merge develop

Reviewed-on: #100
Co-authored-by: dean[백병남] <byungnam.baek@dabeeo.com>
Co-committed-by: dean[백병남] <byungnam.baek@dabeeo.com>

Dockerfile-prod

@@ -0,0 +1,29 @@
+# Stage 1: Build stage (gradle build는 Jenkins에서 이미 수행)
+FROM eclipse-temurin:21-jre-jammy
+
+# GDAL 설치
+RUN apt-get update && apt-get install -y \
+    gdal-bin \
+    libgdal-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+ARG UID=1000
+ARG GID=1000
+
+RUN groupadd -g ${GID} kcomu \
+ && useradd -u ${UID} -g ${GID} -m kcomu
+
+USER kcomu
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# JAR 파일 복사 (Jenkins에서 빌드된 ROOT.jar)
+COPY build/libs/ROOT.jar app.jar
+
+# 포트 노출
+EXPOSE 8080
+
+# 애플리케이션 실행
+# dev 프로파일로 실행
+ENTRYPOINT ["java", "-jar", "-Dspring.profiles.active=prod", "app.jar"]

Dockerfile-prod_bak

@@ -0,0 +1,23 @@
+# Stage 1: Build stage (gradle build는 Jenkins에서 이미 수행)
+FROM kamco-java-gdal:21
+
+ARG UID=1000
+ARG GID=1000
+
+RUN groupadd -g ${GID} kcomu \
+ && useradd -u ${UID} -g ${GID} -m kcomu
+
+USER kcomu
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# JAR 파일 복사 (Jenkins에서 빌드된 ROOT.jar)
+COPY build/libs/ROOT.jar app.jar
+
+# 포트 노출
+EXPOSE 8080
+
+# 애플리케이션 실행
+# dev 프로파일로 실행
+ENTRYPOINT ["java", "-jar", "-Dspring.profiles.active=prod", "app.jar"]

docker-compose-dev.yml

@@ -15,11 +15,7 @@ services:
       - SPRING_PROFILES_ACTIVE=dev
       - TZ=Asia/Seoul
     volumes:
-      - /mnt/nfs_share/images:/app/original-images
+      - /data:/kamco-nfs
-      - /mnt/nfs_share/model_output:/app/model-outputs
-      - /mnt/nfs_share/train_dataset:/app/train-dataset
-      - /mnt/nfs_share/tmp:/app/tmp
-      - /kamco-nfs:/kamco-nfs
     networks:
       - kamco-cds
     restart: unless-stopped

docker-compose-prod.yml

@@ -0,0 +1,44 @@
+services:
+  nginx:
+    image: nginx:alpine
+    container_name: kamco-cd-api-nginx
+    ports:
+      - "12013:443"
+    volumes:
+      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+      - ./nginx/conf.d:/etc/nginx/conf.d:ro
+      - /etc/ssl/certs/globalsign:/etc/ssl/certs/globalsign:ro
+    networks:
+      - kamco-cds
+    restart: unless-stopped
+    depends_on:
+      - kamco-cd-api
+    healthcheck:
+      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 10s
+
+  kamco-cd-api:
+    image: kamco-api-app:260219
+    container_name: kamco-cd-api
+    user: "1000:1000"
+    environment:
+      - SPRING_PROFILES_ACTIVE=prod
+      - TZ=Asia/Seoul
+    volumes:
+      - /data:/kamco-nfs
+    networks:
+      - kamco-cds
+    restart: unless-stopped
+    healthcheck:
+      test: [ "CMD", "curl", "-f", "http://localhost:8080/monitor/health" ]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 40s
+
+networks:
+  kamco-cds:
+    external: true

nginx/README.md

@@ -0,0 +1,122 @@
+# Nginx HTTPS Configuration for KAMCO Change Detection API
+
+## SSL Certificate Setup
+
+### Required Files
+GlobalSign SSL 인증서 파일들을 서버의 `/etc/ssl/certs/globalsign/` 디렉토리에 배치해야 합니다:
+
+```
+/etc/ssl/certs/globalsign/
+├── certificate.crt      # SSL 인증서 파일
+├── private.key          # 개인 키 파일
+└── ca-bundle.crt        # CA 번들 파일 (중간 인증서)
+```
+
+### Certificate Installation Steps
+
+1. **디렉토리 생성**
+```bash
+sudo mkdir -p /etc/ssl/certs/globalsign
+sudo chmod 755 /etc/ssl/certs/globalsign
+```
+
+2. **인증서 파일 복사**
+```bash
+sudo cp your-certificate.crt /etc/ssl/certs/globalsign/certificate.crt
+sudo cp your-private.key /etc/ssl/certs/globalsign/private.key
+sudo cp ca-bundle.crt /etc/ssl/certs/globalsign/ca-bundle.crt
+```
+
+3. **파일 권한 설정**
+```bash
+sudo chmod 644 /etc/ssl/certs/globalsign/certificate.crt
+sudo chmod 600 /etc/ssl/certs/globalsign/private.key
+sudo chmod 644 /etc/ssl/certs/globalsign/ca-bundle.crt
+```
+
+## Configuration Overview
+
+### Service Architecture
+```
+Internet (HTTPS:12013)
+    ↓
+nginx (443 in container)
+    ↓
+kamco-changedetection-api (8080 in container)
+```
+
+### Key Features
+- **HTTPS/TLS**: TLSv1.2, TLSv1.3 지원
+- **Port**: 외부 12013 → 내부 443 (nginx)
+- **Domain**: aicd-api.e-kamco.com:12013
+- **Reverse Proxy**: kamco-changedetection-api:8080으로 프록시
+- **Security Headers**: HSTS, X-Frame-Options, X-Content-Type-Options 등
+- **Health Check**: /health 엔드포인트
+
+## Deployment
+
+### Start Services
+```bash
+docker-compose -f docker-compose-prod.yml up -d
+```
+
+### Check Logs
+```bash
+# Nginx logs
+docker logs kamco-cd-nginx
+
+# API logs
+docker logs kamco-changedetection-api
+```
+
+### Verify Configuration
+```bash
+# Test nginx configuration
+docker exec kamco-cd-nginx nginx -t
+
+# Check SSL certificate
+docker exec kamco-cd-nginx openssl s_client -connect localhost:443 -servername aicd-api.e-kamco.com
+```
+
+### Access Service
+```bash
+# HTTPS Access
+curl -k https://aicd-api.e-kamco.com:12013/monitor/health
+
+# Health Check
+curl -k https://aicd-api.e-kamco.com:12013/health
+```
+
+## Troubleshooting
+
+### Certificate Issues
+인증서 파일이 제대로 마운트되었는지 확인:
+```bash
+docker exec kamco-cd-nginx ls -la /etc/ssl/certs/globalsign/
+```
+
+### Nginx Configuration Test
+```bash
+docker exec kamco-cd-nginx nginx -t
+```
+
+### Connection Test
+```bash
+# Check if nginx is listening
+docker exec kamco-cd-nginx netstat -tlnp | grep 443
+
+# Check backend connection
+docker exec kamco-cd-nginx wget --spider http://kamco-changedetection-api:8080/monitor/health
+```
+
+## Configuration Files
+
+- `nginx/nginx.conf`: Main nginx configuration
+- `nginx/conf.d/default.conf`: Server block with SSL and proxy settings
+- `docker-compose-prod.yml`: Docker compose with nginx service
+
+## Notes
+
+- 인증서 파일명이 다를 경우 `nginx/conf.d/default.conf`에서 경로를 수정하세요
+- 인증서 갱신 시 nginx 컨테이너를 재시작하세요: `docker restart kamco-cd-nginx`
+- 포트 12013이 방화벽에서 허용되어 있는지 확인하세요

nginx/conf.d/default.conf

@@ -0,0 +1,60 @@
+upstream kamco_api {
+    server kamco-cd-api:8080;
+}
+
+server {
+    listen 443 ssl http2;
+    server_name aicd-api.e-kamco.com;
+
+    # GlobalSign SSL Certificate
+    ssl_certificate /etc/ssl/certs/globalsign/certificate.crt;
+    ssl_certificate_key /etc/ssl/certs/globalsign/private.key;
+
+    # SSL Configuration
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_ciphers HIGH:!aNULL:!MD5;
+    ssl_prefer_server_ciphers on;
+    ssl_session_cache shared:SSL:10m;
+    ssl_session_timeout 10m;
+
+    # Security Headers
+    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+
+    # Client Body Size
+    client_max_body_size 100M;
+
+    # Proxy Settings
+    location / {
+        proxy_pass http://kamco_api;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Forwarded-Host $host;
+        proxy_set_header X-Forwarded-Port $server_port;
+
+        # Timeouts
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 60s;
+
+        # WebSocket Support (if needed)
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+
+    # Health Check Endpoint
+    location /health {
+        access_log off;
+        return 200 "OK";
+        add_header Content-Type text/plain;
+    }
+
+    # Access and Error Logs
+    access_log /var/log/nginx/kamco-api-access.log;
+    error_log /var/log/nginx/kamco-api-error.log;
+}

nginx/nginx.conf

@@ -0,0 +1,33 @@
+user  nginx;
+worker_processes  auto;
+
+error_log  /var/log/nginx/error.log warn;
+pid        /var/run/nginx.pid;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+
+    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                      '$status $body_bytes_sent "$http_referer" '
+                      '"$http_user_agent" "$http_x_forwarded_for"';
+
+    access_log  /var/log/nginx/access.log  main;
+
+    sendfile        on;
+    tcp_nopush      on;
+    tcp_nodelay     on;
+    keepalive_timeout  65;
+    types_hash_max_size 2048;
+
+    gzip  on;
+    gzip_vary on;
+    gzip_min_length 1024;
+    gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/json;
+
+    include /etc/nginx/conf.d/*.conf;
+}

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

@@ -18,12 +18,13 @@ import org.springframework.web.filter.OncePerRequestFilter;
 @RequiredArgsConstructor
 public class JwtAuthenticationFilter extends OncePerRequestFilter {
 
-  private final JwtTokenProvider jwtTokenProvider;
-  private final UserDetailsService userDetailsService;
   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/members/*/password"
+    "/api/auth/signin", "/api/auth/refresh", "/api/auth/logout"
   };
+  private final JwtTokenProvider jwtTokenProvider;
+  private final UserDetailsService userDetailsService;
 
   @Override
   protected void doFilterInternal(

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

@@ -146,4 +146,53 @@ public class ChangeDetectionApiController {
     return ApiResponseDto.ok(
         changeDetectionService.getChangeDetectionPointList(type, scale, uuid, mapSheetNum));
   }
+
+  @Operation(summary = "선택 변화탐지 결과 uuid 조회", description = "선택 변화탐지 결과 uuid 조회")
+  @GetMapping("/selected/uuid")
+  public ApiResponseDto<UUID> getChnDtctIdUuid(
+      @Parameter(description = "회차 32자 uid", example = "98ABAA1FC4394F11885C302C19AE5E81")
+          @RequestParam
+          String chnDtctId) {
+    return ApiResponseDto.ok(changeDetectionService.getLearnUuid(chnDtctId));
+  }
+
+  @Operation(summary = "선택 변화탐지 결과 Polygon", description = "선택 변화탐지 결과 Polygon")
+  @GetMapping("/selected/polygon")
+  public ApiResponseDto<ChangeDetectionDto.PolygonFeatureList> getCdPolygonList(
+      @Parameter(description = "회차 32자 uid", example = "98ABAA1FC4394F11885C302C19AE5E81")
+          @RequestParam
+          String chnDtctId,
+      @Parameter(description = "polygon 32자 uid", example = "3B1A7E5F895A4D9698489540EE1BBE1E")
+          @RequestParam
+          String cdObjectId,
+      @Parameter(
+              description = "polygon 32자 uids",
+              example =
+                  "3B1A7E5F895A4D9698489540EE1BBE1E,3B221A2AF9614647A0903A972D56C574,3B22686A7ACE44FC9CB20F1B4FA6DEFD,3B376D94A183479BB5FBE3D7166E6E1A")
+          @RequestParam
+          List<String> cdObjectIds,
+      @Parameter(description = "pnu") @RequestParam(required = false) String pnu) {
+    return ApiResponseDto.ok(
+        changeDetectionService.getPolygonListByCd(chnDtctId, cdObjectId, cdObjectIds, pnu));
+  }
+
+  @Operation(summary = "선택 변화탐지 결과 Point", description = "선택 변화탐지 결과 Point")
+  @GetMapping("/selected/point")
+  public ApiResponseDto<ChangeDetectionDto.PointFeatureList> getCdPointList(
+      @Parameter(description = "회차 32자 uid", example = "98ABAA1FC4394F11885C302C19AE5E81")
+          @RequestParam
+          String chnDtctId,
+      @Parameter(description = "polygon 32자 uid", example = "3B1A7E5F895A4D9698489540EE1BBE1E")
+          @RequestParam
+          String cdObjectId,
+      @Parameter(
+              description = "polygon 32자 uids",
+              example =
+                  "3B1A7E5F895A4D9698489540EE1BBE1E,3B221A2AF9614647A0903A972D56C574,3B22686A7ACE44FC9CB20F1B4FA6DEFD,3B376D94A183479BB5FBE3D7166E6E1A")
+          @RequestParam
+          List<String> cdObjectIds,
+      @Parameter(description = "pnu") @RequestParam(required = false) String pnu) {
+    return ApiResponseDto.ok(
+        changeDetectionService.getPointListByCd(chnDtctId, cdObjectId, cdObjectIds, pnu));
+  }
 }

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

@@ -197,6 +197,8 @@ public class ChangeDetectionDto {
     private Double afterConfidence; // 비교 신뢰도(확률)
     private String afterClass;
     private Double cdProb; // 탐지정확도
+    private UUID uuid;
+    private String resultUid;
   }
 
   @Schema(name = "PointFeature", description = "Geometry 리턴 객체")
@@ -250,5 +252,21 @@ public class ChangeDetectionDto {
     private Double afterConfidence; // 비교 신뢰도(확률)
     private String afterClass; // 비교 분류
     private Double cdProb; // 탐지 정확도
+    private UUID uuid;
+    private String uid;
+  }
+
+  @Schema(name = "ChangeDetectionMapDto", description = "변화지도 팝업 검색조건")
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class ChangeDetectionMapDto {
+    private Integer compareYyyy;
+    private Integer targetYyyy;
+    private String cdObjectId;
+    private List<String> cdObjectIds;
+    private String chnDtctId;
+    private String pnu;
   }
 }

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

@@ -89,4 +89,42 @@ public class ChangeDetectionService {
       default -> throw new IllegalArgumentException("Unsupported type: " + type);
     }
   }
+
+  /**
+   * 선택 폴리곤 정보 조회
+   *
+   * @param chnDtctId
+   * @param cdObjectId
+   * @param cdObjectIds
+   * @param pnu
+   * @return
+   */
+  public ChangeDetectionDto.PolygonFeatureList getPolygonListByCd(
+      String chnDtctId, String cdObjectId, List<String> cdObjectIds, String pnu) {
+    return changeDetectionCoreService.getPolygonListByCd(chnDtctId, cdObjectId, cdObjectIds);
+  }
+
+  /**
+   * 선택 Point 조회
+   *
+   * @param chnDtctId
+   * @param cdObjectId
+   * @param cdObjectIds
+   * @param pnu
+   * @return
+   */
+  public ChangeDetectionDto.PointFeatureList getPointListByCd(
+      String chnDtctId, String cdObjectId, List<String> cdObjectIds, String pnu) {
+    return changeDetectionCoreService.getPointListByCd(chnDtctId, cdObjectId, cdObjectIds);
+  }
+
+  /**
+   * Learn uuid 조회
+   *
+   * @param chnDtctId
+   * @return uuid
+   */
+  public UUID getLearnUuid(String chnDtctId) {
+    return changeDetectionCoreService.getLearnUuid(chnDtctId);
+  }
 }

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

@@ -0,0 +1,92 @@
+package com.kamco.cd.kamcoback.common.download;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+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.repository.log.AuditLogRepository;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Objects;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.event.EventListener;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class DownloadAuditEventListener {
+
+  private final AuditLogRepository auditLogRepository;
+  private final MenuService menuService;
+  private final ObjectMapper objectMapper;
+
+  @Async("auditLogExecutor")
+  @Transactional(propagation = Propagation.REQUIRES_NEW)
+  @EventListener
+  public void onDownloadAudit(DownloadAuditEvent ev) {
+    try {
+      String menuUid = resolveMenuUid(ev.normalizedUri());
+      if (menuUid == null) {
+        // menuUid null 불가 -> 스킵
+        log.warn(
+            "MenuUid not resolved. skip audit. uri={}, normalized={}",
+            ev.requestUri(),
+            ev.normalizedUri());
+        return;
+      }
+
+      AuditLogEntity logEntity =
+          AuditLogEntity.forFileDownload(
+              ev.userId(), ev.requestUri(), menuUid, ev.ip(), ev.status(), ev.downloadUuid());
+
+      auditLogRepository.save(logEntity);
+
+    } catch (Exception e) {
+      // 본 요청과 분리되어야 함
+      log.warn("Download audit save failed. uri={}, err={}", ev.requestUri(), e.toString());
+    }
+  }
+
+  private String resolveMenuUid(String normalizedUri) {
+    try {
+      List<?> list = menuService.getFindAll();
+
+      List<MenuDto.Basic> basics =
+          list.stream()
+              .map(
+                  item -> {
+                    if (item instanceof LinkedHashMap<?, ?> map) {
+                      return objectMapper.convertValue(map, MenuDto.Basic.class);
+                    } else if (item instanceof MenuDto.Basic dto) {
+                      return dto;
+                    }
+                    return null;
+                  })
+              .filter(Objects::nonNull)
+              .toList();
+
+      MenuDto.Basic basic =
+          basics.stream()
+              .filter(m -> m.getMenuUrl() != null && normalizedUri.startsWith(m.getMenuUrl()))
+              .max(Comparator.comparingInt(m -> m.getMenuUrl().length()))
+              .orElse(null);
+
+      if (basic == null) return null;
+
+      String menuUidStr = basic.getMenuUid(); // ← String
+      if (menuUidStr == null || menuUidStr.isBlank()) return null;
+
+      return menuUidStr; // ← Long 변환
+
+    } catch (Exception e) {
+      return null;
+    }
+  }
+}

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

@@ -0,0 +1,19 @@
+package com.kamco.cd.kamcoback.common.download;
+
+import org.springframework.util.AntPathMatcher;
+
+public final class DownloadPaths {
+  private DownloadPaths() {}
+
+  public static final String[] PATTERNS = {
+    "/api/inference/download/**", "/api/training-data/stage/download/**"
+  };
+
+  public static boolean matches(String uri) {
+    AntPathMatcher m = new AntPathMatcher();
+    for (String p : PATTERNS) {
+      if (m.match(p, uri)) return true;
+    }
+    return false;
+  }
+}

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

@@ -0,0 +1,79 @@
+package com.kamco.cd.kamcoback.common.download;
+
+import jakarta.servlet.http.HttpServletRequest;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import org.springframework.core.io.FileSystemResource;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.support.ResourceRegion;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpRange;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+
+@Component
+public class RangeDownloadResponder {
+
+  public ResponseEntity<?> buildZipResponse(
+      Path filePath, String downloadFileName, HttpServletRequest request) throws IOException {
+
+    if (!Files.isRegularFile(filePath)) {
+      return ResponseEntity.notFound().build();
+    }
+
+    long totalSize = Files.size(filePath);
+    Resource resource = new FileSystemResource(filePath);
+
+    String disposition = "attachment; filename=\"" + downloadFileName + "\"";
+    String rangeHeader = request.getHeader(HttpHeaders.RANGE);
+
+    // 🔥 공통 헤더 (여기 고정)
+    ResponseEntity.BodyBuilder base =
+        ResponseEntity.ok()
+            .contentType(MediaType.APPLICATION_OCTET_STREAM)
+            .header(HttpHeaders.CONTENT_DISPOSITION, disposition)
+            .header(HttpHeaders.ACCEPT_RANGES, "bytes")
+            .header("X-Accel-Buffering", "no");
+
+    if (rangeHeader == null || rangeHeader.isBlank()) {
+      return base.contentLength(totalSize).body(resource);
+    }
+
+    List<HttpRange> ranges;
+    try {
+      ranges = HttpRange.parseRanges(rangeHeader);
+    } catch (IllegalArgumentException ex) {
+      return ResponseEntity.status(416)
+          .header(HttpHeaders.CONTENT_RANGE, "bytes */" + totalSize)
+          .header("X-Accel-Buffering", "no")
+          .build();
+    }
+
+    HttpRange range = ranges.get(0);
+
+    long start = range.getRangeStart(totalSize);
+    long end = range.getRangeEnd(totalSize);
+
+    if (start >= totalSize) {
+      return ResponseEntity.status(416)
+          .header(HttpHeaders.CONTENT_RANGE, "bytes */" + totalSize)
+          .header("X-Accel-Buffering", "no")
+          .build();
+    }
+
+    long regionLength = end - start + 1;
+    ResourceRegion region = new ResourceRegion(resource, start, regionLength);
+
+    return ResponseEntity.status(206)
+        .contentType(MediaType.APPLICATION_OCTET_STREAM)
+        .header(HttpHeaders.CONTENT_DISPOSITION, disposition)
+        .header(HttpHeaders.ACCEPT_RANGES, "bytes")
+        .header("X-Accel-Buffering", "no")
+        .header(HttpHeaders.CONTENT_RANGE, "bytes " + start + "-" + end + "/" + totalSize)
+        .contentLength(regionLength)
+        .body(region);
+  }
+}

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

@@ -0,0 +1,11 @@
+package com.kamco.cd.kamcoback.common.download.dto;
+
+import java.util.UUID;
+
+public record DownloadAuditEvent(
+    Long userId,
+    String requestUri,
+    String normalizedUri,
+    String ip,
+    int status,
+    UUID downloadUuid) {}

src/main/java/com/kamco/cd/kamcoback/common/enums/CrsType.java

@@ -0,0 +1,27 @@
+package com.kamco.cd.kamcoback.common.enums;
+
+import com.kamco.cd.kamcoback.common.utils.enums.CodeExpose;
+import com.kamco.cd.kamcoback.common.utils.enums.EnumType;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@CodeExpose
+@Getter
+@AllArgsConstructor
+public enum CrsType implements EnumType {
+  EPSG_3857("Web Mercator, 웹지도 미터(EPSG:900913 동일)"),
+  EPSG_4326("WGS84 위경도, GeoJSON/OSM 기본"),
+  EPSG_5186("Korea 2000 중부 TM, 한국 SHP");
+
+  private final String desc;
+
+  @Override
+  public String getId() {
+    return name();
+  }
+
+  @Override
+  public String getText() {
+    return desc;
+  }
+}

src/main/java/com/kamco/cd/kamcoback/common/exception/CustomApiException.java

@@ -27,4 +27,10 @@ public class CustomApiException extends RuntimeException {
     this.codeName = errorCode.getCode();
     this.status = errorCode.getStatus();
   }
+
+  public CustomApiException(String codeName, HttpStatus status, Throwable cause) {
+    super(codeName, cause);
+    this.codeName = codeName;
+    this.status = status;
+  }
 }

src/main/java/com/kamco/cd/kamcoback/common/service/ExternalJarRunner.java

@@ -7,11 +7,14 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import lombok.extern.log4j.Log4j2;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 
 @Log4j2
 @Component
 public class ExternalJarRunner {
+  @Value("${spring.profiles.active}")
+  private String profile;
 
   private static final long TIMEOUT_MINUTES = TimeUnit.DAYS.toMinutes(3);
 
@@ -40,7 +43,7 @@ public class ExternalJarRunner {
     if (mode != null && !mode.isEmpty()) {
       addArg(args, "converter.mode", mode);
     }
-
+    addArg(args, "spring.profiles.active", profile);
     execJar(jarPath, args);
   }
 
@@ -54,9 +57,10 @@ public class ExternalJarRunner {
   public void run(String jarPath, String register, String layer) {
     List<String> args = new ArrayList<>();
 
-    addArg(args, "register", register);
+    addArg(args, "upload-shp", register);
-    addArg(args, "layer", layer);
+    //    addArg(args, "layer", layer);
 
+    addArg(args, "spring.profiles.active", profile);
     execJar(jarPath, args);
   }
 

src/main/java/com/kamco/cd/kamcoback/common/utils/FIleChecker.java

@@ -279,18 +279,28 @@ public class FIleChecker {
     return true;
   }
 
-  public static List<Folder> getFolderAll(String dirPath, String sortType, int maxDepth) {
+  // kamco-nfs를 확인하는곳이 있어서 파라미터 추가 사용용도확인후 처리
+  public static List<Folder> getFolderAll(
+      String dirPath, String sortType, int maxDepth, String nfsRootDir) {
 
     Path startPath = Paths.get(dirPath);
 
     List<Folder> folderList = List.of();
 
-    try (Stream<Path> stream = Files.walk(startPath, maxDepth)) {
+    log.info("[FIND_FOLDER] DIR : {} {} {} {}", dirPath, sortType, maxDepth, startPath);
 
+    int childDirCount = getChildFolderCount(startPath.toFile());
+    log.info("[FIND_FOLDER] START_PATH_CHILD_DIR_COUNT : {}", childDirCount);
+
+    try (Stream<Path> stream = Files.walk(startPath, maxDepth)) {
       folderList =
           stream
               .filter(Files::isDirectory)
-              .filter(p -> !p.toString().equals(dirPath))
+              .filter(
+                  p ->
+                      !p.toAbsolutePath()
+                          .normalize()
+                          .equals(startPath.toAbsolutePath().normalize()))
               .map(
                   path -> {
                     int depth = path.getNameCount();
@@ -300,11 +310,12 @@ public class FIleChecker {
                     String parentPath = path.getParent().toString();
                     String fullPath = path.toAbsolutePath().toString();
 
-                    boolean isValid =
+                    // 이것이 필요한건가?
-                        !NameValidator.containsKorean(folderNm)
+                    //                    boolean isShowHide =
-                            && !NameValidator.containsWhitespaceRegex(folderNm)
+                    //                      !parentFolderNm.equals("kamco-nfs"); // 폴더 리스트에
-                            && !parentFolderNm.equals("kamco-nfs");
+                    // kamco-nfs 하위만 나오도록 처리
-
+                    boolean isShowHide =
+                        !parentFolderNm.equals(nfsRootDir); // 폴더 리스트에 nfsRootDir 하위만 나오도록 처리
                     File file = new File(fullPath);
                     int childCnt = getChildFolderCount(file);
                     String lastModified = getLastModified(file);
@@ -317,7 +328,7 @@ public class FIleChecker {
                         depth,
                         childCnt,
                         lastModified,
-                        isValid);
+                        isShowHide);
                   })
               .collect(Collectors.toList());
 
@@ -352,24 +363,8 @@ public class FIleChecker {
     return folderList;
   }
 
-  public static List<Folder> getFolderAll(String dirPath) {
+  public static List<Folder> getFolderAll(String dirPath, String nfsRootDir) {
-    return getFolderAll(dirPath, "name", 1);
+    return getFolderAll(dirPath, "name", 1, nfsRootDir);
-  }
-
-  public static List<Folder> getFolderAll(String dirPath, String sortType) {
-    return getFolderAll(dirPath, sortType, 1);
-  }
-
-  public static int getChildFolderCount(String dirPath) {
-    File directory = new File(dirPath);
-    File[] childFolders = directory.listFiles(File::isDirectory);
-
-    int childCnt = 0;
-    if (childFolders != null) {
-      childCnt = childFolders.length;
-    }
-
-    return childCnt;
   }
 
   public static int getChildFolderCount(File directory) {
@@ -383,11 +378,6 @@ public class FIleChecker {
     return childCnt;
   }
 
-  public static String getLastModified(String dirPath) {
-    File file = new File(dirPath);
-    return dttmFormat.format(new Date(file.lastModified()));
-  }
-
   public static String getLastModified(File file) {
     return dttmFormat.format(new Date(file.lastModified()));
   }

src/main/java/com/kamco/cd/kamcoback/common/utils/NetUtils.java

@@ -5,11 +5,9 @@ import java.net.InetAddress;
 import java.net.URLEncoder;
 import java.net.UnknownHostException;
 import java.nio.charset.StandardCharsets;
-import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import org.springframework.http.HttpHeaders;
-import org.springframework.http.MediaType;
 
 public class NetUtils {
 
@@ -56,9 +54,8 @@ public class NetUtils {
 
   public HttpHeaders jsonHeaders() {
     HttpHeaders headers = new HttpHeaders();
-    headers.setContentType(MediaType.APPLICATION_JSON);
+    headers.set(HttpHeaders.ACCEPT, "application/json;charset=UTF-8");
-    headers.setAccept(List.of(MediaType.APPLICATION_JSON));
+    headers.set(HttpHeaders.CONTENT_TYPE, "application/json;charset=UTF-8");
-
     return headers;
   }
 }

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

@@ -1,92 +1,64 @@
 package com.kamco.cd.kamcoback.config;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
+import com.kamco.cd.kamcoback.common.download.dto.DownloadAuditEvent;
-import com.kamco.cd.kamcoback.auth.CustomUserDetails;
+import com.kamco.cd.kamcoback.common.utils.UserUtil;
-import com.kamco.cd.kamcoback.common.utils.HeaderUtil;
 import com.kamco.cd.kamcoback.config.api.ApiLogFunction;
-import com.kamco.cd.kamcoback.menu.dto.MenuDto;
+import jakarta.servlet.DispatcherType;
-import com.kamco.cd.kamcoback.menu.service.MenuService;
-import com.kamco.cd.kamcoback.postgres.entity.AuditLogEntity;
-import com.kamco.cd.kamcoback.postgres.repository.log.AuditLogRepository;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
-import java.util.Comparator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Objects;
 import java.util.UUID;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.stereotype.Component;
 import org.springframework.web.servlet.HandlerInterceptor;
 
 @Slf4j
 @Component
+@RequiredArgsConstructor
 public class FileDownloadInteceptor implements HandlerInterceptor {
 
-  private final AuditLogRepository auditLogRepository;
+  private final ApplicationEventPublisher publisher;
-  private final MenuService menuService;
+  private final UserUtil userUtil;
-
-  @Autowired private ObjectMapper objectMapper;
-
-  public FileDownloadInteceptor(AuditLogRepository auditLogRepository, MenuService menuService) {
-    this.auditLogRepository = auditLogRepository;
-    this.menuService = menuService;
-  }
 
   @Override
   public void afterCompletion(
       HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
 
-    // 파일 다운로드 API만 필터링
+    String uri = request.getRequestURI();
-    if (!request.getRequestURI().contains("/download")) {
+    if (uri == null || !uri.contains("/download")) return;
+    if (request.getDispatcherType() != DispatcherType.REQUEST) return;
+
+    Long userId;
+    try {
+      userId = userUtil.getId();
+      if (userId == null) return; // userId null 불가면 스킵
+    } catch (Exception e) {
+      log.warn("Download audit userId resolve failed. uri={}, err={}", uri, e.toString());
       return;
     }
 
-    Long userId = extractUserId(request);
     String ip = ApiLogFunction.getClientIp(request);
+    int status = response.getStatus();
+    String normalizedUri = uri.replace("/api", "");
 
-    List<?> list = menuService.getFindAll();
+    UUID downloadUuid = extractUuidFromUri(uri);
-    List<MenuDto.Basic> result =
+    if (downloadUuid == null) {
-        list.stream()
+      log.warn("Download UUID parse failed. uri={}", uri);
-            .map(
+      return; // downloadUuid null 불가 -> 스킵
-                item -> {
+    }
-                  if (item instanceof LinkedHashMap<?, ?> map) {
-                    return objectMapper.convertValue(map, MenuDto.Basic.class);
-                  } else if (item instanceof MenuDto.Basic dto) {
-                    return dto;
-                  } else {
-                    throw new IllegalStateException("Unsupported cache type: " + item.getClass());
-                  }
-                })
-            .toList();
 
-    String normalizedUri = request.getRequestURI().replace("/api", "");
+    publisher.publishEvent(
-    MenuDto.Basic basic =
+        new DownloadAuditEvent(userId, uri, normalizedUri, ip, status, downloadUuid));
-        result.stream()
-            .filter(
-                menu -> menu.getMenuUrl() != null && normalizedUri.startsWith(menu.getMenuUrl()))
-            .max(Comparator.comparingInt(m -> m.getMenuUrl().length()))
-            .orElse(null);
-
-    AuditLogEntity log =
-        AuditLogEntity.forFileDownload(
-            userId,
-            request.getRequestURI(),
-            Objects.requireNonNull(basic).getMenuUid(),
-            ip,
-            response.getStatus(),
-            UUID.fromString(HeaderUtil.get(request, "kamco-download-uuid")));
-
-    auditLogRepository.save(log);
   }
 
-  private Long extractUserId(HttpServletRequest request) {
+  private UUID extractUuidFromUri(String uri) {
-    if (request.getUserPrincipal() instanceof UsernamePasswordAuthenticationToken auth
+    try {
-        && auth.getPrincipal() instanceof CustomUserDetails userDetails) {
+      String[] parts = uri.split("/");
-      return userDetails.getMember().getId();
+      String last = parts[parts.length - 1];
+      return UUID.fromString(last);
+    } catch (Exception e) {
+      return null;
     }
-    return null;
   }
 }

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

@@ -465,8 +465,7 @@ public class GlobalExceptionHandler {
     String stackTraceStr =
         Arrays.stream(stackTrace)
             .map(StackTraceElement::toString)
-            .collect(Collectors.joining("\n"))
+            .collect(Collectors.joining("\n"));
-            .substring(0, 255);
 
     String actionType = HeaderUtil.get(request, "kamco-action-type");
 

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

@@ -24,7 +24,7 @@ public class OpenApiConfig {
   @Value("${swagger.dev-url:https://kamco.dev-api.gs.dabeeo.com}")
   private String devUrl;
 
-  @Value("${swagger.prod-url:https://api.kamco.com}")
+  @Value("${swagger.prod-url:https://aicd-api.e-kamco.com:12013}")
   private String prodUrl;
 
   @Bean
@@ -51,9 +51,9 @@ public class OpenApiConfig {
       servers.add(new Server().url("http://localhost:" + serverPort).description("로컬 서버"));
       //      servers.add(new Server().url(prodUrl).description("운영 서버"));
     } else if ("prod".equals(profile)) {
-      //      servers.add(new Server().url(prodUrl).description("운영 서버"));
+      servers.add(new Server().url(prodUrl).description("운영 서버"));
       servers.add(new Server().url("http://localhost:" + serverPort).description("로컬 서버"));
-      servers.add(new Server().url(devUrl).description("개발 서버"));
+
     } else {
       servers.add(new Server().url("http://localhost:" + serverPort).description("로컬 서버"));
       servers.add(new Server().url(devUrl).description("개발 서버"));

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

@@ -3,6 +3,8 @@ package com.kamco.cd.kamcoback.config;
 import com.kamco.cd.kamcoback.auth.CustomAuthenticationProvider;
 import com.kamco.cd.kamcoback.auth.JwtAuthenticationFilter;
 import com.kamco.cd.kamcoback.auth.MenuAuthorizationManager;
+import com.kamco.cd.kamcoback.common.download.DownloadPaths;
+import jakarta.servlet.DispatcherType;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Bean;
@@ -44,9 +46,11 @@ public class SecurityConfig {
         .authorizeHttpRequests(
             auth ->
                 auth
+
                     // .requestMatchers("/chunk_upload_test.html").authenticated()
                     .requestMatchers("/monitor/health", "/monitor/health/**")
                     .permitAll()
+
                     // 맵시트 영역 전체 허용 (우선순위 최상단)
                     .requestMatchers("/api/mapsheet/**")
                     .permitAll()
@@ -67,44 +71,55 @@ public class SecurityConfig {
                     .requestMatchers("/api/test/review")
                     .hasAnyRole("ADMIN", "REVIEWER")
 
+                    // ASYNC/ERROR 재디스패치는 막지 않기 (다운로드/스트리밍에서 필수)
+                    .dispatcherTypeMatchers(DispatcherType.ASYNC, DispatcherType.ERROR)
+                    .permitAll()
+
+                    // 다운로드는 인증 필요
+                    .requestMatchers(HttpMethod.GET, DownloadPaths.PATTERNS)
+                    .authenticated()
+
                     // 메뉴 등록 ADMIN만 가능
                     .requestMatchers(HttpMethod.POST, "/api/menu/auth")
                     .hasAnyRole("ADMIN")
+
+                    // 에러 경로는 항상 허용 (이미 있지만 유지)
                     .requestMatchers("/error")
                     .permitAll()
+
+                    // preflight 허용
                     .requestMatchers(HttpMethod.OPTIONS, "/**")
-                    .permitAll() // preflight 허용
+                    .permitAll()
                     .requestMatchers(
                         "/api/auth/signin",
                         "/api/auth/refresh",
                         "/api/auth/logout",
                         "/swagger-ui/**",
-                        "/api/members/*/password",
                         "/v3/api-docs/**",
                         "/chunk_upload_test.html",
+                        "/download_progress_test.html",
                         "/api/model/file-chunk-upload",
                         "/api/upload/file-chunk-upload",
                         "/api/upload/chunk-upload-complete",
-                        "/api/change-detection/**")
+                        "/api/change-detection/**",
+                        "/api/layer/map/**",
+                        "/api/layer/tile-url",
+                        "/api/layer/tile-url-year",
+                        "/api/common-code/clazz")
                     .permitAll()
                     // 로그인한 사용자만 가능 IAM
                     .requestMatchers(
                         "/api/user/**",
                         "/api/my/menus",
-                        "/api/common-code/**",
+                        "/api/members/*/password",
                         "/api/training-data/label/**",
                         "/api/training-data/review/**")
                     .authenticated()
-                    .anyRequest()
-                    .access(menuAuthorizationManager)
 
-            //                    .authenticated()
+                    // 나머지는 메뉴권한
-            )
+                    .anyRequest()
-        .addFilterBefore(
+                    .access(menuAuthorizationManager))
-            jwtAuthenticationFilter,
+        .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
-            UsernamePasswordAuthenticationFilter
-                .class) // 요청 들어오면 먼저 JWT 토큰 검사 후 security context 에 사용자 정보 저장.
-    ;
 
     return http.build();
   }
@@ -115,23 +130,18 @@ public class SecurityConfig {
     return configuration.getAuthenticationManager();
   }
 
-  /**
+  /** CORS 설정 */
-   * CORS 설정
-   *
-   * @return
-   */
   @Bean
   public CorsConfigurationSource corsConfigurationSource() {
-    CorsConfiguration config = new CorsConfiguration(); // CORS 객체 생성
+    CorsConfiguration config = new CorsConfiguration();
-    config.setAllowedOriginPatterns(List.of("*")); // 도메인 허용
+    config.setAllowedOriginPatterns(List.of("*"));
     config.setAllowedMethods(List.of("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"));
-    config.setAllowedHeaders(List.of("*")); // 헤더요청 Authorization, Content-Type, X-Custom-Header
+    config.setAllowedHeaders(List.of("*"));
-    config.setAllowCredentials(true); // 쿠키, Authorization 헤더, Bearer Token 등 자격증명 포함 요청을 허용할지 설정
+    config.setAllowCredentials(true);
     config.setExposedHeaders(List.of("Content-Disposition"));
 
     UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
-    /** "/**" → 모든 API 경로에 대해 이 CORS 규칙을 적용 /api/** 같이 특정 경로만 지정 가능. */
+    source.registerCorsConfiguration("/**", config);
-    source.registerCorsConfiguration("/**", config); // CORS 정책을 등록
     return source;
   }
 

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

@@ -2,6 +2,7 @@ package com.kamco.cd.kamcoback.config;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.kamco.cd.kamcoback.common.download.DownloadPaths;
 import com.kamco.cd.kamcoback.common.utils.geometry.GeometryDeserializer;
 import com.kamco.cd.kamcoback.common.utils.geometry.GeometrySerializer;
 import org.locationtech.jts.geom.Geometry;
@@ -39,9 +40,6 @@ public class WebConfig implements WebMvcConfigurer {
 
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
-    registry
+    registry.addInterceptor(fileDownloadInteceptor).addPathPatterns(DownloadPaths.PATTERNS);
-        .addInterceptor(fileDownloadInteceptor)
-        .addPathPatterns("/api/inference/download/**") // 추론 파일 다운로드
-        .addPathPatterns("/api/training-data/stage/download/**"); // 학습데이터 다운로드
   }
 }

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

@@ -1,5 +1,6 @@
 package com.kamco.cd.kamcoback.config.api;
 
+import com.kamco.cd.kamcoback.common.download.DownloadPaths;
 import jakarta.servlet.FilterChain;
 import jakarta.servlet.ServletException;
 import jakarta.servlet.http.HttpServletRequest;
@@ -16,6 +17,14 @@ public class ApiLogFilter extends OncePerRequestFilter {
   protected void doFilterInternal(
       HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
       throws ServletException, IOException {
+
+    String uri = request.getRequestURI();
+
+    if (DownloadPaths.matches(uri)) {
+      filterChain.doFilter(request, response);
+      return;
+    }
+
     ContentCachingRequestWrapper wrappedRequest = new ContentCachingRequestWrapper(request);
 
     ContentCachingResponseWrapper wrappedResponse = new ContentCachingResponseWrapper(response);

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

@@ -1,72 +1,120 @@
 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.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Component;
-import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.HttpStatusCodeException;
-import org.springframework.web.client.HttpServerErrorException;
 import org.springframework.web.client.RestTemplate;
 
+@RequiredArgsConstructor
 @Component
 @Log4j2
-@RequiredArgsConstructor
 public class ExternalHttpClient {
 
   private final RestTemplate restTemplate;
+  private final ObjectMapper objectMapper;
 
   public <T> ExternalCallResult<T> call(
       String url, HttpMethod method, Object body, HttpHeaders headers, Class<T> responseType) {
 
-    HttpEntity<Object> entity = new HttpEntity<>(body, headers);
+    // responseType 기반으로 Accept 동적 세팅
+    HttpHeaders resolvedHeaders = resolveHeaders(headers, responseType);
+    logRequestBody(body);
 
-    // 요청 로그
+    HttpEntity<Object> entity = new HttpEntity<>(body, resolvedHeaders);
-    log.info("[HTTP-REQ] {} {}", method, url);
-    if (body != null) {
-      log.debug("[HTTP-REQ-BODY] {}", body);
-    }
 
     try {
+      // String: raw bytes -> UTF-8 string
+      if (responseType == String.class) {
+        ResponseEntity<byte[]> res = restTemplate.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이면 에러로 처리
+      if (responseType == byte[].class) {
+        ResponseEntity<byte[]> res = restTemplate.exchange(url, method, entity, byte[].class);
+
+        MediaType ct = res.getHeaders().getContentType();
+        byte[] bytes = res.getBody();
+
+        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);
+      return new ExternalCallResult<>(res.getStatusCodeValue(), true, res.getBody(), null);
 
-      int code = res.getStatusCodeValue();
+    } catch (HttpStatusCodeException e) {
-
+      return new ExternalCallResult<>(
-      // 응답 로그
+          e.getStatusCode().value(), false, null, e.getResponseBodyAsString());
-      log.info("[HTTP-RES] {} {} -> {}", method, url, code);
-      log.debug("[HTTP-RES-BODY] {}", res.getBody());
-
-      return new ExternalCallResult<>(code, code >= 200 && code < 300, res.getBody());
-
-    } catch (HttpClientErrorException.NotFound e) {
-      log.info("[HTTP-RES] {} {} -> 404 (Not Found)", method, url);
-      log.debug("[HTTP-RES-BODY] {}", e.getResponseBodyAsString());
-
-      return new ExternalCallResult<>(404, false, null);
-
-    } catch (HttpClientErrorException e) {
-      // 기타 4xx
-      log.warn(
-          "[HTTP-ERR] {} {} -> {} body={}",
-          method,
-          url,
-          e.getStatusCode().value(),
-          e.getResponseBodyAsString());
-      throw e;
-
-    } catch (HttpServerErrorException e) {
-      // 5xx
-      log.error(
-          "[HTTP-ERR] {} {} -> {} body={}",
-          method,
-          url,
-          e.getStatusCode().value(),
-          e.getResponseBodyAsString());
-      throw e;
     }
   }
 
-  public record ExternalCallResult<T>(int statusCode, boolean success, T body) {}
+  // 기존 resolveJsonHeaders를 "동적"으로 교체
+  private HttpHeaders resolveHeaders(HttpHeaders headers, Class<?> responseType) {
+    // 원본 headers를 그대로 쓰면 외부에서 재사용할 때 사이드이펙트 날 수 있어서 복사 권장
+    HttpHeaders h = (headers == null) ? new HttpHeaders() : new HttpHeaders(headers);
+
+    // 요청 바디 기본은 JSON이라고 가정 (필요하면 호출부에서 덮어쓰기)
+    if (h.getContentType() == null) {
+      h.setContentType(MediaType.APPLICATION_JSON);
+    }
+
+    // 호출부에서 Accept를 명시했으면 존중
+    if (h.getAccept() != null && !h.getAccept().isEmpty()) {
+      return h;
+    }
+
+    // responseType 기반 Accept 자동 지정
+    if (responseType == byte[].class) {
+      h.setAccept(
+          List.of(
+              MediaType.APPLICATION_OCTET_STREAM,
+              MediaType.valueOf("application/zip"),
+              MediaType.APPLICATION_JSON // 실패(JSON 에러 바디) 대비
+              ));
+    } else {
+      h.setAccept(List.of(MediaType.APPLICATION_JSON));
+    }
+
+    return h;
+  }
+
+  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) {
+        log.info("[HTTP-REQ-BODY-JSON] {}", objectMapper.writeValueAsString(body));
+      }
+    } catch (Exception e) {
+      log.warn("[HTTP-REQ-BODY-JSON] serialize failed: {}", e.getMessage());
+    }
+  }
+
+  public record ExternalCallResult<T>(int statusCode, boolean success, T body, String errBody) {}
 }

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.http.client.BufferingClientHttpRequestFactory;
 import org.springframework.http.client.SimpleClientHttpRequestFactory;
 import org.springframework.web.client.RestTemplate;
 
@@ -13,10 +14,20 @@ public class RestTemplateConfig {
 
   @Bean
   public RestTemplate restTemplate(RestTemplateBuilder builder) {
-    SimpleClientHttpRequestFactory f = new SimpleClientHttpRequestFactory();
+    SimpleClientHttpRequestFactory baseFactory = new SimpleClientHttpRequestFactory();
-    f.setConnectTimeout(2000);
+    baseFactory.setConnectTimeout(2000);
-    f.setReadTimeout(3000);
+    baseFactory.setReadTimeout(3000);
 
-    return builder.requestFactory(() -> f).additionalInterceptors(new RetryInterceptor()).build();
+    RestTemplate rt =
+        builder
+            .requestFactory(() -> new BufferingClientHttpRequestFactory(baseFactory))
+            .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/config/resttemplate/RetryInterceptor.java

@@ -1,12 +1,15 @@
 package com.kamco.cd.kamcoback.config.resttemplate;
 
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.util.concurrent.TimeUnit;
+import lombok.extern.log4j.Log4j2;
 import org.springframework.http.HttpRequest;
 import org.springframework.http.client.ClientHttpRequestExecution;
 import org.springframework.http.client.ClientHttpRequestInterceptor;
 import org.springframework.http.client.ClientHttpResponse;
 
+@Log4j2
 public class RetryInterceptor implements ClientHttpRequestInterceptor {
 
   private static final int MAX_RETRY = 3;
@@ -20,21 +23,25 @@ public class RetryInterceptor implements ClientHttpRequestInterceptor {
 
     for (int attempt = 1; attempt <= MAX_RETRY; attempt++) {
       try {
-        // HTTP 응답을 받으면(2xx/4xx/5xx 포함) 그대로 반환
+        log.info("[WIRE-REQ] {} {}", request.getMethod(), request.getURI());
-        return execution.execute(request, body);
+        log.info("[WIRE-REQ-HEADERS] {}", request.getHeaders());
+        log.info("[WIRE-REQ-BODY] {}", new String(body, StandardCharsets.UTF_8));
+
+        ClientHttpResponse response = execution.execute(request, body);
+
+        log.info("[WIRE-RES-STATUS] {}", response.getStatusCode());
+        return response;
 
       } catch (IOException e) {
-        // 네트워크/타임아웃 등 I/O 예외만 재시도
         lastException = e;
+        log.error("[WIRE-IO-ERR] attempt={} msg={}", attempt, e.getMessage(), e);
       }
 
-      // 마지막 시도가 아니면 대기
       if (attempt < MAX_RETRY) {
         sleep();
       }
     }
 
-    //  마지막 예외를 그대로 던져서 원인이 로그에 남게 함
     throw lastException;
   }
 

src/main/java/com/kamco/cd/kamcoback/config/swagger/SwaggerConfig.java

@@ -1,4 +1,4 @@
-package com.kamco.cd.kamcoback.config;
+package com.kamco.cd.kamcoback.config.swagger;
 
 import io.swagger.v3.oas.annotations.enums.SecuritySchemeType;
 import io.swagger.v3.oas.annotations.security.SecurityScheme;

src/main/java/com/kamco/cd/kamcoback/config/swagger/SwaggerUiAutoAuthConfig.java

@@ -0,0 +1,97 @@
+package com.kamco.cd.kamcoback.config.swagger;
+
+import jakarta.servlet.http.HttpServletRequest;
+import java.nio.charset.StandardCharsets;
+import org.springdoc.core.properties.SwaggerUiConfigProperties;
+import org.springdoc.core.properties.SwaggerUiOAuthProperties;
+import org.springdoc.core.providers.ObjectMapperProvider;
+import org.springdoc.webmvc.ui.SwaggerIndexPageTransformer;
+import org.springdoc.webmvc.ui.SwaggerIndexTransformer;
+import org.springdoc.webmvc.ui.SwaggerWelcomeCommon;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.io.Resource;
+import org.springframework.web.servlet.resource.ResourceTransformerChain;
+import org.springframework.web.servlet.resource.TransformedResource;
+
+@Profile({"local", "dev"})
+@Configuration
+public class SwaggerUiAutoAuthConfig {
+
+  @Bean
+  @Primary
+  public SwaggerIndexTransformer swaggerIndexTransformer(
+      SwaggerUiConfigProperties swaggerUiConfigProperties,
+      SwaggerUiOAuthProperties swaggerUiOAuthProperties,
+      SwaggerWelcomeCommon swaggerWelcomeCommon,
+      ObjectMapperProvider objectMapperProvider) {
+
+    SwaggerIndexPageTransformer delegate =
+        new SwaggerIndexPageTransformer(
+            swaggerUiConfigProperties,
+            swaggerUiOAuthProperties,
+            swaggerWelcomeCommon,
+            objectMapperProvider);
+
+    return new SwaggerIndexTransformer() {
+      private static final String TOKEN_KEY = "SWAGGER_ACCESS_TOKEN";
+
+      @Override
+      public Resource transform(
+          HttpServletRequest request, Resource resource, ResourceTransformerChain chain) {
+        try {
+          // 1) springdoc 기본 변환 먼저 적용
+          Resource transformed = delegate.transform(request, resource, chain);
+
+          String html =
+              new String(transformed.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+
+          String loginPathContains = "/api/auth/signin";
+
+          String inject =
+              """
+                      tagsSorter: (a, b) => {
+                              const TOP = '인증(Auth)';
+                              if (a === TOP && b !== TOP) return -1;
+                              if (b === TOP && a !== TOP) return 1;
+                              return a.localeCompare(b);
+                            },
+                    requestInterceptor: (req) => {
+                      const token = localStorage.getItem('%s');
+                      if (token) {
+                        req.headers = req.headers || {};
+                        req.headers['Authorization'] = 'Bearer ' + token;
+                      }
+                      return req;
+                    },
+                    responseInterceptor: async (res) => {
+                      try {
+                        const isLogin = (res?.url?.includes('%s') && res?.status === 200);
+                        if (isLogin) {
+                          const text = (typeof res.data === 'string') ? res.data : JSON.stringify(res.data);
+                          const json = JSON.parse(text);
+                          const token = json?.data?.accessToken;
+
+                          if (token) {
+                            localStorage.setItem('%s', token);
+                          }
+                        }
+                      } catch (e) {}
+                      return res;
+                    },
+                  """
+                  .formatted(TOKEN_KEY, loginPathContains, TOKEN_KEY);
+
+          html = html.replace("SwaggerUIBundle({", "SwaggerUIBundle({\n" + inject);
+
+          return new TransformedResource(transformed, html.getBytes(StandardCharsets.UTF_8));
+        } catch (Exception e) {
+          // 실패 시 원본 반환(문서 깨짐 방지)
+          return resource;
+        }
+      }
+    };
+  }
+}

src/main/java/com/kamco/cd/kamcoback/gukyuin/GukYuinApiController.java

@@ -1,11 +1,12 @@
 package com.kamco.cd.kamcoback.gukyuin;
 
 import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
+import com.kamco.cd.kamcoback.config.api.ApiResponseDto.ResponseObj;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectContDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.ChnDetectMastReqDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.ChngDetectMastSearchDto;
-import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.ResReturn;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LabelSendDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.DetectMastDto.Basic;
 import com.kamco.cd.kamcoback.gukyuin.dto.DetectMastDto.DetectMastReq;
 import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.GukYuinLinkableRes;
@@ -18,6 +19,8 @@ import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
+import java.time.LocalDate;
+import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -51,7 +54,7 @@ public class GukYuinApiController {
         @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
       })
   @PostMapping("/chn/mast/regist")
-  public ApiResponseDto<ChngDetectMastDto.Basic> regist(
+  public ApiResponseDto<ChngDetectMastDto.RegistResDto> regist(
       @RequestBody @Valid ChngDetectMastDto.ChnDetectMastReqDto chnDetectMastReq) {
     return ApiResponseDto.ok(gukYuinApiService.regist(chnDetectMastReq));
   }
@@ -70,7 +73,7 @@ public class GukYuinApiController {
         @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
       })
   @PostMapping("/chn/mast/remove")
-  public ApiResponseDto<ResReturn> remove(
+  public ApiResponseDto<ChngDetectMastDto.RemoveResDto> remove(
       @RequestBody @Valid ChngDetectMastDto.ChnDetectMastReqDto chnDetectMastReq) {
     return ApiResponseDto.ok(gukYuinApiService.remove(chnDetectMastReq));
   }
@@ -116,7 +119,7 @@ public class GukYuinApiController {
       })
   public ApiResponseDto<ChngDetectMastDto.ResultDto> selectChangeDetectionDtctIdList(
       @RequestParam(required = false) String chnDtctId) {
-    return ApiResponseDto.ok(gukYuinApiService.listChnDtctId(chnDtctId));
+    return ApiResponseDto.ok(gukYuinApiService.listChnDtctId(chnDtctId, ""));
   }
 
   @Operation(summary = "탐지결과 등록목록 조회(1건 조회)", description = "탐지결과 등록목록 조회")
@@ -133,9 +136,9 @@ public class GukYuinApiController {
         @ApiResponse(responseCode = "404", description = "코드를 찾을 수 없음", content = @Content),
         @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
       })
-  public ApiResponseDto<ChngDetectMastDto.ResultDto> selectChangeDetectionList(
+  public ApiResponseDto<ChngDetectMastDto.ResultDto> selectChangeDetectionDetail(
       @PathVariable String chnDtctMstId) {
-    return ApiResponseDto.ok(gukYuinApiService.list(chnDtctMstId));
+    return ApiResponseDto.ok(gukYuinApiService.detail(chnDtctMstId));
   }
 
   @Operation(summary = "국유in연동 가능여부 확인", description = "국유in연동 가능여부 확인")
@@ -180,7 +183,30 @@ public class GukYuinApiController {
       @PathVariable String chnDtctId,
       @RequestParam(defaultValue = "0") Integer pageIndex,
       @RequestParam(defaultValue = "10") Integer pageSize) {
-    return ApiResponseDto.ok(gukYuinApiService.findChnContList(chnDtctId, pageIndex, pageSize));
+    return ApiResponseDto.ok(gukYuinApiService.findChnContList(chnDtctId, pageIndex, pageSize, ""));
+  }
+
+  @Operation(summary = "탐지객체 조회 (탐지객체 1건 조회)", description = "탐지객체 조회 (탐지객체 1건 조회)")
+  @GetMapping("/chn/cont/{chnDtctId}/objt/{chnDtctObjtId}")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "목록 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = Basic.class))),
+        @ApiResponse(responseCode = "404", description = "코드를 찾을 수 없음", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  public ApiResponseDto<ChngDetectContDto.ResultContDto> findChnPnuToContObject(
+      @PathVariable String chnDtctId,
+      @PathVariable String chnDtctObjtId,
+      @RequestParam(defaultValue = "0") Integer pageIndex,
+      @RequestParam(defaultValue = "10") Integer pageSize) {
+    return ApiResponseDto.ok(
+        gukYuinApiService.findChnPnuToContObject(chnDtctId, chnDtctObjtId, pageIndex, pageSize));
   }
 
   @Operation(summary = "탐지객체 조회 (PNU에 해당하는 탐지객체)", description = "탐지객체 조회 (PNU에 해당하는 탐지객체)")
@@ -235,8 +261,65 @@ public class GukYuinApiController {
         @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
       })
   @PostMapping("/rlb/objt/{chnDtctObjtId}/lbl/{lblYn}")
-  public ApiResponseDto<ResReturn> updateChnDtctObjtLabelingYn(
+  public ApiResponseDto<ChngDetectContDto.ResultLabelDto> updateChnDtctObjtLabelingYn(
       @PathVariable String chnDtctObjtId, @PathVariable String lblYn) {
-    return ApiResponseDto.ok(gukYuinApiService.updateChnDtctObjtLabelingYn(chnDtctObjtId, lblYn));
+    return ApiResponseDto.ok(
+        gukYuinApiService.updateChnDtctObjtLabelingYn(chnDtctObjtId, lblYn, ""));
+  }
+
+  @Operation(summary = "국유in연동 등록", description = "국유in연동 등록")
+  @PostMapping("/mast/reg/{uuid}")
+  public ApiResponseDto<ResponseObj> connectChnMastRegist(
+      @Parameter(description = "uuid", example = "7a593d0e-76a8-4b50-8978-9af1fbe871af")
+          @PathVariable
+          UUID uuid) {
+    return ApiResponseDto.okObject(gukYuinApiService.connectChnMastRegist(uuid));
+  }
+
+  @Operation(summary = "라벨 전송 완료 리스트", description = "라벨 전송 완료 리스트")
+  @GetMapping("/label/send-list")
+  public ApiResponseDto<List<LabelSendDto>> findLabelingCompleteSendList(
+      @Parameter(description = "어제 날짜", example = "2026-01-29") LocalDate yesterday) {
+    return ApiResponseDto.ok(gukYuinApiService.findLabelingCompleteSendList(yesterday));
+  }
+
+  @Operation(summary = "탐지객체 적합여부 조회 (리스트조회)", description = "탐지객체 적합여부 조회 (리스트조회)")
+  @GetMapping("/rlb/dtct/{chnDtctId}")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "목록 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = Basic.class))),
+        @ApiResponse(responseCode = "404", description = "코드를 찾을 수 없음", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  public ApiResponseDto<ChngDetectMastDto.RlbDtctDto> findRlbDtctList(
+      @PathVariable String chnDtctId,
+      @Parameter(description = "날짜(기본은 어제 날짜)") @RequestParam(defaultValue = "20260205")
+          String yyyymmdd) {
+    return ApiResponseDto.ok(gukYuinApiService.findRlbDtctList(chnDtctId, yyyymmdd, ""));
+  }
+
+  @Operation(summary = "탐지객체 적합여부 조회 (객체별 조회)", description = "탐지객체 적합여부 조회 (객체별 조회)")
+  @GetMapping("/rlb/objt/{chnDtctObjtId}")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "목록 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = Basic.class))),
+        @ApiResponse(responseCode = "404", description = "코드를 찾을 수 없음", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  public ApiResponseDto<ChngDetectMastDto.RlbDtctDto> findRlbDtctObject(
+      @PathVariable String chnDtctObjtId) {
+    return ApiResponseDto.ok(gukYuinApiService.findRlbDtctObject(chnDtctObjtId));
   }
 }

src/main/java/com/kamco/cd/kamcoback/gukyuin/dto/ChngDetectContDto.java

@@ -114,4 +114,38 @@ public class ChngDetectContDto {
     private List<DtoPnuDetectMpng> result;
     private Boolean success;
   }
+
+  @Schema(name = "ResultLabelDto", description = "ResultLabelDto list 리턴 형태")
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class ResultLabelDto {
+
+    private Integer code;
+    private String message;
+    private DtoPnuDetectMpng result;
+    private Boolean success;
+  }
+
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class ReqInfo {
+
+    private String reqIp;
+    private String reqEpno;
+  }
+
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class StbltResult {
+
+    private String stbltYn;
+    private String incyCd;
+    private String incyCmnt;
+  }
 }

src/main/java/com/kamco/cd/kamcoback/gukyuin/dto/ChngDetectMastDto.java

@@ -1,6 +1,7 @@
 package com.kamco.cd.kamcoback.gukyuin.dto;
 
 import io.swagger.v3.oas.annotations.media.Schema;
+import java.time.ZonedDateTime;
 import java.util.List;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
@@ -66,13 +67,30 @@ public class ChngDetectMastDto {
   @AllArgsConstructor
   public static class ChnDetectMastReqDto {
 
-    private String cprsYr; // 비교년도 2023
+    @Schema(description = "비교년도", example = "2023")
-    private String crtrYr; // 기준년도 2024
+    private String cprsYr;
-    private String chnDtctSno; // 차수 (1 | 2 | ...)
+
-    private String chnDtctId; // 탐지아이디. UUID를 기반으로 '-'를 제거하고 대문자/숫자로 구성
+    @Schema(description = "기준년도", example = "2024")
-    private String pathNm; // 탐지결과 절대경로명 /kamco_nas/export/{chnDtctId}
+    private String crtrYr;
-    private String reqEpno; // 사원번호
+
-    private String reqIp; // 사원아이피
+    @Schema(description = "차수", example = "1")
+    private String chnDtctSno;
+
+    @Schema(
+        description = "탐지아이디, UUID를 기반으로 '-'를 제거하고 대문자/숫자로 구성",
+        example = "D5F192EC76D34F6592035BE63A84F591")
+    private String chnDtctId;
+
+    @Schema(
+        description = "탐지결과 절대경로명 /kamco_nas/export/{chnDtctId}",
+        example = "{file.nfs}/dataset/export/D5F192EC76D34F6592035BE63A84F591")
+    private String pathNm;
+
+    @Schema(description = "사원번호", example = "123456")
+    private String reqEpno;
+
+    @Schema(description = "사원아이피", example = "127.0.0.1")
+    private String reqIp;
   }
 
   @Getter
@@ -158,4 +176,129 @@ public class ChngDetectMastDto {
     private List<Basic> result;
     private Boolean success;
   }
+
+  @Schema(name = "RegistResDto", description = "reg 등록 후 리턴 형태")
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class RegistResDto {
+
+    private Integer code;
+    private String message;
+    private Basic result;
+    private Boolean success;
+  }
+
+  @Schema(name = "LearnKeyDto", description = "learn 엔티티 key 정보")
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class LearnKeyDto {
+
+    private Long id;
+    private String uid;
+    private String chnDtctMstId;
+  }
+
+  @Schema(name = "LabelSendDto", description = "라벨링 전송한 목록")
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class LabelSendDto {
+
+    private String chnDtctObjtId;
+    private String labelerId;
+    private ZonedDateTime labelerWorkDttm;
+    private String reviewerId;
+    private ZonedDateTime reviewerWorkDttm;
+    private ZonedDateTime labelSendDttm;
+  }
+
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class ErrorResDto {
+
+    private String timestamp;
+    private Integer status;
+    private String error;
+    private String path;
+  }
+
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class RlbDtctDto {
+
+    private Integer code;
+    private String message;
+    private List<RlbDtctMastDto> result;
+    private Boolean success;
+  }
+
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class RlbDtctMastDto {
+
+    private String pnuDtctId; // PNU탐지ID
+    private String pnu; // PNU코드(19자리)
+    private String lrmSyncYmd; // 지적도동기화일자(YYYYMMDD)
+    private String pnuSyncYmd; // PNU동기화일자(YYYYMMDD)
+    private String mpqdNo; // 도곽번호
+    private String cprsYr; // 비교년도
+    private String crtrYr; // 기준년도
+    private String chnDtctSno; // 회차, 변화탐지순번
+    private String chnDtctId; // 변화탐지ID(UUID)
+
+    private String chnDtctMstId; // 변화탐지마스터ID
+    private String chnDtctObjtId; // 변화탐지객체ID
+    private String chnDtctContId; // 변화탐지내용ID
+    private String chnCd; // 변화코드
+    private String chnDtctProb; // 변화탐지정확도(0~1)
+
+    private String bfClsCd; // 이전분류코드
+    private String bfClsProb; // 이전분류정확도(0~1)
+    private String afClsCd; // 이후분류코드
+    private String afClsProb; // 이후분류정확도(0~1)
+
+    private String pnuSqms; // PNU면적(㎡)
+    private String pnuDtctSqms; // PNU탐지면적(㎡)
+    private String chnDtctSqms; // 변화탐지면적(㎡)
+    private String stbltYn; // 적합여부(Y/N) - 안정성 (Y:부적합, N:적합)
+    private String incyCd; // 부적합코드
+    private String incyRsnCont; // 부적합사유내용
+    private String lockYn; // 잠금여부(Y/N)
+    private String lblYn; // 라벨여부(Y/N)
+    private String chgYn; // 변경여부(Y/N)
+    private String rsatctNo; // 부동산등기번호
+    private String rmk; // 비고
+
+    private String crtDt; // 생성일시
+    private String crtEpno; // 생성사원번호
+    private String crtIp; // 생성사원아이피
+    private String chgDt; // 변경일시
+    private String chgEpno; // 변경자사번
+    private String chgIp; // 변경자IP
+    private String delYn; // 삭제여부
+  }
+
+  @Schema(name = "RemoveResDto", description = "remove 후 리턴 형태")
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class RemoveResDto {
+
+    private Integer code;
+    private String message;
+    private Boolean result;
+    private Boolean success;
+  }
 }

src/main/java/com/kamco/cd/kamcoback/gukyuin/dto/GukYuinDto.java

@@ -1,21 +1,13 @@
 package com.kamco.cd.kamcoback.gukyuin.dto;
 
 import com.kamco.cd.kamcoback.common.utils.enums.EnumType;
+import java.util.UUID;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.Setter;
 
 public class GukYuinDto {
 
-  @Getter
-  @Setter
-  public static class GukYuinLinkableRes {
-
-    private boolean linkable;
-    //    private GukYuinLinkFailCode code;
-    private String message;
-  }
-
   /** 실패 코드 enum */
   @Getter
   @AllArgsConstructor
@@ -39,10 +31,47 @@ public class GukYuinDto {
     }
   }
 
+  @Getter
+  @Setter
+  public static class GukYuinLinkableRes {
+
+    private boolean linkable;
+    //    private GukYuinLinkFailCode code;
+    private String message;
+  }
+
   // Repository가 반환할 Fact(조회 결과)
   public record GukYuinLinkFacts(
       boolean existsLearn,
       boolean isPartScope,
       boolean hasRunningInference,
       boolean hasOtherUnfinishedGukYuin) {}
+
+  @Getter
+  @Setter
+  @AllArgsConstructor
+  public static class LearnInfo {
+
+    private Long id;
+    private UUID uuid;
+    private Integer compareYyyy;
+    private Integer targetYyyy;
+    private Integer stage;
+    private String uid;
+    private String applyStatus;
+    private Boolean applyYn;
+
+    public Boolean getApplyYn() {
+      return this.applyYn != null && this.applyYn;
+    }
+  }
+
+  @Getter
+  @Setter
+  @AllArgsConstructor
+  public static class GeomUidDto {
+
+    private Long geoUid;
+    private String resultUid;
+  }
 }

src/main/java/com/kamco/cd/kamcoback/gukyuin/dto/GukYuinStatus.java

@@ -11,6 +11,8 @@ public enum GukYuinStatus implements EnumType {
   IN_PROGRESS("진행중"),
   GUK_COMPLETED("국유인 매핑 완료"),
   PNU_COMPLETED("PNU 싱크 완료"),
+  PNU_FAILED("PNU 싱크 중 에러"),
+  END("종료"),
   CANCELED("취소");
 
   private final String desc;

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

@@ -1,29 +1,50 @@
 package com.kamco.cd.kamcoback.gukyuin.service;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.kamco.cd.kamcoback.common.utils.NetUtils;
+import com.kamco.cd.kamcoback.common.utils.UserUtil;
+import com.kamco.cd.kamcoback.config.api.ApiLogFunction;
+import com.kamco.cd.kamcoback.config.api.ApiResponseDto.ApiResponseCode;
+import com.kamco.cd.kamcoback.config.api.ApiResponseDto.ResponseObj;
 import com.kamco.cd.kamcoback.config.resttemplate.ExternalHttpClient;
 import com.kamco.cd.kamcoback.config.resttemplate.ExternalHttpClient.ExternalCallResult;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectContDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectContDto.ContBasic;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectContDto.ReqInfo;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectContDto.ResultContDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectContDto.ResultPnuDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto;
-import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.ResReturn;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.ChnDetectMastReqDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.ErrorResDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LabelSendDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.ResultDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.RlbDtctDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.GukYuinLinkFacts;
 import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.GukYuinLinkFailCode;
 import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.GukYuinLinkableRes;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.LearnInfo;
+import com.kamco.cd.kamcoback.log.dto.EventStatus;
+import com.kamco.cd.kamcoback.log.dto.EventType;
 import com.kamco.cd.kamcoback.postgres.core.GukYuinCoreService;
+import com.kamco.cd.kamcoback.postgres.entity.AuditLogEntity;
+import com.kamco.cd.kamcoback.postgres.repository.log.AuditLogRepository;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.LocalDate;
 import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpMethod;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
+@Slf4j
 @Service
-@Transactional(readOnly = true)
+@Transactional
 @RequiredArgsConstructor
 public class GukYuinApiService {
 
@@ -31,6 +52,11 @@ public class GukYuinApiService {
   private final ExternalHttpClient externalHttpClient;
   private final NetUtils netUtils = new NetUtils();
 
+  private final UserUtil userUtil;
+  private final AuditLogRepository auditLogRepository;
+  private final ObjectMapper objectMapper;
+  private final String myip = netUtils.getLocalIP();
+
   @Value("${spring.profiles.active:local}")
   private String profile;
 
@@ -40,74 +66,160 @@ public class GukYuinApiService {
   @Value("${gukyuin.cdi}")
   private String gukyuinCdiUrl;
 
+  @Value("${file.nfs}")
+  private String nfs;
+
+  //  @Value("${file.dataset-dir}")
+  //  private String datasetDir;
+
   @Transactional
-  public ChngDetectMastDto.Basic regist(ChngDetectMastDto.ChnDetectMastReqDto chnDetectMastReq) {
+  public ChngDetectMastDto.RegistResDto regist(
+      ChngDetectMastDto.ChnDetectMastReqDto chnDetectMastReq) {
 
     String url = gukyuinCdiUrl + "/chn/mast/regist";
 
-    String myip = netUtils.getLocalIP();
     chnDetectMastReq.setReqIp(myip);
-    chnDetectMastReq.setReqEpno("1234567"); // TODO
+    chnDetectMastReq.setReqEpno(userUtil.getEmployeeNo());
 
-    ExternalCallResult<ChngDetectMastDto.Basic> result =
+    ExternalCallResult<ChngDetectMastDto.RegistResDto> result =
         externalHttpClient.call(
             url,
             HttpMethod.POST,
             chnDetectMastReq,
             netUtils.jsonHeaders(),
-            ChngDetectMastDto.Basic.class);
+            ChngDetectMastDto.RegistResDto.class);
 
-    ChngDetectMastDto.Basic resultBody = result.body();
+    ChngDetectMastDto.RegistResDto resultBody = result.body();
-    gukyuinCoreService.updateGukYuinMastRegResult(resultBody);
+    boolean success = false;
+    if (resultBody != null && resultBody.getSuccess() != null) {
+      ChngDetectMastDto.Basic registRes = resultBody.getResult();
+
+      success = resultBody.getSuccess();
+
+      // 이미 등록한 경우에는 result가 없음
+      if (resultBody.getResult() == null) {
+        return resultBody;
+      }
+
+      // 추론 회차에 applyStatus, applyStatusDttm 업데이트
+      gukyuinCoreService.updateGukYuinMastRegResult(registRes);
+
+      // anal_inference 에도 국유인 반영여부, applyDttm 업데이트
+      gukyuinCoreService.updateAnalInferenceApplyDttm(registRes);
+    } else {
+      String errBody = result.errBody();
+      ErrorResDto error = null;
+      try {
+        error = objectMapper.readValue(errBody, ErrorResDto.class);
+        return new ChngDetectMastDto.RegistResDto(error.getStatus(), error.getError(), null, false);
+      } catch (JsonProcessingException e) {
+        log.error("에러 응답 파싱 실패. rawBody={}", errBody, e);
+        return new ChngDetectMastDto.RegistResDto(
+            result.statusCode(), // HTTP status
+            errBody, // 원문 그대로
+            null,
+            false);
+      }
+    }
+
+    this.insertGukyuinAuditLog(
+        EventType.ADDED.getId(),
+        myip,
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        chnDetectMastReq,
+        success);
 
     return resultBody;
   }
 
   @Transactional
-  public ResReturn remove(ChngDetectMastDto.ChnDetectMastReqDto chnDetectMastReq) {
+  public ChngDetectMastDto.RemoveResDto remove(
+      ChngDetectMastDto.ChnDetectMastReqDto chnDetectMastReq) {
     String url = gukyuinCdiUrl + "/chn/mast/remove";
 
-    String myip = netUtils.getLocalIP();
     chnDetectMastReq.setReqIp(myip);
-    chnDetectMastReq.setReqEpno("1234567"); // TODO
+    chnDetectMastReq.setReqEpno(userUtil.getEmployeeNo());
 
-    ExternalCallResult<ChngDetectMastDto.Basic> result =
+    boolean success = false;
+    ExternalCallResult<ChngDetectMastDto.RemoveResDto> result =
         externalHttpClient.call(
             url,
             HttpMethod.POST,
             chnDetectMastReq,
             netUtils.jsonHeaders(),
-            ChngDetectMastDto.Basic.class);
+            ChngDetectMastDto.RemoveResDto.class);
 
-    ChngDetectMastDto.Basic resultBody = result.body();
+    ChngDetectMastDto.RemoveResDto resultBody = result.body();
-    gukyuinCoreService.updateGukYuinMastRegRemove(resultBody);
+    if (resultBody != null && resultBody.getSuccess() != null) {
 
-    return new ResReturn("success", "탐지결과 삭제 되었습니다.");
+      success = resultBody.getSuccess();
+      if (resultBody.getSuccess()) {
+        gukyuinCoreService.updateGukYuinMastRegRemove(chnDetectMastReq.getChnDtctId());
+      }
+    }
+
+    this.insertGukyuinAuditLog(
+        EventType.REMOVE.getId(),
+        myip,
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        chnDetectMastReq,
+        success);
+
+    return resultBody;
   }
 
   // 등록목록 1개 확인
-  public ChngDetectMastDto.ResultDto list(String chnDtctMstId) {
+  public ChngDetectMastDto.ResultDto detail(String chnDtctMstId) {
 
-    String url = gukyuinCdiUrl + "/chn/mast/list/" + chnDtctMstId;
+    String url =
+        gukyuinCdiUrl
+            + "/chn/mast/list/"
+            + chnDtctMstId
+            + "?reqIp="
+            + myip
+            + "&reqEpno="
+            + userUtil.getEmployeeNo();
 
     ExternalCallResult<ChngDetectMastDto.ResultDto> result =
         externalHttpClient.call(
             url, HttpMethod.GET, null, netUtils.jsonHeaders(), ChngDetectMastDto.ResultDto.class);
 
+    this.insertGukyuinAuditLog(
+        EventType.DETAIL.getId(),
+        netUtils.getLocalIP(),
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        null,
+        result.body().getSuccess());
     return result.body();
   }
 
   // 등록목록 비교년도,기준년도,차수 조합해서 n개 확인
   public ChngDetectMastDto.ResultDto listYearStage(
       ChngDetectMastDto.ChngDetectMastSearchDto searchDto) {
-
     String queryString = netUtils.dtoToQueryString(searchDto, null);
-    String url = gukyuinCdiUrl + "/chn/mast" + queryString;
+    String url =
+        gukyuinCdiUrl
+            + "/chn/mast"
+            + queryString
+            + "&reqIp="
+            + myip
+            + "&reqEpno="
+            + userUtil.getEmployeeNo();
 
     ExternalCallResult<ChngDetectMastDto.ResultDto> result =
         externalHttpClient.call(
             url, HttpMethod.GET, null, netUtils.jsonHeaders(), ChngDetectMastDto.ResultDto.class);
 
+    this.insertGukyuinAuditLog(
+        EventType.LIST.getId(),
+        netUtils.getLocalIP(),
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        null,
+        result.body().getSuccess());
     return result.body();
   }
 
@@ -150,7 +262,8 @@ public class GukYuinApiService {
   }
 
   // 탐지객체 리스트 조회
-  public ResultContDto findChnContList(String chnDtctId, Integer pageIndex, Integer pageSize) {
+  public ResultContDto findChnContList(
+      String chnDtctId, Integer pageIndex, Integer pageSize, String batchYn) {
 
     String url =
         gukyuinCdiUrl
@@ -159,7 +272,11 @@ public class GukYuinApiService {
             + "?pageIndex="
             + pageIndex
             + "&pageSize="
-            + pageSize;
+            + pageSize
+            + "&reqIp="
+            + myip
+            + "&reqEpno="
+            + ("Y".equals(batchYn) ? "BATCH" : userUtil.getEmployeeNo());
 
     ExternalCallResult<ChngDetectContDto.ResultContDto> result =
         externalHttpClient.call(
@@ -171,28 +288,35 @@ public class GukYuinApiService {
 
     List<ContBasic> contList = result.body().getResult();
     if (contList == null || contList.isEmpty()) {
-      return new ResultContDto();
+      return new ResultContDto(
+          result.body().getCode(),
+          result.body().getMessage(),
+          result.body().getResult(),
+          result.body().getSuccess());
     }
 
-    for (ContBasic cont : contList) {
+    this.insertGukyuinAuditLog(
-      String[] pnuList = cont.getPnuList();
+        EventType.LIST.getId(),
-      long pnuCnt = pnuList == null ? 0 : pnuList.length;
+        netUtils.getLocalIP(),
-      if (cont.getChnDtctObjtId() != null) {
+        userUtil.getId(),
-        gukyuinCoreService.updateInferenceGeomDataPnuCnt(cont.getChnDtctObjtId(), pnuCnt);
+        url.replace(gukyuinUrl, ""),
-
+        null,
-        if (pnuCnt > 0) {
+        result.body().getSuccess());
-          Long geoUid =
-              gukyuinCoreService.findMapSheetAnalDataInferenceGeomUid(cont.getChnDtctObjtId());
-          gukyuinCoreService.insertGeoUidPnuData(geoUid, pnuList);
-        }
-      }
-    }
 
     return result.body();
   }
 
   public ResultPnuDto findPnuObjMgmtList(String chnDtctId, String chnDtctObjtId) {
-    String url = gukyuinCdiUrl + "/chn/pnu/" + chnDtctId + "/objt/" + chnDtctObjtId;
+    String url =
+        gukyuinCdiUrl
+            + "/chn/pnu/"
+            + chnDtctId
+            + "/objt/"
+            + chnDtctObjtId
+            + "?reqIp="
+            + myip
+            + "&reqEpno="
+            + userUtil.getEmployeeNo();
 
     ExternalCallResult<ChngDetectContDto.ResultPnuDto> result =
         externalHttpClient.call(
@@ -202,27 +326,56 @@ public class GukYuinApiService {
             netUtils.jsonHeaders(),
             ChngDetectContDto.ResultPnuDto.class);
 
+    this.insertGukyuinAuditLog(
+        EventType.DETAIL.getId(),
+        netUtils.getLocalIP(),
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        null,
+        result.body().getSuccess());
+
     return result.body();
   }
 
-  public ResReturn updateChnDtctObjtLabelingYn(String chnDtctObjtId, String lblYn) {
+  public ChngDetectContDto.ResultLabelDto updateChnDtctObjtLabelingYn(
+      String chnDtctObjtId, String lblYn, String batchYn) {
     String url = gukyuinCdiUrl + "/rlb/objt/" + chnDtctObjtId + "/lbl/" + lblYn;
 
-    ExternalCallResult<ChngDetectContDto.ResultPnuDto> result =
+    ReqInfo info = new ReqInfo();
+    info.setReqIp(myip);
+    info.setReqEpno("Y".equals(batchYn) ? "BATCH" : userUtil.getEmployeeNo());
+
+    ExternalCallResult<ChngDetectContDto.ResultLabelDto> result =
         externalHttpClient.call(
             url,
             HttpMethod.POST,
-            null,
+            info,
             netUtils.jsonHeaders(),
-            ChngDetectContDto.ResultPnuDto.class);
+            ChngDetectContDto.ResultLabelDto.class);
 
-    ChngDetectContDto.ResultPnuDto dto = result.body();
+    this.insertGukyuinAuditLog(
+        EventType.MODIFIED.getId(),
+        netUtils.getLocalIP(),
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        null,
+        result.body().getSuccess());
 
-    return new ResReturn(dto.getCode() > 200000 ? "fail" : "success", dto.getMessage());
+    return result.body();
   }
 
   public ResultContDto findChnPnuToContList(String chnDtctId, String pnu) {
-    String url = gukyuinCdiUrl + "/chn/cont/" + chnDtctId + "/pnu/" + pnu;
+
+    String url =
+        gukyuinCdiUrl
+            + "/chn/cont/"
+            + chnDtctId
+            + "/pnu/"
+            + pnu
+            + "?reqIp="
+            + myip
+            + "&reqEpno="
+            + userUtil.getEmployeeNo();
 
     ExternalCallResult<ChngDetectContDto.ResultContDto> result =
         externalHttpClient.call(
@@ -232,16 +385,205 @@ public class GukYuinApiService {
             netUtils.jsonHeaders(),
             ChngDetectContDto.ResultContDto.class);
 
+    this.insertGukyuinAuditLog(
+        EventType.LIST.getId(),
+        netUtils.getLocalIP(),
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        null,
+        result.body().getSuccess());
     return result.body();
   }
 
-  public ResultDto listChnDtctId(String chnDtctId) {
+  public ResultDto listChnDtctId(String chnDtctId, String batchYn) {
-    String url = gukyuinCdiUrl + "/chn/mast/" + chnDtctId;
+    String url =
+        gukyuinCdiUrl
+            + "/chn/mast/"
+            + chnDtctId
+            + "?reqIp="
+            + myip
+            + "&reqEpno="
+            + ("Y".equals(batchYn) ? "BATCH" : userUtil.getEmployeeNo());
 
     ExternalCallResult<ChngDetectMastDto.ResultDto> result =
         externalHttpClient.call(
             url, HttpMethod.GET, null, netUtils.jsonHeaders(), ChngDetectMastDto.ResultDto.class);
 
+    this.insertGukyuinAuditLog(
+        EventType.DETAIL.getId(),
+        netUtils.getLocalIP(),
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        null,
+        result.body().getSuccess());
+
+    return result.body();
+  }
+
+  @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = false)
+  public void insertGukyuinAuditLog(
+      String actionType,
+      String myIp,
+      Long userUid,
+      String requestUri,
+      Object requestBody,
+      boolean successFail) {
+    try {
+      AuditLogEntity log =
+          new AuditLogEntity(
+              userUid,
+              EventType.fromName(actionType),
+              successFail ? EventStatus.SUCCESS : EventStatus.FAILED,
+              "GUKYUIN", // 메뉴도 국유인으로 하나 따기
+              myIp,
+              requestUri,
+              requestBody == null ? null : ApiLogFunction.cutRequestBody(requestBody.toString()),
+              null,
+              null,
+              null);
+      auditLogRepository.save(log);
+
+    } catch (Exception e) {
+      log.error(e.getMessage());
+      throw e;
+    }
+  }
+
+  public ResponseObj connectChnMastRegist(UUID uuid) {
+    // uuid로 추론 회차 조회
+    LearnInfo info = gukyuinCoreService.findMapSheetLearnInfo(uuid);
+    if (info.getApplyYn() != null && info.getApplyYn()) {
+      return new ResponseObj(ApiResponseCode.DUPLICATE_DATA, "이미 국유인 연동을 한 회차입니다.");
+    }
+
+    //    String kamconfsDatasetExportPathfsDatasetExportPath = "/kamco-nfs/dataset/export/";
+    String kamconfsDatasetExportPathfsDatasetExportPath =
+        String.format("%s%s", nfs, "/dataset/export/");
+    if (!Files.isDirectory(Path.of(kamconfsDatasetExportPathfsDatasetExportPath + info.getUid()))) {
+      return new ResponseObj(
+          ApiResponseCode.NOT_FOUND_DATA, "파일 경로에 회차 실행 파일이 생성되지 않았습니다. 확인 부탁드립니다.");
+    }
+
+    // 비교년도,기준년도로 전송한 데이터 있는지 확인 후 회차 번호 생성
+    Integer maxStage =
+        gukyuinCoreService.findMapSheetLearnYearStage(info.getCompareYyyy(), info.getTargetYyyy());
+
+    // reqDto 셋팅
+    ChnDetectMastReqDto reqDto = new ChnDetectMastReqDto();
+    reqDto.setCprsYr(String.valueOf(info.getCompareYyyy()));
+    reqDto.setCrtrYr(String.valueOf(info.getTargetYyyy()));
+    reqDto.setChnDtctSno(String.valueOf(maxStage + 1));
+    reqDto.setChnDtctId(info.getUid());
+    reqDto.setPathNm(kamconfsDatasetExportPathfsDatasetExportPath + info.getUid());
+
+    // 1회차를 종료 상태로 처리하고 2회차를 보내야 함
+    // 추론(learn), 학습데이터(inference) 둘 다 종료 처리
+    if (maxStage > 0) {
+      Long learnId =
+          gukyuinCoreService.findMapSheetLearnInfoByYyyy(
+              info.getCompareYyyy(), info.getTargetYyyy(), maxStage);
+      gukyuinCoreService.updateMapSheetLearnGukyuinEndStatus(learnId);
+      gukyuinCoreService.updateMapSheetInferenceLabelEndStatus(learnId);
+    }
+
+    // 국유인 /chn/mast/regist 전송
+    ChngDetectMastDto.RegistResDto result = this.regist(reqDto);
+    if (result.getSuccess()) {
+      return new ResponseObj(ApiResponseCode.OK, "연동되었습니다.");
+    } else {
+      return new ResponseObj(ApiResponseCode.INTERNAL_SERVER_ERROR, result.getMessage());
+    }
+  }
+
+  public List<LabelSendDto> findLabelingCompleteSendList(LocalDate yesterday) {
+    return gukyuinCoreService.findLabelingCompleteSendList(yesterday);
+  }
+
+  public ResultContDto findChnPnuToContObject(
+      String chnDtctId, String chnDtctObjtId, Integer pageIndex, Integer pageSize) {
+
+    String url =
+        gukyuinCdiUrl
+            + "/chn/cont/"
+            + chnDtctId
+            + "/chnDtctObjtId/"
+            + chnDtctObjtId
+            + "?pageIndex="
+            + pageIndex
+            + "&pageSize="
+            + pageSize
+            + "&reqIp="
+            + myip
+            + "&reqEpno="
+            + userUtil.getEmployeeNo();
+
+    ExternalCallResult<ChngDetectContDto.ResultContDto> result =
+        externalHttpClient.call(
+            url,
+            HttpMethod.GET,
+            null,
+            netUtils.jsonHeaders(),
+            ChngDetectContDto.ResultContDto.class);
+
+    this.insertGukyuinAuditLog(
+        EventType.DETAIL.getId(),
+        netUtils.getLocalIP(),
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        null,
+        result.body() != null && result.body().getSuccess());
+    return result.body();
+  }
+
+  public ChngDetectMastDto.RlbDtctDto findRlbDtctList(
+      String chnDtctId, String yyyymmdd, String batchYn) {
+
+    String url =
+        gukyuinCdiUrl
+            + "/rlb/dtct/"
+            + chnDtctId
+            + "?reqIp="
+            + myip
+            + "&reqEpno="
+            + ("Y".equals(batchYn) ? "BATCH" : userUtil.getEmployeeNo())
+            + "&yyyymmdd="
+            + yyyymmdd;
+
+    ExternalCallResult<ChngDetectMastDto.RlbDtctDto> result =
+        externalHttpClient.call(
+            url, HttpMethod.GET, null, netUtils.jsonHeaders(), ChngDetectMastDto.RlbDtctDto.class);
+
+    this.insertGukyuinAuditLog(
+        EventType.LIST.getId(),
+        netUtils.getLocalIP(),
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        null,
+        result.body() != null && result.body().getSuccess());
+    return result.body();
+  }
+
+  public RlbDtctDto findRlbDtctObject(String chnDtctObjtId) {
+    String url =
+        gukyuinCdiUrl
+            + "/rlb/objt/"
+            + chnDtctObjtId
+            + "?reqIp="
+            + myip
+            + "&reqEpno="
+            + userUtil.getEmployeeNo();
+
+    ExternalCallResult<ChngDetectMastDto.RlbDtctDto> result =
+        externalHttpClient.call(
+            url, HttpMethod.GET, null, netUtils.jsonHeaders(), ChngDetectMastDto.RlbDtctDto.class);
+
+    this.insertGukyuinAuditLog(
+        EventType.DETAIL.getId(),
+        netUtils.getLocalIP(),
+        userUtil.getId(),
+        url.replace(gukyuinUrl, ""),
+        null,
+        result.body() != null && result.body().getSuccess());
     return result.body();
   }
 }

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

@@ -1,5 +1,6 @@
 package com.kamco.cd.kamcoback.inference;
 
+import com.kamco.cd.kamcoback.common.download.RangeDownloadResponder;
 import com.kamco.cd.kamcoback.common.exception.CustomApiException;
 import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
 import com.kamco.cd.kamcoback.inference.dto.InferenceDetailDto;
@@ -17,26 +18,24 @@ 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;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.servlet.http.HttpServletRequest;
 import jakarta.validation.Valid;
 import java.io.IOException;
-import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.LocalDate;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
-import org.springframework.core.io.FileSystemResource;
+import lombok.extern.log4j.Log4j2;
-import org.springframework.core.io.Resource;
 import org.springframework.data.domain.Page;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -48,6 +47,7 @@ import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 @Tag(name = "추론관리", description = "추론관리 API")
+@Log4j2
 @RequestMapping("/api/inference")
 @RequiredArgsConstructor
 @RestController
@@ -56,6 +56,7 @@ public class InferenceResultApiController {
   private final InferenceResultService inferenceResultService;
   private final MapSheetMngService mapSheetMngService;
   private final ModelMngService modelMngService;
+  private final RangeDownloadResponder rangeDownloadResponder;
 
   @Operation(summary = "추론관리 목록", description = "어드민 홈 > 추론관리 > 추론관리 > 추론관리 목록")
   @ApiResponses(
@@ -150,7 +151,7 @@ public class InferenceResultApiController {
           @RequestBody
           @Valid
           InferenceResultDto.RegReq req) {
-    UUID uuid = inferenceResultService.saveInferenceInfo(req);
+    UUID uuid = inferenceResultService.run(req);
     return ApiResponseDto.ok(uuid);
   }
 
@@ -194,7 +195,7 @@ public class InferenceResultApiController {
           LocalDate endDttm,
       @Parameter(description = "키워드 (모델버전)", example = "M1.H1.E28") @RequestParam(required = false)
           String searchVal,
-      @Parameter(description = "타입", example = "M1") @RequestParam(required = false)
+      @Parameter(description = "타입", example = "G1") @RequestParam(required = false)
           String modelType,
       @RequestParam(defaultValue = "0") int page,
       @RequestParam(defaultValue = "20") int size) {
@@ -328,7 +329,21 @@ public class InferenceResultApiController {
     return ApiResponseDto.ok(geomList);
   }
 
-  @Operation(summary = "shp 파일 다운로드", description = "추론관리 분석결과 shp 파일 다운로드")
+  @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"))
+      })
   @ApiResponses(
       value = {
         @ApiResponse(
@@ -341,15 +356,13 @@ public class InferenceResultApiController {
         @ApiResponse(responseCode = "404", description = "파일 없음", content = @Content),
         @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
       })
-  @GetMapping(value = "/download/{uuid}", produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)
+  @GetMapping("/download/{uuid}")
-  public ResponseEntity<Resource> downloadShp(
+  public ResponseEntity<?> download(@PathVariable UUID uuid, HttpServletRequest request)
-      @Parameter(description = "uuid", example = "0192efc6-9ec2-43ee-9a90-5b73e763c09f")
-          @PathVariable
-          UUID uuid)
       throws IOException {
 
     String path;
     String uid;
+
     try {
       Map<String, Object> map = inferenceResultService.shpDownloadPath(uuid);
       path = String.valueOf(map.get("path"));
@@ -360,24 +373,11 @@ public class InferenceResultApiController {
 
     Path zipPath = Path.of(path);
 
-    if (!Files.exists(zipPath) || !Files.isReadable(zipPath)) {
+    // Range + 200/206/416 공통 처리 (추가 헤더 포함)
-      return ResponseEntity.notFound().build();
+    return rangeDownloadResponder.buildZipResponse(zipPath, uid + ".zip", request);
-    }
-
-    FileSystemResource resource = new FileSystemResource(zipPath);
-
-    String filename = uid + ".zip";
-
-    long fileSize = Files.size(zipPath);
-
-    return ResponseEntity.ok()
-        .contentType(MediaType.APPLICATION_OCTET_STREAM)
-        .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"")
-        .contentLength(fileSize)
-        .body(resource);
   }
 
-  @Operation(summary = "shp 파일 다운로드 이력", description = "추론관리 분석결과 shp 파일 다운로드 이력")
+  @Operation(summary = "shp 파일 다운로드 이력 조회", description = "추론관리 분석결과 shp 파일 다운로드 이력 조회")
   @GetMapping(value = "/download-audit/{uuid}")
   @ApiResponses(
       value = {
@@ -392,19 +392,20 @@ public class InferenceResultApiController {
         @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
       })
   public ApiResponseDto<Page<AuditLogDto.DownloadRes>> downloadAudit(
-      @Parameter(description = "UUID", example = "0192efc6-9ec2-43ee-9a90-5b73e763c09f")
+      @Parameter(description = "UUID", example = "69c4e56c-e0bf-4742-9225-bba9aae39052")
           @PathVariable
           UUID uuid,
       @Parameter(description = "다운로드일 시작", example = "2025-01-01") @RequestParam(required = false)
           LocalDate strtDttm,
-      @Parameter(description = "다운로드일 종료", example = "2026-01-01") @RequestParam(required = false)
+      @Parameter(description = "다운로드일 종료", example = "2026-04-01") @RequestParam(required = false)
           LocalDate endDttm,
-      @Parameter(description = "키워드", example = "관리자") @RequestParam(required = false)
+      @Parameter(description = "키워드", example = "") @RequestParam(required = false)
           String searchValue,
       @Parameter(description = "페이지 번호 (0부터 시작)", example = "0") @RequestParam(defaultValue = "0")
           int page,
       @Parameter(description = "페이지 크기", example = "20") @RequestParam(defaultValue = "20")
           int size) {
+
     AuditLogDto.searchReq searchReq = new searchReq();
     searchReq.setPage(page);
     searchReq.setSize(size);
@@ -413,8 +414,7 @@ public class InferenceResultApiController {
     downloadReq.setStartDate(strtDttm);
     downloadReq.setEndDate(endDttm);
     downloadReq.setSearchValue(searchValue);
-    downloadReq.setMenuId("22");
+    downloadReq.setRequestUri("/api/inference/download/" + uuid);
-    downloadReq.setRequestUri("/api/inference/download-audit");
 
     return ApiResponseDto.ok(inferenceResultService.getDownloadAudit(searchReq, downloadReq));
   }

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

@@ -0,0 +1,57 @@
+package com.kamco.cd.kamcoback.inference;
+
+import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
+import com.kamco.cd.kamcoback.inference.service.InferenceRunService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.Content;
+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.UUID;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@Tag(name = "추론 실행", description = "추론 실행")
+@Log4j2
+@RequestMapping("/api/inference/run")
+@RequiredArgsConstructor
+@RestController
+public class InferenceRunController {
+
+  private final InferenceRunService inferenceRunService;
+
+  @Operation(summary = "추론 진행 여부 확인", description = "어드민 홈 > 추론관리 > 추론관리 > 추론관리 목록")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "검색 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema =
+                        @Schema(
+                            description = "진행 여부 (UUID 있으면 진행중)",
+                            type = "UUID",
+                            example = "44709877-2e27-4fc5-bacb-8e0328c69b64"))),
+        @ApiResponse(responseCode = "400", description = "잘못된 검색 조건", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  @GetMapping
+  public ApiResponseDto<Void> getProcessing(
+      @Parameter(description = "비교년도", example = "2021") @RequestParam(required = false)
+          Integer compareYear,
+      @Parameter(description = "기준년도", example = "2022") @RequestParam(required = false)
+          Integer targetYear,
+      @Parameter(description = "모델 uuid") @RequestParam(required = false) UUID modelUuid) {
+
+    inferenceRunService.run(compareYear, targetYear, modelUuid);
+    return ApiResponseDto.ok(null);
+  }
+}

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

@@ -534,6 +534,10 @@ public class InferenceDetailDto {
         throw new RuntimeException(e);
       }
     }
+
+    public Boolean getApplyYn() {
+      return this.applyYn != null && this.applyYn;
+    }
   }
 
   @Getter

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

@@ -246,15 +246,15 @@ public class InferenceResultDto {
     @NotBlank
     private String title;
 
-    @Schema(description = "M1", example = "b40e0f68-c1d8-49fc-93f9-a36270093861")
+    @Schema(description = "G1", example = "b40e0f68-c1d8-49fc-93f9-a36270093861")
     @NotNull
     private UUID model1Uuid;
 
-    @Schema(description = "M2", example = "ec92b7d2-b5a3-4915-9bdf-35fb3ca8ad27")
+    @Schema(description = "G2", example = "ec92b7d2-b5a3-4915-9bdf-35fb3ca8ad27")
     @NotNull
     private UUID model2Uuid;
 
-    @Schema(description = "M3", example = "37f45782-8ccf-4cf6-911c-a055a1510d39")
+    @Schema(description = "G3", example = "37f45782-8ccf-4cf6-911c-a055a1510d39")
     @NotNull
     private UUID model3Uuid;
 
@@ -297,6 +297,30 @@ public class InferenceResultDto {
   @Schema(name = "InferenceStatusDetailDto", description = "추론(변화탐지) 진행상태")
   public static class InferenceStatusDetailDto {
 
+    @Schema(description = "모델1 사용시간 시작일시")
+    @JsonFormatDttm
+    ZonedDateTime m1ModelStartDttm;
+
+    @Schema(description = "모델2 사용시간 시작일시")
+    @JsonFormatDttm
+    ZonedDateTime m2ModelStartDttm;
+
+    @Schema(description = "모델3 사용시간 시작일시")
+    @JsonFormatDttm
+    ZonedDateTime m3ModelStartDttm;
+
+    @Schema(description = "모델1 사용시간 종료일시")
+    @JsonFormatDttm
+    ZonedDateTime m1ModelEndDttm;
+
+    @Schema(description = "모델2 사용시간 종료일시")
+    @JsonFormatDttm
+    ZonedDateTime m2ModelEndDttm;
+
+    @Schema(description = "모델3 사용시간 종료일시")
+    @JsonFormatDttm
+    ZonedDateTime m3ModelEndDttm;
+
     @Schema(description = "탐지대상 도엽수")
     private Long detectingCnt;
 
@@ -336,30 +360,6 @@ public class InferenceResultDto {
     @Schema(description = "모델3 분석 실패")
     private Integer m3FailedJobs;
 
-    @Schema(description = "모델1 사용시간 시작일시")
-    @JsonFormatDttm
-    ZonedDateTime m1ModelStartDttm;
-
-    @Schema(description = "모델2 사용시간 시작일시")
-    @JsonFormatDttm
-    ZonedDateTime m2ModelStartDttm;
-
-    @Schema(description = "모델3 사용시간 시작일시")
-    @JsonFormatDttm
-    ZonedDateTime m3ModelStartDttm;
-
-    @Schema(description = "모델1 사용시간 종료일시")
-    @JsonFormatDttm
-    ZonedDateTime m1ModelEndDttm;
-
-    @Schema(description = "모델2 사용시간 종료일시")
-    @JsonFormatDttm
-    ZonedDateTime m2ModelEndDttm;
-
-    @Schema(description = "모델3 사용시간 종료일시")
-    @JsonFormatDttm
-    ZonedDateTime m3ModelEndDttm;
-
     @Schema(description = "변화탐지 제목")
     private String title;
 
@@ -496,19 +496,19 @@ public class InferenceResultDto {
       return MapSheetScope.getDescByCode(this.mapSheetScope);
     }
 
-    @Schema(description = "M1 사용시간")
+    @Schema(description = "G1 사용시간")
     @JsonProperty("m1ElapsedTim")
     public String getM1ElapsedTime() {
       return formatElapsedTime(this.m1ModelStartDttm, this.m1ModelEndDttm);
     }
 
-    @Schema(description = "M2 사용시간")
+    @Schema(description = "G2 사용시간")
     @JsonProperty("m2ElapsedTim")
     public String getM2ElapsedTime() {
       return formatElapsedTime(this.m2ModelStartDttm, this.m2ModelEndDttm);
     }
 
-    @Schema(description = "M3 사용시간")
+    @Schema(description = "G3 사용시간")
     @JsonProperty("m3ElapsedTim")
     public String getM3ElapsedTime() {
       return formatElapsedTime(this.m3ModelStartDttm, this.m3ModelEndDttm);

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

@@ -1,10 +1,12 @@
 package com.kamco.cd.kamcoback.inference.dto;
 
 import com.kamco.cd.kamcoback.postgres.entity.InferenceResultsTestingEntity;
+import java.time.ZonedDateTime;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
+import org.locationtech.jts.geom.Geometry;
 
 public class InferenceResultsTestingDto {
 
@@ -22,4 +24,31 @@ public class InferenceResultsTestingDto {
       return new ShpDto(e.getBatchId(), e.getUid(), e.getMapId());
     }
   }
+
+  @Getter
+  @Setter
+  @AllArgsConstructor
+  @NoArgsConstructor
+  public static class Basic {
+    private Double probability;
+    private Long beforeYear;
+    private Long afterYear;
+    private String mapId;
+    private String modelVersion;
+    private String clsModelPath;
+    private String clsModelVersion;
+    private String cdModelType;
+    private Long id;
+    private String modelName;
+    private Long batchId;
+    private Double area;
+    private String beforeC;
+    private Double beforeP;
+    private String afterC;
+    private Double afterP;
+    private Long seq;
+    private ZonedDateTime createdDate;
+    private String uid;
+    private Geometry geometry;
+  }
 }

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

@@ -5,8 +5,10 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
+import lombok.extern.slf4j.Slf4j;
 
 /** AI API 추론 실행 DTO */
+@Slf4j
 @Getter
 @Setter
 @NoArgsConstructor

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

@@ -0,0 +1,10 @@
+package com.kamco.cd.kamcoback.inference.service;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/inference/manual")
+public class InferenceManualApiController {}

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

@@ -0,0 +1,22 @@
+package com.kamco.cd.kamcoback.inference.service;
+
+import com.kamco.cd.kamcoback.inference.dto.InferenceResultsTestingDto;
+import com.kamco.cd.kamcoback.postgres.core.InferenceResultCoreService;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class InferenceManualService {
+  private final InferenceResultCoreService inferenceResultCoreService;
+
+  public void getResultsTesting(List<Long> batchIds) {
+    List<InferenceResultsTestingDto.Basic> resultList =
+        inferenceResultCoreService.getInferenceResults(batchIds);
+
+    if (resultList.isEmpty()) {}
+
+    for (InferenceResultsTestingDto.Basic result : resultList) {}
+  }
+}

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

@@ -45,6 +45,7 @@ import java.time.ZonedDateTime;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -116,6 +117,124 @@ public class InferenceResultService {
     return dto.getUuid();
   }
 
+  @Transactional
+  public UUID run(InferenceResultDto.RegReq req) {
+    List<MngListDto> targetDtoList = mapSheetMngCoreService.getHstMapSheetList(req);
+    List<String> compareList = mapSheetMngCoreService.getMapSheetMngHst(req.getCompareYyyy());
+    List<String> targetList =
+        mapSheetMngCoreService.getHstMapSheetList(req).stream()
+            .map(MngListDto::getMapSheetNum)
+            .filter(Objects::nonNull)
+            .distinct()
+            .toList();
+
+    log.info(
+        "hst list count compareList = {}, targetList = {}", compareList.size(), targetList.size());
+
+    Set<String> compareSet = new HashSet<>(compareList);
+    Set<String> targetSet = new HashSet<>(targetList);
+
+    long intersectionCount =
+        targetSet.stream()
+            .distinct()
+            .filter(compareSet::contains)
+            .count(); // compare와 target에 공통으로 존재하는 도협 수
+
+    long excludedTargetCount =
+        targetSet.stream()
+            .distinct()
+            .filter(s -> !compareSet.contains(s))
+            .count(); // target 에만 존재하는 도협 수 (compare 에는 없음)
+
+    long onlyCompareCount =
+        compareSet.stream()
+            .distinct()
+            .filter(s -> !targetSet.contains(s))
+            .count(); // compare 에만 존재하는 도협 수 (target 에는 없음)
+
+    log.info(
+        """
+    ===== MapSheet Year Comparison =====
+    target Total: {}
+    compare Total: {}
+    Intersection: {}
+    target Only (Excluded from compare): {}
+    compare Only: {}
+    ====================================
+    """,
+        targetSet.size(),
+        compareSet.size(),
+        intersectionCount,
+        excludedTargetCount,
+        onlyCompareCount);
+
+    List<String> filteredTargetList =
+        targetSet.stream() // target 기준으로
+            .filter(compareSet::contains) // compare에 있는 도협만 남김
+            .toList();
+
+    Scene modelComparePath =
+        getSceneInference(req.getCompareYyyy().toString(), filteredTargetList, "", "");
+
+    Scene modelTargetPath =
+        getSceneInference(req.getTargetYyyy().toString(), filteredTargetList, "", "");
+
+    // 작은 쪽 기준으로 탐지건수/파일생성 리스트 결정
+    List<ImageFeature> imageFeatureList;
+    if (modelComparePath.getFeatures().size() <= modelTargetPath.getFeatures().size()) {
+      imageFeatureList = modelComparePath.getFeatures();
+    } else {
+      imageFeatureList = modelTargetPath.getFeatures();
+    }
+
+    // imageFeatureList 기준 sceneId Set
+    Set<String> sceneIdSet =
+        imageFeatureList.stream()
+            .map(ImageFeature::getSceneId)
+            .filter(Objects::nonNull)
+            .collect(Collectors.toSet());
+
+    // targetList(List<MngListDto>) 리턴용으로 필터링
+    List<MngListDto> newTargetList =
+        targetDtoList.stream()
+            .filter(m -> m.getMapSheetNum() != null)
+            .filter(m -> sceneIdSet.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());
+
+    InferenceSendDto m1 = this.getModelInfo(req.getModel1Uuid());
+    m1.setPred_requests_areas(predRequestsAreas);
+
+    log.info("[INFERENCE] Start m1 = {}", m1);
+    m1.setPred_requests_areas(predRequestsAreas);
+
+    // ai 추론 실행 api 호출
+    Long batchId = ensureAccepted(m1);
+
+    // ai 추론 실행후 응답값 update
+    SaveInferenceAiDto saveInferenceAiDto = new SaveInferenceAiDto();
+    saveInferenceAiDto.setUuid(uuid);
+    saveInferenceAiDto.setBatchId(batchId);
+    saveInferenceAiDto.setStatus(Status.IN_PROGRESS.getId());
+    saveInferenceAiDto.setType(ModelType.G1.getId());
+    saveInferenceAiDto.setInferStartDttm(ZonedDateTime.now());
+    saveInferenceAiDto.setModelComparePath(modelComparePath.getFilePath());
+    saveInferenceAiDto.setModelTargetPath(modelTargetPath.getFilePath());
+    saveInferenceAiDto.setModelStartDttm(ZonedDateTime.now());
+    inferenceResultCoreService.update(saveInferenceAiDto);
+
+    return uuid;
+  }
+
   /**
    * 변화탐지 실행 정보 생성
    *
@@ -146,31 +265,31 @@ public class InferenceResultService {
 
     List<TotalListDto> totalNumList = new ArrayList<>();
 
-    if (DetectOption.EXCL.getId().equals(req.getDetectOption())) {
+    //    if (DetectOption.EXCL.getId().equals(req.getDetectOption())) {
-      // "추론제외" 일때 전년도 이전 값이 있어도 전년도 도엽이 없으면 비교 안함
+    //      // "추론제외" 일때 전년도 이전 값이 있어도 전년도 도엽이 없으면 비교 안함
-      for (MngListCompareDto dto : compareList) {
+    //      for (MngListCompareDto dto : compareList) {
-        if (Objects.equals(dto.getBeforeYear(), req.getCompareYyyy())) {
+    //        if (Objects.equals(dto.getBeforeYear(), req.getCompareYyyy())) {
-          TotalListDto totalDto = new TotalListDto();
+    //          TotalListDto totalDto = new TotalListDto();
-          totalDto.setBeforeYear(dto.getBeforeYear() == null ? 0 : dto.getBeforeYear());
+    //          totalDto.setBeforeYear(dto.getBeforeYear() == null ? 0 : dto.getBeforeYear());
-          totalDto.setMapSheetNum(dto.getMapSheetNum());
+    //          totalDto.setMapSheetNum(dto.getMapSheetNum());
-          totalNumList.add(totalDto);
+    //          totalNumList.add(totalDto);
-        }
+    //        }
-      }
+    //      }
-    } else if (DetectOption.PREV.getId().equals(req.getDetectOption())) {
+    //    } else if (DetectOption.PREV.getId().equals(req.getDetectOption())) {
-      // "이전 년도 도엽 사용" 이면 전년도 이전 도엽도 사용
+    //      // "이전 년도 도엽 사용" 이면 전년도 이전 도엽도 사용
-      for (MngListCompareDto dto : compareList) {
+    //      for (MngListCompareDto dto : compareList) {
-        if (dto.getBeforeYear() != 0) {
+    //        if (dto.getBeforeYear() != 0) {
-          TotalListDto totalDto = new TotalListDto();
+    //          TotalListDto totalDto = new TotalListDto();
-          totalDto.setBeforeYear(dto.getBeforeYear() == null ? 0 : dto.getBeforeYear());
+    //          totalDto.setBeforeYear(dto.getBeforeYear() == null ? 0 : dto.getBeforeYear());
-          totalDto.setMapSheetNum(dto.getMapSheetNum());
+    //          totalDto.setMapSheetNum(dto.getMapSheetNum());
-          totalNumList.add(totalDto);
+    //          totalNumList.add(totalDto);
-        }
+    //        }
-      }
+    //      }
-    }
+    //    }
-
+    //
-    if (totalNumList.isEmpty()) {
+    //    if (totalNumList.isEmpty()) {
-      throw new CustomApiException("NOT_FOUND_COMPARE_YEAR", HttpStatus.NOT_FOUND);
+    //      throw new CustomApiException("NOT_FOUND_COMPARE_YEAR", HttpStatus.NOT_FOUND);
-    }
+    //    }
 
     // 사용할 영상파일 년도 기록 및 추론에 포함되는지 설정
     for (MngListDto target : targetList) {
@@ -238,6 +357,8 @@ public class InferenceResultService {
     predRequestsAreas.setInput2_scene_path(modelTargetPath.getFilePath());
 
     InferenceSendDto m1 = this.getModelInfo(req.getModel1Uuid());
+
+    log.info("[INFERENCE] Start m1 = {}", m1);
     m1.setPred_requests_areas(predRequestsAreas);
 
     // ai 추론 실행 api 호출
@@ -248,7 +369,7 @@ public class InferenceResultService {
     saveInferenceAiDto.setUuid(uuid);
     saveInferenceAiDto.setBatchId(batchId);
     saveInferenceAiDto.setStatus(Status.IN_PROGRESS.getId());
-    saveInferenceAiDto.setType("M1");
+    saveInferenceAiDto.setType(ModelType.G1.getId());
     saveInferenceAiDto.setInferStartDttm(ZonedDateTime.now());
     saveInferenceAiDto.setModelComparePath(modelComparePath.getFilePath());
     saveInferenceAiDto.setModelTargetPath(modelTargetPath.getFilePath());
@@ -325,6 +446,7 @@ public class InferenceResultService {
    *
    * @param dto
    */
+  // 같은함수가 왜 두개지
   private Long ensureAccepted(InferenceSendDto dto) {
 
     if (dto == null) {
@@ -332,6 +454,14 @@ public class InferenceResultService {
       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));
@@ -340,13 +470,15 @@ public class InferenceResultService {
     }
 
     // 2) local 환경 임시 처리
-    if ("local".equals(profile)) {
+    //    if ("local".equals(profile)) {
-      if (dto.getPred_requests_areas() == null) {
+    //      if (dto.getPred_requests_areas() == null) {
-        throw new IllegalStateException("pred_requests_areas is 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");
+    // 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();
@@ -414,12 +546,12 @@ public class InferenceResultService {
 
     String modelType = "";
 
-    if (modelInfo.getModelType().equals(ModelType.M1.getId())) {
+    if (modelInfo.getModelType().equals(ModelType.G1.getId())) {
-      modelType = "G1";
+      modelType = ModelType.G1.getId();
-    } else if (modelInfo.getModelType().equals(ModelType.M2.getId())) {
+    } else if (modelInfo.getModelType().equals(ModelType.G2.getId())) {
-      modelType = "G2";
+      modelType = ModelType.G2.getId();
     } else {
-      modelType = "G3";
+      modelType = ModelType.G3.getId();
     }
 
     InferenceSendDto sendDto = new InferenceSendDto();
@@ -429,7 +561,8 @@ public class InferenceResultService {
     sendDto.setCls_model_path(cdClsModelPath);
     sendDto.setCls_model_version(modelInfo.getModelVer());
     sendDto.setCd_model_type(modelType);
-    sendDto.setPriority(modelInfo.getPriority());
+    sendDto.setPriority(5d);
+    log.info("[Inference Send]SendDto={}", sendDto);
     return sendDto;
   }
 

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

@@ -0,0 +1,224 @@
+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.Scene;
+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 com.kamco.cd.kamcoback.inference.dto.InferenceSendDto.pred_requests_areas;
+import com.kamco.cd.kamcoback.model.dto.ModelMngDto.Basic;
+import com.kamco.cd.kamcoback.model.dto.ModelMngDto.ModelType;
+import com.kamco.cd.kamcoback.postgres.core.MapSheetMngCoreService;
+import com.kamco.cd.kamcoback.postgres.core.ModelMngCoreService;
+import java.nio.file.Paths;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+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;
+
+@Service
+@Log4j2
+@RequiredArgsConstructor
+public class InferenceRunService {
+  private final ExternalHttpClient externalHttpClient;
+  private final MapSheetMngCoreService mapSheetMngCoreService;
+  private final ModelMngCoreService modelMngCoreService;
+  private final ObjectMapper objectMapper;
+
+  @Value("${spring.profiles.active}")
+  private String profile;
+
+  @Value("${inference.url}")
+  private String inferenceUrl;
+
+  // TODO 이거 쓰는건가?
+  public void run(Integer compareYear, Integer targetYear, UUID modelUuid) {
+
+    List<String> compareList = mapSheetMngCoreService.getMapSheetMngHst(compareYear);
+    List<String> targetList = mapSheetMngCoreService.getMapSheetMngHst(targetYear);
+
+    log.info(
+        "hst list count compareList = {}, targetList = {}", compareList.size(), targetList.size());
+
+    Set<String> compareSet = new HashSet<>(compareList);
+    Set<String> targetSet = new HashSet<>(targetList);
+
+    long intersectionCount =
+        targetSet.stream()
+            .distinct()
+            .filter(compareSet::contains)
+            .count(); // compare와 target에 공통으로 존재하는 도협 수
+
+    long excludedTargetCount =
+        targetSet.stream()
+            .distinct()
+            .filter(s -> !compareSet.contains(s))
+            .count(); // target 에만 존재하는 도협 수 (compare 에는 없음)
+
+    long onlyCompareCount =
+        compareSet.stream()
+            .distinct()
+            .filter(s -> !targetSet.contains(s))
+            .count(); // compare 에만 존재하는 도협 수 (target 에는 없음)
+
+    log.info(
+        """
+      ===== MapSheet Year Comparison =====
+      target Total: {}
+      compare Total: {}
+      Intersection: {}
+      target Only (Excluded from compare): {}
+      compare Only: {}
+      ====================================
+      """,
+        targetSet.size(),
+        compareSet.size(),
+        intersectionCount,
+        excludedTargetCount,
+        onlyCompareCount);
+
+    List<String> filteredTargetList =
+        targetSet.stream() // target 기준으로
+            .filter(compareSet::contains) // compare에 있는 도협만 남김
+            .toList();
+
+    Scene modelComparePath = getSceneInference(compareYear.toString(), filteredTargetList, "", "");
+
+    Scene modelTargetPath = getSceneInference(targetYear.toString(), filteredTargetList, "", "");
+
+    // ai 서버에 전달할 파라미터 생성
+    pred_requests_areas predRequestsAreas = new pred_requests_areas();
+    predRequestsAreas.setInput1_year(compareYear);
+    predRequestsAreas.setInput2_year(targetYear);
+    predRequestsAreas.setInput1_scene_path(modelComparePath.getFilePath());
+    predRequestsAreas.setInput2_scene_path(modelTargetPath.getFilePath());
+
+    InferenceSendDto m1 = this.getModelInfo(modelUuid);
+    m1.setPred_requests_areas(predRequestsAreas);
+
+    // ai 추론 실행 api 호출
+    Long batchId = ensureAccepted(m1);
+  }
+
+  private Scene getSceneInference(
+      String yyyy, List<String> mapSheetNums, String mapSheetScope, String detectOption) {
+    return mapSheetMngCoreService.getSceneInference(
+        yyyy, mapSheetNums, mapSheetScope, detectOption);
+  }
+
+  /**
+   * 추론 AI API 호출
+   *
+   * @param dto
+   */
+  private Long ensureAccepted(InferenceSendDto dto) {
+
+    if (dto == null) {
+      log.warn("not InferenceSendDto dto");
+      throw new CustomApiException("BAD_REQUEST", HttpStatus.BAD_REQUEST);
+    }
+
+    // 1) 요청 로그
+    try {
+      log.info("Inference request dto={}", objectMapper.writeValueAsString(dto));
+    } catch (JsonProcessingException e) {
+      log.warn("Failed to serialize inference dto", e);
+    }
+
+    // 3) HTTP 호출
+    HttpHeaders headers = new HttpHeaders();
+    headers.setContentType(MediaType.APPLICATION_JSON);
+    headers.setAccept(List.of(MediaType.APPLICATION_JSON));
+
+    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 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);
+    }
+  }
+
+  /**
+   * 모델정보 조회 dto 생성 후 반환
+   *
+   * @param uuid
+   * @return
+   */
+  private InferenceSendDto getModelInfo(UUID uuid) {
+
+    Basic modelInfo = modelMngCoreService.findByModelUuid(uuid);
+
+    String cdModelPath = "";
+    String cdModelConfigPath = "";
+    String cdClsModelPath = "";
+
+    if (modelInfo.getCdModelPath() != null && modelInfo.getCdModelFileName() != null) {
+      cdModelPath =
+          Paths.get(modelInfo.getCdModelPath(), modelInfo.getCdModelFileName()).toString();
+    }
+
+    if (modelInfo.getCdModelConfig() != null && modelInfo.getCdModelConfigFileName() != null) {
+      cdModelConfigPath =
+          Paths.get(modelInfo.getCdModelConfig(), modelInfo.getCdModelConfigFileName()).toString();
+    }
+
+    if (modelInfo.getClsModelPath() != null && modelInfo.getClsModelFileName() != null) {
+      cdClsModelPath =
+          Paths.get(modelInfo.getClsModelPath(), modelInfo.getClsModelFileName()).toString();
+    }
+
+    String modelType = "";
+
+    if (modelInfo.getModelType().equals(ModelType.G1.getId())) {
+      modelType = ModelType.G1.getId();
+    } else if (modelInfo.getModelType().equals(ModelType.G2.getId())) {
+      modelType = ModelType.G2.getId();
+    } else {
+      modelType = ModelType.G3.getId();
+    }
+
+    InferenceSendDto sendDto = new InferenceSendDto();
+    sendDto.setModel_version(modelInfo.getModelVer());
+    sendDto.setCd_model_path(cdModelPath);
+    sendDto.setCd_model_config(cdModelConfigPath);
+    sendDto.setCls_model_path(cdClsModelPath);
+    sendDto.setCls_model_version(modelInfo.getModelVer());
+    sendDto.setCd_model_type(modelType);
+    sendDto.setPriority(5.0);
+    return sendDto;
+  }
+}

src/main/java/com/kamco/cd/kamcoback/label/LabelAllocateApiController.java

@@ -1,5 +1,6 @@
 package com.kamco.cd.kamcoback.label;
 
+import com.kamco.cd.kamcoback.common.download.RangeDownloadResponder;
 import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.InferenceDetail;
@@ -9,20 +10,35 @@ import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.WorkHistoryDto;
 import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.UpdateClosedRequest;
 import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.WorkerListResponse;
 import com.kamco.cd.kamcoback.label.service.LabelAllocateService;
+import com.kamco.cd.kamcoback.log.dto.AuditLogDto;
+import com.kamco.cd.kamcoback.log.dto.AuditLogDto.DownloadReq;
+import com.kamco.cd.kamcoback.log.dto.AuditLogDto.searchReq;
 import io.swagger.v3.oas.annotations.Hidden;
 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.Content;
 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 jakarta.servlet.http.HttpServletRequest;
 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.LocalDate;
 import java.util.List;
+import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.coyote.BadRequestException;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.domain.Page;
+import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
+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;
@@ -37,6 +53,10 @@ import org.springframework.web.bind.annotation.RestController;
 public class LabelAllocateApiController {
 
   private final LabelAllocateService labelAllocateService;
+  private final RangeDownloadResponder rangeDownloadResponder;
+
+  @Value("${file.dataset-response}")
+  private String responsePath;
 
   @Operation(summary = "배정 가능한 사용자 목록 조회", description = "라벨링 작업 배정을 위한 활성 상태의 사용자 목록을 조회합니다.")
   @ApiResponses(
@@ -333,4 +353,149 @@ public class LabelAllocateApiController {
   public ApiResponseDto<Long> labelingIngProcessCnt() {
     return ApiResponseDto.ok(labelAllocateService.findLabelingIngProcessCnt());
   }
+
+  @Operation(
+      summary = "라벨 파일 다운로드",
+      description = "라벨 파일 다운로드",
+      parameters = {
+        @Parameter(
+            name = "kamco-download-uuid",
+            in = ParameterIn.HEADER,
+            required = true,
+            description = "다운로드 요청 UUID",
+            schema =
+                @Schema(
+                    type = "string",
+                    format = "uuid",
+                    example = "6d8d49dc-0c9d-4124-adc7-b9ca610cc394"))
+      })
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "라벨 zip파일 다운로드",
+            content =
+                @Content(
+                    mediaType = "application/octet-stream",
+                    schema = @Schema(type = "string", format = "binary"))),
+        @ApiResponse(responseCode = "404", description = "파일 없음", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  @GetMapping("/download/{uuid}")
+  public ResponseEntity<?> download(@PathVariable UUID uuid, HttpServletRequest request)
+      throws IOException {
+
+    String uid = labelAllocateService.findLearnUid(uuid);
+    Path zipPath = Paths.get(responsePath).resolve(uid + ".zip");
+
+    if (!Files.isRegularFile(zipPath)) {
+      throw new BadRequestException();
+    }
+
+    return rangeDownloadResponder.buildZipResponse(zipPath, uid + ".zip", request);
+  }
+
+  @Operation(summary = "라벨 파일 다운로드 이력 조회", description = "라벨 파일 다운로드 이력 조회")
+  @GetMapping(value = "/download-audit/{uuid}")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "검색 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = Page.class))),
+        @ApiResponse(responseCode = "400", description = "잘못된 검색 조건", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  public ApiResponseDto<Page<AuditLogDto.DownloadRes>> downloadAudit(
+      @Parameter(description = "UUID", example = "6d8d49dc-0c9d-4124-adc7-b9ca610cc394")
+          @PathVariable
+          UUID uuid,
+      //    @Parameter(description = "다운로드일 시작", example = "2025-01-01") @RequestParam(required =
+      // false)
+      //    LocalDate strtDttm,
+      //    @Parameter(description = "다운로드일 종료", example = "2026-04-01") @RequestParam(required =
+      // false)
+      //    LocalDate endDttm,
+      //    @Parameter(description = "키워드", example = "") @RequestParam(required = false)
+      //    String searchValue,
+      @Parameter(description = "페이지 번호 (0부터 시작)", example = "0") @RequestParam(defaultValue = "0")
+          int page,
+      @Parameter(description = "페이지 크기", example = "20") @RequestParam(defaultValue = "20")
+          int size) {
+
+    AuditLogDto.searchReq searchReq = new searchReq();
+    searchReq.setPage(page);
+    searchReq.setSize(size);
+    DownloadReq downloadReq = new DownloadReq();
+    downloadReq.setUuid(uuid);
+    //    downloadReq.setStartDate(strtDttm);
+    //    downloadReq.setEndDate(endDttm);
+    //    downloadReq.setSearchValue(searchValue);
+    downloadReq.setRequestUri("/api/training-data/stage/download/" + uuid);
+
+    return ApiResponseDto.ok(labelAllocateService.getDownloadAudit(searchReq, downloadReq));
+  }
+
+  @Operation(summary = "다운로드 가능여부 조회", description = "다운로드 가능여부 조회 API")
+  @GetMapping(value = "/download-check/{uuid}")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "검색 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = Page.class))),
+        @ApiResponse(responseCode = "400", description = "잘못된 검색 조건", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  public ApiResponseDto<Boolean> isDownloadable(
+      @Parameter(description = "UUID", example = "6d8d49dc-0c9d-4124-adc7-b9ca610cc394")
+          @PathVariable
+          UUID uuid) {
+    return ApiResponseDto.ok(labelAllocateService.isDownloadable(uuid));
+  }
+
+  @Operation(
+      summary = "라벨링작업 관리 > 추가 작업 배정(실태조사 추가되면)",
+      description = "라벨링작업 관리 > 추가 작업 배정(실태조사 추가되면)")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "201",
+            description = "등록 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = Long.class))),
+        @ApiResponse(responseCode = "400", description = "잘못된 요청 데이터", content = @Content),
+        @ApiResponse(responseCode = "404", description = "코드를 찾을 수 없음", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  @PostMapping("/allocate-add-stblt")
+  public ApiResponseDto<ApiResponseDto.ResponseObj> labelAllocateAddStblt(
+      @RequestBody @Valid LabelAllocateDto.AllocateAddStbltDto dto) {
+
+    return ApiResponseDto.okObject(
+        labelAllocateService.allocateAddStbltYn(
+            dto.getTotalCnt(), dto.getUuid(), dto.getLabelers(), dto.getBaseDate()));
+  }
+
+  @Operation(summary = "라벨링 추가 할당 가능한 건수", description = "라벨링 추가 할당 가능한 건수 API")
+  @ApiResponses(
+      value = {
+        @ApiResponse(responseCode = "200", description = "조회 성공"),
+        @ApiResponse(responseCode = "404", description = "코드를 찾을 수 없음"),
+        @ApiResponse(responseCode = "500", description = "서버 오류")
+      })
+  @GetMapping("/allocate-add-cnt")
+  public ApiResponseDto<Long> allocateAddCnt(
+      @RequestParam UUID uuid, @RequestParam LocalDate baseDate) {
+
+    return ApiResponseDto.ok(labelAllocateService.findAllocateAddCnt(uuid, baseDate));
+  }
 }

src/main/java/com/kamco/cd/kamcoback/label/dto/LabelAllocateDto.java

@@ -3,6 +3,7 @@ package com.kamco.cd.kamcoback.label.dto;
 import com.kamco.cd.kamcoback.common.utils.enums.CodeExpose;
 import com.kamco.cd.kamcoback.common.utils.enums.EnumType;
 import io.swagger.v3.oas.annotations.media.Schema;
+import java.time.LocalDate;
 import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.UUID;
@@ -359,4 +360,41 @@ public class LabelAllocateDto {
     @Schema(description = "작업기간 종료일")
     private ZonedDateTime projectCloseDttm;
   }
+
+  @Getter
+  @Setter
+  @AllArgsConstructor
+  @NoArgsConstructor
+  public static class InferenceLearnDto {
+
+    private UUID analUuid;
+    private String learnUid;
+    private String analState;
+    private Long analId;
+  }
+
+  @Getter
+  @Setter
+  @AllArgsConstructor
+  public static class AllocateAddStbltDto {
+
+    @Schema(description = "총 잔여 건수", example = "179")
+    private Integer totalCnt;
+
+    @Schema(
+        description = "추가할당할 라벨러",
+        example =
+            """
+        [
+          "123454", "654321", "222233", "777222"
+        ]
+        """)
+    private List<String> labelers;
+
+    @Schema(description = "회차 마스터 key", example = "c0e77cc7-8c28-46ba-9ca4-11e90246ab44")
+    private UUID uuid;
+
+    @Schema(description = "기준일자", example = "2026-02-20")
+    private LocalDate baseDate;
+  }
 }

src/main/java/com/kamco/cd/kamcoback/label/service/LabelAllocateService.java

@@ -16,25 +16,29 @@ import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.searchReq;
 import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.ProjectInfo;
 import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.WorkProgressInfo;
 import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.WorkerListResponse;
+import com.kamco.cd.kamcoback.log.dto.AuditLogDto;
+import com.kamco.cd.kamcoback.log.dto.AuditLogDto.DownloadReq;
+import com.kamco.cd.kamcoback.postgres.core.AuditLogCoreService;
 import com.kamco.cd.kamcoback.postgres.core.LabelAllocateCoreService;
+import java.time.LocalDate;
 import java.util.List;
 import java.util.Objects;
 import java.util.UUID;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Page;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 @Slf4j
 @Service
-@Transactional
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
 public class LabelAllocateService {
 
   private final LabelAllocateCoreService labelAllocateCoreService;
-
+  private final AuditLogCoreService auditLogCoreService;
-  public LabelAllocateService(LabelAllocateCoreService labelAllocateCoreService) {
-    this.labelAllocateCoreService = labelAllocateCoreService;
-  }
 
   /**
    * 도엽 기준 asc sorting 해서 할당 수만큼 배정하는 로직
@@ -273,4 +277,78 @@ public class LabelAllocateService {
   public Long findLabelingIngProcessCnt() {
     return labelAllocateCoreService.findLabelingIngProcessCnt();
   }
+
+  @Transactional(propagation = Propagation.NOT_SUPPORTED)
+  public String findLearnUid(UUID uuid) {
+    return labelAllocateCoreService.findLearnUid(uuid);
+  }
+
+  /**
+   * 다운로드 이력 조회
+   *
+   * @param searchReq 페이징
+   * @param downloadReq 조회조건
+   */
+  public Page<AuditLogDto.DownloadRes> getDownloadAudit(
+      AuditLogDto.searchReq searchReq, DownloadReq downloadReq) {
+    return auditLogCoreService.findLogByAccount(searchReq, downloadReq);
+  }
+
+  /**
+   * 다운로드 가능 여부 조회
+   *
+   * @param uuid
+   * @return
+   */
+  public boolean isDownloadable(UUID uuid) {
+    return labelAllocateCoreService.isDownloadable(uuid);
+  }
+
+  /**
+   * 실태조사가 값 들어온 기간만큼 할당하는 로직 (최초 할당 이후 작업)
+   *
+   * @param uuid
+   * @param targetUsers
+   * @return
+   */
+  @Transactional
+  public ApiResponseDto.ResponseObj allocateAddStbltYn(
+      Integer totalCnt, UUID uuid, List<String> targetUsers, LocalDate baseDate) {
+
+    int userCount = targetUsers.size();
+    if (userCount == 0) {
+      return new ApiResponseDto.ResponseObj(ApiResponseCode.BAD_REQUEST, "추가 할당할 라벨러를 선택해주세요.");
+    }
+
+    int base = totalCnt / userCount;
+    int remainder = totalCnt % userCount;
+    Long lastId = null;
+    List<AllocateInfoDto> allIds =
+        labelAllocateCoreService.fetchNextIdsAddStbltYn(
+            uuid, baseDate, lastId, totalCnt.longValue());
+
+    // MapSheetAnalInferenceEntity analUid 가져오기
+    Long analUid = labelAllocateCoreService.findMapSheetAnalInferenceUid(uuid);
+
+    int index = 0;
+    for (int i = 0; i < userCount; i++) {
+      int assignCount = base;
+      // 마지막 사람에게 나머지 몰아주기
+      if (i == userCount - 1) {
+        assignCount += remainder;
+      }
+
+      int end = index + assignCount;
+      List<AllocateInfoDto> sub = allIds.subList(index, end);
+
+      labelAllocateCoreService.assignOwner(sub, targetUsers.get(i), analUid);
+      index = end;
+    }
+
+    return new ApiResponseDto.ResponseObj(ApiResponseCode.OK, "추가 할당이 완료되었습니다.");
+  }
+
+  public Long findAllocateAddCnt(UUID uuid, LocalDate baseDate) {
+    return labelAllocateCoreService.findAllocateAddCnt(uuid, baseDate);
+  }
 }

src/main/java/com/kamco/cd/kamcoback/layer/LayerApiController.java

@@ -2,10 +2,13 @@ package com.kamco.cd.kamcoback.layer;
 
 import com.kamco.cd.kamcoback.config.api.ApiResponseDto;
 import com.kamco.cd.kamcoback.layer.dto.LayerDto;
+import com.kamco.cd.kamcoback.layer.dto.LayerDto.IsMapYn;
+import com.kamco.cd.kamcoback.layer.dto.LayerDto.LayerMapDto;
 import com.kamco.cd.kamcoback.layer.dto.LayerDto.OrderReq;
 import com.kamco.cd.kamcoback.layer.dto.LayerDto.SearchReq;
 import com.kamco.cd.kamcoback.layer.service.LayerService;
 import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.media.ArraySchema;
 import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -76,10 +79,24 @@ public class LayerApiController {
       })
   @PostMapping("/save/{layerType}")
   public ApiResponseDto<UUID> save(
-      @PathVariable String layerType, @RequestBody LayerDto.AddReq dto) {
+      @Schema(description = "TILE,GEOJSON,WMS,WMTS", example = "GEOJSON") @PathVariable
+          String layerType,
+      @RequestBody LayerDto.AddReq dto) {
     return ApiResponseDto.ok(layerService.saveLayers(layerType, dto));
   }
 
+  @Operation(summary = "순서 변경", description = "순서 변경 api")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "201",
+            description = "등록 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = Void.class))),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
   @PutMapping("/order")
   public ApiResponseDto<Void> updateOrder(@RequestBody List<OrderReq> dto) {
     layerService.orderUpdate(dto);
@@ -152,6 +169,24 @@ public class LayerApiController {
     return ApiResponseDto.ok(null);
   }
 
+  @Operation(summary = "맵 노출여부 수정", description = "맵 노출여부 수정 api")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "201",
+            description = "수정 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = Void.class))),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  @PutMapping("/update-map/{uuid}")
+  public ApiResponseDto<Void> updateIsMap(@PathVariable UUID uuid, @RequestBody IsMapYn isMapYn) {
+    layerService.updateIsMap(uuid, isMapYn);
+    return ApiResponseDto.ok(null);
+  }
+
   @Operation(summary = "wmts tile 조회", description = "wmts tile 조회 api")
   @ApiResponses(
       value = {
@@ -187,4 +222,55 @@ public class LayerApiController {
   public ApiResponseDto<List<String>> getWmsTile() {
     return ApiResponseDto.ok(layerService.getWmsTitle());
   }
+
+  @Operation(summary = "변화지도 레이어 조회", description = "변화지도 레이어 조회")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "검색 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    array = @ArraySchema(schema = @Schema(implementation = String.class)))),
+        @ApiResponse(responseCode = "400", description = "잘못된 검색 조건", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  @GetMapping("/map/change-detection")
+  public ApiResponseDto<List<LayerMapDto>> changeDetectionMap() {
+    return ApiResponseDto.ok(layerService.findLayerMapList("change-detection"));
+  }
+
+  @Operation(summary = "라벨링 툴 레이어 조회", description = "라벨링 툴 레이어 조회")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "검색 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    array = @ArraySchema(schema = @Schema(implementation = String.class)))),
+        @ApiResponse(responseCode = "400", description = "잘못된 검색 조건", content = @Content),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  @GetMapping("/map/labeling")
+  public ApiResponseDto<List<LayerMapDto>> labelingMap() {
+    return ApiResponseDto.ok(layerService.findLayerMapList("labeling"));
+  }
+
+  @Operation(summary = "년도별 tile Url(before,after 모두 조회)", description = "년도별 tile Url")
+  @GetMapping("/tile-url")
+  public ApiResponseDto<LayerDto.YearTileDto> getChangeDetectionTileUrl(
+      @Parameter(description = "이전 년도", example = "2023") @RequestParam Integer beforeYear,
+      @Parameter(description = "이후 년도", example = "2024") @RequestParam Integer afterYear) {
+    return ApiResponseDto.ok(layerService.getChangeDetectionTileUrl(beforeYear, afterYear));
+  }
+
+  @Operation(summary = "년도별 tile Url(년도 1개만 조회)", description = "년도별 tile Url")
+  @GetMapping("/tile-url-year")
+  public ApiResponseDto<LayerDto.TileUrlDto> getChangeDetectionTileOneYearUrl(
+      @Parameter(description = "년도", example = "2023") @RequestParam Integer year) {
+    return ApiResponseDto.ok(layerService.getChangeDetectionTileOneYearUrl(year));
+  }
 }

src/main/java/com/kamco/cd/kamcoback/layer/dto/LayerDto.java

@@ -1,5 +1,10 @@
 package com.kamco.cd.kamcoback.layer.dto;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.kamco.cd.kamcoback.common.utils.interfaces.JsonFormatDttm;
 import io.swagger.v3.oas.annotations.media.Schema;
 import java.math.BigDecimal;
@@ -12,14 +17,23 @@ import lombok.Setter;
 
 public class LayerDto {
 
+  public enum MapType {
+    CHANGE_MAP,
+    LABELING_MAP
+  }
+
   @Getter
   @Setter
   @AllArgsConstructor
   @Schema(name = "LayerBasic")
   public static class Basic {
+
     @Schema(description = "uuid")
     private UUID uuid;
 
+    @Schema(description = "레이어명")
+    private String layerName;
+
     @Schema(example = "WMTS", description = "유형 (TILE/GEOJSON/WMTS/WMS)")
     private String layerType;
 
@@ -48,9 +62,13 @@ public class LayerDto {
   @AllArgsConstructor
   @Schema(name = "LayerDetail")
   public static class Detail {
+
     @Schema(description = "uuid")
     private UUID uuid;
 
+    @Schema(description = "레이어명")
+    private String layerName;
+
     @Schema(description = "유형 (TILE/GEOJSON/WMTS/WMS)")
     private String layerType;
 
@@ -96,6 +114,9 @@ public class LayerDto {
     @JsonFormatDttm
     @Schema(description = "등록일시")
     private ZonedDateTime createdDttm;
+
+    @Schema(description = "좌표계")
+    private String crs;
   }
 
   @Getter
@@ -104,7 +125,10 @@ public class LayerDto {
   @Schema(name = "LayerAddReq")
   public static class AddReq {
 
-    @Schema(description = "title")
+    @Schema(description = "레이어명")
+    private String layerName;
+
+    @Schema(description = "title WMS, WMTS 선택한 tile")
     private String title;
 
     @Schema(description = "설명")
@@ -133,6 +157,9 @@ public class LayerDto {
 
     @Schema(description = "zoom max", example = "18")
     private Short max;
+
+    @Schema(description = "좌표계", example = "EPSG_3857")
+    private String crs;
   }
 
   @Getter
@@ -153,6 +180,7 @@ public class LayerDto {
   @AllArgsConstructor
   @NoArgsConstructor
   public static class SearchReq {
+
     private String tag;
     private String layerType;
   }
@@ -162,6 +190,7 @@ public class LayerDto {
   @AllArgsConstructor
   @NoArgsConstructor
   public static class TileAddReqDto {
+
     @Schema(description = "설명", example = "배경지도 입니다.")
     private String description;
 
@@ -189,4 +218,229 @@ public class LayerDto {
     @Schema(description = "zoom max", example = "18")
     private Short max;
   }
+
+  @Getter
+  @Setter
+  @Schema(name = "LayerMapDto")
+  public static class LayerMapDto {
+
+    @Schema(description = "레이어명")
+    private String layerName;
+
+    @Schema(example = "WMTS", description = "유형 (TILE/GEOJSON/WMTS/WMS)")
+    private String layerType;
+
+    @Schema(description = "title")
+    private String title;
+
+    @Schema(description = "설명")
+    private String description;
+
+    @Schema(description = "태그")
+    private String tag;
+
+    @Schema(description = "순서")
+    private Long sortOrder;
+
+    @Schema(description = "url")
+    private String url;
+
+    @Schema(description = "좌측상단 경도", example = "126.0")
+    private BigDecimal minLon;
+
+    @Schema(description = "좌측상단 위도", example = "34.0")
+    private BigDecimal minLat;
+
+    @Schema(description = "우측하단 경도", example = "130.0")
+    private BigDecimal maxLon;
+
+    @Schema(description = "우측하단 위도", example = "38.5")
+    private BigDecimal maxLat;
+
+    @Schema(description = "zoom min", example = "5")
+    private Short minZoom;
+
+    @Schema(description = "zoom max", example = "18")
+    private Short maxZoom;
+
+    @Schema(description = "bbox")
+    private JsonNode bbox;
+
+    @JsonIgnore private String bboxGeometry;
+
+    @Schema(description = "uuid")
+    private UUID uuid;
+
+    @JsonIgnore private String rawJsonString;
+
+    @Schema(description = "rawJson")
+    private JsonNode rawJson;
+
+    @Schema(description = "crs")
+    private String crs;
+
+    public LayerMapDto(
+        String layerName,
+        String layerType,
+        String tag,
+        Long sortOrder,
+        String url,
+        BigDecimal minLon,
+        BigDecimal minLat,
+        BigDecimal maxLon,
+        BigDecimal maxLat,
+        Short minZoom,
+        Short maxZoom,
+        String bboxGeometry,
+        UUID uuid,
+        String rawJsonString,
+        String crs) {
+      this.layerName = layerName;
+      this.layerType = layerType;
+      this.tag = tag;
+      this.sortOrder = sortOrder;
+      this.url = url;
+      this.minLon = minLon;
+      this.minLat = minLat;
+      this.maxLon = maxLon;
+      this.maxLat = maxLat;
+      this.minZoom = minZoom;
+      this.maxZoom = maxZoom;
+      this.bboxGeometry = bboxGeometry;
+      this.uuid = uuid;
+      this.rawJsonString = rawJsonString;
+
+      JsonNode geoJson = null;
+      JsonNode rawJson = null;
+      ObjectMapper mapper = new ObjectMapper();
+      if (bboxGeometry != null) {
+        try {
+          geoJson = mapper.readTree(bboxGeometry);
+        } catch (JsonProcessingException e) {
+          throw new RuntimeException(e);
+        }
+      }
+
+      if (rawJsonString != null) {
+        try {
+          rawJson = mapper.readTree(rawJsonString);
+        } catch (JsonProcessingException e) {
+          throw new RuntimeException(e);
+        }
+      }
+
+      this.rawJson = rawJson;
+      this.bbox = geoJson;
+      this.crs = crs;
+    }
+
+    @JsonProperty("workspace")
+    public String getWorkSpace() {
+      return "cd";
+    }
+  }
+
+  @Schema(name = "TileUrlDto", description = "Tile Url 정보")
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  public static class TileUrlDto {
+
+    @Schema(description = "mngYyyy")
+    private Integer mngYyyy;
+
+    @Schema(description = "url")
+    private String url;
+
+    @Schema(description = "태그")
+    private String tag;
+
+    @Schema(description = "좌측상단 경도", example = "126.0")
+    private BigDecimal minLon;
+
+    @Schema(description = "좌측상단 위도", example = "34.0")
+    private BigDecimal minLat;
+
+    @Schema(description = "우측하단 경도", example = "130.0")
+    private BigDecimal maxLon;
+
+    @Schema(description = "우측하단 위도", example = "38.5")
+    private BigDecimal maxLat;
+
+    @Schema(description = "zoom min", example = "5")
+    private Short minZoom;
+
+    @Schema(description = "zoom max", example = "18")
+    private Short maxZoom;
+
+    @Schema(description = "bbox")
+    private JsonNode bbox;
+
+    @JsonIgnore private String bboxGeometry;
+
+    private String crs;
+
+    public TileUrlDto(
+        Integer mngYyyy,
+        String url,
+        String tag,
+        BigDecimal minLon,
+        BigDecimal minLat,
+        BigDecimal maxLon,
+        BigDecimal maxLat,
+        Short minZoom,
+        Short maxZoom,
+        String bboxGeometry,
+        String crs) {
+      this.mngYyyy = mngYyyy;
+      this.url = url;
+      this.tag = tag;
+      this.minLon = minLon;
+      this.minLat = minLat;
+      this.maxLon = maxLon;
+      this.maxLat = maxLat;
+      this.minZoom = minZoom;
+      this.maxZoom = maxZoom;
+      this.bboxGeometry = bboxGeometry;
+
+      JsonNode geoJson = null;
+
+      if (bboxGeometry != null) {
+        ObjectMapper mapper = new ObjectMapper();
+        try {
+          geoJson = mapper.readTree(bboxGeometry);
+        } catch (JsonProcessingException e) {
+          throw new RuntimeException(e);
+        }
+      }
+
+      this.bbox = geoJson;
+      this.crs = crs;
+    }
+  }
+
+  @Schema(name = "TileUrlDto", description = "Tile Url 정보")
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class YearTileDto {
+
+    private TileUrlDto before;
+    private TileUrlDto after;
+  }
+
+  @Schema(name = "맵 노출 여부", description = "맵 노출 여부")
+  @Getter
+  @Setter
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class IsMapYn {
+
+    @Schema(description = "CHANGE_MAP(변화지도), LABELING_MAP(라벨링지도)", example = "CHANGE_MAP")
+    private String mapType;
+
+    @Schema(description = "노출여부 true, false", example = "true")
+    private Boolean isMapYn;
+  }
 }

src/main/java/com/kamco/cd/kamcoback/layer/dto/WmsDto.java

@@ -26,5 +26,6 @@ public class WmsDto {
     private String title;
     private String description;
     private String tag;
+    private String layerName;
   }
 }

src/main/java/com/kamco/cd/kamcoback/layer/dto/WmsLayerInfo.java

@@ -2,171 +2,46 @@ package com.kamco.cd.kamcoback.layer.dto;
 
 import java.util.ArrayList;
 import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
 
 /** WMS 레이어 정보를 담는 DTO 클래스 */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class WmsLayerInfo {
+
   private String name;
   private String title;
   private String abstractText;
-  private List<String> keywords;
+
+  private List<String> keywords = new ArrayList<>();
   private BoundingBox boundingBox;
-  private List<String> crs; // 지원하는 좌표계 목록
 
-  @Override
+  /** 지원하는 좌표계 목록 */
-  public String toString() {
+  private List<String> crs = new ArrayList<>();
-    return "WmsLayerInfo{"
-        + "name='"
-        + name
-        + '\''
-        + ", title='"
-        + title
-        + '\''
-        + ", abstractText='"
-        + abstractText
-        + '\''
-        + ", keywords="
-        + keywords
-        + ", boundingBox="
-        + boundingBox
-        + ", crs="
-        + crs
-        + '}';
-  }
 
-  public WmsLayerInfo() {
+  /* ===== convenience methods ===== */
-    this.keywords = new ArrayList<>();
-    this.crs = new ArrayList<>();
-  }
-
-  // Getters and Setters
-  public String getName() {
-    return name;
-  }
-
-  public void setName(String name) {
-    this.name = name;
-  }
-
-  public String getTitle() {
-    return title;
-  }
-
-  public void setTitle(String title) {
-    this.title = title;
-  }
-
-  public String getAbstractText() {
-    return abstractText;
-  }
-
-  public void setAbstractText(String abstractText) {
-    this.abstractText = abstractText;
-  }
-
-  public List<String> getKeywords() {
-    return keywords;
-  }
-
-  public void setKeywords(List<String> keywords) {
-    this.keywords = keywords;
-  }
 
   public void addKeyword(String keyword) {
     this.keywords.add(keyword);
   }
 
-  public BoundingBox getBoundingBox() {
-    return boundingBox;
-  }
-
-  public void setBoundingBox(BoundingBox boundingBox) {
-    this.boundingBox = boundingBox;
-  }
-
-  public List<String> getCrs() {
-    return crs;
-  }
-
-  public void setCrs(List<String> crs) {
-    this.crs = crs;
-  }
-
   public void addCrs(String crsValue) {
     this.crs.add(crsValue);
   }
 
   /** BoundingBox 정보를 담는 내부 클래스 */
+  @Data
+  @NoArgsConstructor
+  @AllArgsConstructor
   public static class BoundingBox {
+
     private String crs;
     private double minX;
     private double minY;
     private double maxX;
     private double maxY;
-
-    public BoundingBox(String crs, double minX, double minY, double maxX, double maxY) {
-      this.crs = crs;
-      this.minX = minX;
-      this.minY = minY;
-      this.maxX = maxX;
-      this.maxY = maxY;
-    }
-
-    // Getters and Setters
-    public String getCrs() {
-      return crs;
-    }
-
-    public void setCrs(String crs) {
-      this.crs = crs;
-    }
-
-    public double getMinX() {
-      return minX;
-    }
-
-    public void setMinX(double minX) {
-      this.minX = minX;
-    }
-
-    public double getMinY() {
-      return minY;
-    }
-
-    public void setMinY(double minY) {
-      this.minY = minY;
-    }
-
-    public double getMaxX() {
-      return maxX;
-    }
-
-    public void setMaxX(double maxX) {
-      this.maxX = maxX;
-    }
-
-    public double getMaxY() {
-      return maxY;
-    }
-
-    public void setMaxY(double maxY) {
-      this.maxY = maxY;
-    }
-
-    @Override
-    public String toString() {
-      return "BoundingBox{"
-          + "crs='"
-          + crs
-          + '\''
-          + ", minX="
-          + minX
-          + ", minY="
-          + minY
-          + ", maxX="
-          + maxX
-          + ", maxY="
-          + maxY
-          + '}';
-    }
   }
 }

src/main/java/com/kamco/cd/kamcoback/layer/dto/WmtsDto.java

@@ -26,5 +26,6 @@ public class WmtsDto {
     private String title;
     private String description;
     private String tag;
+    private String layerName;
   }
 }

src/main/java/com/kamco/cd/kamcoback/layer/dto/WmtsLayerInfo.java

@@ -1,70 +1,51 @@
 package com.kamco.cd.kamcoback.layer.dto;
 
-import com.fasterxml.jackson.annotation.JsonProperty;
 import java.util.ArrayList;
 import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
 
 /** WMTS 레이어 정보를 담는 DTO 클래스 */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class WmtsLayerInfo {
 
-  public String identifier;
+  private String identifier;
-  public String title;
+  private String title;
-  public String abstractText;
+  private String abstractText;
-  public List<String> keywords = new ArrayList<>();
-  public BoundingBox boundingBox;
-  public List<String> formats = new ArrayList<>();
-  public List<String> tileMatrixSetLinks = new ArrayList<>();
-  public List<ResourceUrl> resourceUrls = new ArrayList<>();
-  public List<Style> styles = new ArrayList<>();
 
-  public void setTitle(String title) {
+  private List<String> keywords = new ArrayList<>();
-    this.title = title;
+  private BoundingBox boundingBox;
+  private List<String> formats = new ArrayList<>();
+  private List<TileMatrixSetLink> tileMatrixSetLinks = new ArrayList<>();
+  private List<ResourceUrl> resourceUrls = new ArrayList<>();
+  private List<Style> styles = new ArrayList<>();
+
+  private List<String> matrixIds = new ArrayList<>(); // 20250130
+  private String workspace; // 20250130
+
+  private List<TileMatric> tileMatrices = new ArrayList<>();
+
+  // (선택) 기존 add 메서드 유지하고 싶으면 남겨도 됨
+  public void addTileMatric(TileMatric tileMatric) {
+    this.tileMatrices.add(tileMatric);
   }
 
-  public void setAbstractText(String abstractText) {
+  public void addMatrixId(String matrixId) {
-    this.abstractText = abstractText;
+    this.matrixIds.add(matrixId);
   }
 
-  public void setBoundingBox(BoundingBox boundingBox) {
+  public void addKeyword(String keyword) {
-    this.boundingBox = boundingBox;
+    this.keywords.add(keyword);
-  }
-
-  @Override
-  public String toString() {
-    return "WmtsLayerInfo{"
-        + "identifier='"
-        + identifier
-        + '\''
-        + ", title='"
-        + title
-        + '\''
-        + ", abstractText='"
-        + abstractText
-        + '\''
-        + ", keywords="
-        + keywords
-        + ", boundingBox="
-        + boundingBox
-        + ", formats="
-        + formats
-        + ", tileMatrixSetLinks="
-        + tileMatrixSetLinks
-        + ", resourceUrls="
-        + resourceUrls
-        + ", styles="
-        + styles
-        + '}';
-  }
-
-  public void addKeyword(String keywowrd) {
-    this.keywords.add(keywowrd);
   }
 
   public void addFormat(String format) {
     this.formats.add(format);
   }
 
-  public void addTileMatrixSetLink(String tileMatrixSetLink) {
+  public void addTileMatrixSetLink(TileMatrixSetLink tileMatrixSetLink) {
     this.tileMatrixSetLinks.add(tileMatrixSetLink);
   }
 
@@ -77,200 +58,61 @@ public class WmtsLayerInfo {
   }
 
   /** BoundingBox 정보를 담는 내부 클래스 */
+  @Data
+  @NoArgsConstructor
+  @AllArgsConstructor
   public static class BoundingBox {
-
+    private String crs;
-    public String crs;
+    private double lowerCornerX;
-    public double lowerCornerX;
+    private double lowerCornerY;
-    public double lowerCornerY;
+    private double upperCornerX;
-    public double upperCornerX;
+    private double upperCornerY;
-    public double upperCornerY;
-
-    public BoundingBox() {}
-
-    public BoundingBox(
-        String crs,
-        double lowerCornerX,
-        double lowerCornerY,
-        double upperCornerX,
-        double upperCornerY) {
-      this.crs = crs;
-      this.lowerCornerX = lowerCornerX;
-      this.lowerCornerY = lowerCornerY;
-      this.upperCornerX = upperCornerX;
-      this.upperCornerY = upperCornerY;
-    }
-
-    // Getters and Setters
-    public String getCrs() {
-      return crs;
-    }
-
-    public void setCrs(String crs) {
-      this.crs = crs;
-    }
-
-    public double getLowerCornerX() {
-      return lowerCornerX;
-    }
-
-    public void setLowerCornerX(double lowerCornerX) {
-      this.lowerCornerX = lowerCornerX;
-    }
-
-    public double getLowerCornerY() {
-      return lowerCornerY;
-    }
-
-    public void setLowerCornerY(double lowerCornerY) {
-      this.lowerCornerY = lowerCornerY;
-    }
-
-    public double getUpperCornerX() {
-      return upperCornerX;
-    }
-
-    public void setUpperCornerX(double upperCornerX) {
-      this.upperCornerX = upperCornerX;
-    }
-
-    public double getUpperCornerY() {
-      return upperCornerY;
-    }
-
-    public void setUpperCornerY(double upperCornerY) {
-      this.upperCornerY = upperCornerY;
-    }
-
-    @Override
-    public String toString() {
-      return "BoundingBox{"
-          + "crs='"
-          + crs
-          + '\''
-          + ", lowerCorner=["
-          + lowerCornerX
-          + ", "
-          + lowerCornerY
-          + ']'
-          + ", upperCorner=["
-          + upperCornerX
-          + ", "
-          + upperCornerY
-          + ']'
-          + '}';
-    }
   }
 
   /** ResourceURL 정보를 담는 내부 클래스 (타일 URL 템플릿) */
+  @Data
+  @NoArgsConstructor
+  @AllArgsConstructor
   public static class ResourceUrl {
-
     private String format;
     private String resourceType;
     private String template;
-
-    public ResourceUrl() {}
-
-    public ResourceUrl(String format, String resourceType, String template) {
-      this.format = format;
-      this.resourceType = resourceType;
-      this.template = template;
-    }
-
-    // Getters and Setters
-    public String getFormat() {
-      return format;
-    }
-
-    public void setFormat(String format) {
-      this.format = format;
-    }
-
-    public String getResourceType() {
-      return resourceType;
-    }
-
-    public void setResourceType(String resourceType) {
-      this.resourceType = resourceType;
-    }
-
-    public String getTemplate() {
-      return template;
-    }
-
-    public void setTemplate(String template) {
-      this.template = template;
-    }
-
-    @Override
-    public String toString() {
-      return "ResourceUrl{"
-          + "format='"
-          + format
-          + '\''
-          + ", resourceType='"
-          + resourceType
-          + '\''
-          + ", template='"
-          + template
-          + '\''
-          + '}';
-    }
   }
 
   /** Style 정보를 담는 내부 클래스 */
+  @Data
+  @NoArgsConstructor
+  @AllArgsConstructor
   public static class Style {
-
     private String identifier;
     private String title;
-
-    @JsonProperty("default")
     private boolean isDefault;
+  }
 
-    public Style() {}
+  /** TileMatrix 정보를 담는 내부 클래스 */
+  @Data
+  @NoArgsConstructor
+  @AllArgsConstructor
+  public static class TileMatric {
+    private String identifier;
+    private String scaleDenominator;
+    private String topLeftCorner;
+    //    private String tileWidth;
+    //    private String tileHeight;
+    //    private String matrixWidth;
+    //    private String matrixHeight;
+  }
 
-    public Style(String identifier, String title, boolean isDefault) {
+  /** TileMatrixSetLink 정보를 담는 내부 클래스 */
-      this.identifier = identifier;
+  @Data
-      this.title = title;
+  @NoArgsConstructor
-      this.isDefault = isDefault;
+  @AllArgsConstructor
-    }
+  public static class TileMatrixSetLink {
+    private String tileMatrixSet;
+    private List<String> zoomLevels = new ArrayList<>();
 
-    // Getters and Setters
+    public void addZoomLevel(String zoomLevel) {
-    public String getIdentifier() {
+      this.zoomLevels.add(zoomLevel);
-      return identifier;
-    }
-
-    public void setIdentifier(String identifier) {
-      this.identifier = identifier;
-    }
-
-    public String getTitle() {
-      return title;
-    }
-
-    public void setTitle(String title) {
-      this.title = title;
-    }
-
-    public boolean isDefault() {
-      return isDefault;
-    }
-
-    public void setDefault(boolean isDefault) {
-      this.isDefault = isDefault;
-    }
-
-    @Override
-    public String toString() {
-      return "Style{"
-          + "identifier='"
-          + identifier
-          + '\''
-          + ", title='"
-          + title
-          + '\''
-          + ", isDefault="
-          + isDefault
-          + '}';
     }
   }
 }

src/main/java/com/kamco/cd/kamcoback/layer/service/LayerService.java

@@ -4,9 +4,11 @@ import com.kamco.cd.kamcoback.common.enums.LayerType;
 import com.kamco.cd.kamcoback.common.exception.CustomApiException;
 import com.kamco.cd.kamcoback.layer.dto.LayerDto;
 import com.kamco.cd.kamcoback.layer.dto.LayerDto.Basic;
+import com.kamco.cd.kamcoback.layer.dto.LayerDto.IsMapYn;
+import com.kamco.cd.kamcoback.layer.dto.LayerDto.LayerMapDto;
 import com.kamco.cd.kamcoback.layer.dto.LayerDto.OrderReq;
+import com.kamco.cd.kamcoback.layer.dto.LayerDto.TileUrlDto;
 import com.kamco.cd.kamcoback.layer.dto.WmsDto.WmsAddDto;
-import com.kamco.cd.kamcoback.layer.dto.WmsDto.WmsAddReqDto;
 import com.kamco.cd.kamcoback.layer.dto.WmsLayerInfo;
 import com.kamco.cd.kamcoback.layer.dto.WmtsDto.WmtsAddDto;
 import com.kamco.cd.kamcoback.layer.dto.WmtsLayerInfo;
@@ -14,6 +16,7 @@ import com.kamco.cd.kamcoback.postgres.core.MapLayerCoreService;
 import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -27,6 +30,15 @@ public class LayerService {
   private final WmtsService wmtsService;
   private final WmsService wmsService;
 
+  @Value("${layer.geoserver-url}")
+  private String geoserverUrl;
+
+  @Value("${layer.wms-path}")
+  private String wmsPath;
+
+  @Value("${layer.wmts-path}")
+  private String wmtsPath;
+
   /**
    * 지도 레이어 관리 목록
    *
@@ -55,7 +67,7 @@ public class LayerService {
       }
 
       case GEOJSON -> {
-        mapLayerCoreService.saveGeoJson(dto);
+        return mapLayerCoreService.saveGeoJson(dto);
       }
 
       case WMTS -> {
@@ -66,6 +78,7 @@ public class LayerService {
         addDto.setDescription(dto.getDescription());
         addDto.setTitle(dto.getTitle());
         addDto.setTag(dto.getTag());
+        addDto.setLayerName(dto.getLayerName());
         return mapLayerCoreService.saveWmts(addDto);
       }
 
@@ -76,12 +89,12 @@ public class LayerService {
         addDto.setDescription(dto.getDescription());
         addDto.setTitle(dto.getTitle());
         addDto.setTag(dto.getTag());
+        addDto.setLayerName(dto.getLayerName());
         return mapLayerCoreService.saveWms(addDto);
       }
 
       default -> throw new CustomApiException("BAD_REQUEST", HttpStatus.BAD_REQUEST);
     }
-    return null;
   }
 
   /**
@@ -124,6 +137,17 @@ public class LayerService {
     mapLayerCoreService.update(uuid, dto);
   }
 
+  /**
+   * 맵 노출 여부 수정
+   *
+   * @param uuid
+   * @param isMapYn
+   */
+  @Transactional
+  public void updateIsMap(UUID uuid, IsMapYn isMapYn) {
+    mapLayerCoreService.updateIsMap(uuid, isMapYn);
+  }
+
   /**
    * wmts tile 조회
    *
@@ -142,21 +166,39 @@ public class LayerService {
     return wmsService.getTile();
   }
 
-  /**
+  public List<LayerMapDto> findLayerMapList(String type) {
-   * wms 저장
+    List<LayerMapDto> layerMapDtoList = mapLayerCoreService.findLayerMapList(type);
-   *
+    layerMapDtoList.forEach(
-   * @param dto
+        dto -> {
-   * @return
+          if (dto.getLayerType().equals("WMS")) {
-   */
+            dto.setUrl(
-  @Transactional
+                String.format(
-  public UUID saveWms(WmsAddReqDto dto) {
+                    "%s/%s/%s",
-    // 선택한 tile 상세정보 조회
+                    trimSlash(geoserverUrl), trimSlash(wmsPath), dto.getLayerType().toLowerCase()));
-    WmsLayerInfo info = wmsService.getDetail(dto.getTitle());
+          } else if (dto.getLayerType().equals("WMTS")) {
-    WmsAddDto addDto = new WmsAddDto();
+            dto.setUrl(
-    addDto.setWmsLayerInfo(info);
+                String.format(
-    addDto.setDescription(dto.getDescription());
+                    "%s/%s/%s",
-    addDto.setTitle(dto.getTitle());
+                    trimSlash(geoserverUrl),
-    addDto.setTag(dto.getTag());
+                    trimSlash(wmtsPath),
-    return mapLayerCoreService.saveWms(addDto);
+                    dto.getLayerType().toLowerCase()));
+          }
+        });
+    return layerMapDtoList;
+  }
+
+  private String trimSlash(String s) {
+    if (s == null) {
+      return "";
+    }
+    return s.replaceAll("/+$", "").replaceAll("^/+", "");
+  }
+
+  public LayerDto.YearTileDto getChangeDetectionTileUrl(Integer beforeYear, Integer afterYear) {
+    return mapLayerCoreService.getChangeDetectionTileUrl(beforeYear, afterYear);
+  }
+
+  public TileUrlDto getChangeDetectionTileOneYearUrl(Integer year) {
+    return mapLayerCoreService.getChangeDetectionTileOneYearUrl(year);
   }
 }

src/main/java/com/kamco/cd/kamcoback/layer/service/WmtsService.java

@@ -41,7 +41,7 @@ public class WmtsService {
     List<String> titles = new ArrayList<>();
 
     for (WmtsLayerInfo layer : layers) {
-      titles.add(layer.title);
+      titles.add(layer.getTitle()); // ✅ getter로 변경
     }
     return titles;
   }
@@ -50,7 +50,14 @@ public class WmtsService {
     return getLayerInfoByTitle(geoserverUrl, workspace, tile);
   }
 
-  private List<WmtsLayerInfo> getAllLayers(String geoserverUrl, String workspace) {
+  /**
+   * WMTS Capabilities URL에서 모든 레이어 정보를 가져옵니다.
+   *
+   * @param geoserverUrl 예: http://localhost:8080
+   * @param workspace 워크스페이스 이름
+   * @return 모든 레이어 정보 리스트
+   */
+  public List<WmtsLayerInfo> getAllLayers(String geoserverUrl, String workspace) {
     List<WmtsLayerInfo> layers = new ArrayList<>();
     try {
       // 1. XML 문서 로드 및 파싱
@@ -75,7 +82,7 @@ public class WmtsService {
         String title = getChildValue(layerNode, "Title");
 
         if (title != null && !title.trim().isEmpty()) {
-          WmtsLayerInfo layerInfo = parseLayerNode(layerNode, title);
+          WmtsLayerInfo layerInfo = parseLayerNode(workspace, doc, layerNode, title);
           layers.add(layerInfo);
         }
       }
@@ -88,151 +95,6 @@ public class WmtsService {
     return layers;
   }
 
-  // 특정 노드 아래의 자식 태그 값 추출 (예: <Title>값)
-  private String getChildValue(Node parent, String childName) {
-    Node child = findChildNode(parent, childName);
-    return (child != null) ? child.getTextContent() : null;
-  }
-
-  // 이름으로 자식 노드 찾기 (Local Name 기준)
-  private Node findChildNode(Node parent, String localName) {
-    NodeList children = parent.getChildNodes();
-    for (int i = 0; i < children.getLength(); i++) {
-      Node node = children.item(i);
-      // 네임스페이스 접두사(ows:, wmts:)를 무시하고 태그 이름 확인
-      if (node.getNodeName().endsWith(":" + localName) || node.getNodeName().equals(localName)) {
-        return node;
-      }
-    }
-    return null;
-  }
-
-  // 레이어 노드를 Java 객체로 변환
-  private WmtsLayerInfo parseLayerNode(Node layerNode, String title) {
-    WmtsLayerInfo info = new WmtsLayerInfo();
-    info.title = title;
-    info.identifier = getChildValue(layerNode, "Identifier");
-    info.abstractText = getChildValue(layerNode, "Abstract");
-
-    // Keywords 파싱
-    // 구조: <ows:Keywords><ows:Keyword>...</ows:Keyword></ows:Keywords>
-    info.keywords = getChildValues(layerNode, "Keywords", "Keyword");
-
-    // BoundingBox 파싱 (WGS84BoundingBox 기준)
-    info.boundingBox = parseBoundingBox(layerNode);
-
-    // Formats 파싱
-    info.formats = getChildValuesDirect(layerNode, "Format");
-
-    // TileMatrixSetLink 파싱
-    // 구조: <TileMatrixSetLink><TileMatrixSet>...</TileMatrixSet></TileMatrixSetLink>
-    info.tileMatrixSetLinks = getChildValues(layerNode, "TileMatrixSetLink", "TileMatrixSet");
-
-    // ResourceURL 파싱
-    info.resourceUrls = parseResourceUrls(layerNode);
-
-    // Styles 파싱
-    info.styles = parseStyles(layerNode);
-
-    return info;
-  }
-
-  // 특정 노드 아래의 반복되는 자식 구조 값 추출 (예: Keywords -> Keyword)
-  private List<String> getChildValues(Node parent, String wrapperName, String childName) {
-    List<String> results = new ArrayList<>();
-    Node wrapper = findChildNode(parent, wrapperName);
-    if (wrapper != null) {
-      NodeList children = wrapper.getChildNodes();
-      for (int i = 0; i < children.getLength(); i++) {
-        Node node = children.item(i);
-        if (node.getNodeName().endsWith(childName)) {
-          results.add(node.getTextContent());
-        }
-      }
-    }
-    return results;
-  }
-
-  private WmtsLayerInfo.BoundingBox parseBoundingBox(Node layerNode) {
-    // 보통 <ows:WGS84BoundingBox>를 찾음
-    Node bboxNode = findChildNode(layerNode, "WGS84BoundingBox");
-    if (bboxNode == null) bboxNode = findChildNode(layerNode, "BoundingBox");
-
-    if (bboxNode != null) {
-      WmtsLayerInfo.BoundingBox bbox = new WmtsLayerInfo.BoundingBox();
-      bbox.crs = getAttributeValue(bboxNode, "crs"); // WGS84는 보통 CRS 속성이 없을 수 있음(Default EPSG:4326)
-
-      String lowerCorner = getChildValue(bboxNode, "LowerCorner");
-      String upperCorner = getChildValue(bboxNode, "UpperCorner");
-
-      if (lowerCorner != null) {
-        String[] coords = lowerCorner.split(" ");
-        bbox.lowerCornerX = Double.parseDouble(coords[0]);
-        bbox.lowerCornerY = Double.parseDouble(coords[1]);
-      }
-      if (upperCorner != null) {
-        String[] coords = upperCorner.split(" ");
-        bbox.upperCornerX = Double.parseDouble(coords[0]);
-        bbox.upperCornerY = Double.parseDouble(coords[1]);
-      }
-      return bbox;
-    }
-    return null;
-  }
-
-  private String getAttributeValue(Node node, String attrName) {
-    if (node.hasAttributes()) {
-      Node attr = node.getAttributes().getNamedItem(attrName);
-      if (attr != null) return attr.getNodeValue();
-    }
-    return null;
-  }
-
-  // Wrapper 없이 바로 반복되는 값 추출 (예: Format)
-  private List<String> getChildValuesDirect(Node parent, String childName) {
-    List<String> results = new ArrayList<>();
-    NodeList children = parent.getChildNodes();
-    for (int i = 0; i < children.getLength(); i++) {
-      Node node = children.item(i);
-      if (node.getNodeName().endsWith(childName)) {
-        results.add(node.getTextContent());
-      }
-    }
-    return results;
-  }
-
-  private List<WmtsLayerInfo.ResourceUrl> parseResourceUrls(Node layerNode) {
-    List<WmtsLayerInfo.ResourceUrl> list = new ArrayList<>();
-    NodeList children = layerNode.getChildNodes();
-    for (int i = 0; i < children.getLength(); i++) {
-      Node node = children.item(i);
-      if (node.getNodeName().contains("ResourceURL")) { // local-name check simplification
-        WmtsLayerInfo.ResourceUrl url = new WmtsLayerInfo.ResourceUrl();
-        url.setFormat(getAttributeValue(node, "format"));
-        url.setResourceType(getAttributeValue(node, "resourceType"));
-        url.setTemplate(getAttributeValue(node, "template"));
-        list.add(url);
-      }
-    }
-    return list;
-  }
-
-  private List<WmtsLayerInfo.Style> parseStyles(Node layerNode) {
-    List<WmtsLayerInfo.Style> styles = new ArrayList<>();
-    NodeList children = layerNode.getChildNodes();
-    for (int i = 0; i < children.getLength(); i++) {
-      Node node = children.item(i);
-      if (node.getNodeName().endsWith("Style")) {
-        WmtsLayerInfo.Style style = new WmtsLayerInfo.Style();
-        style.setDefault(Boolean.parseBoolean(getAttributeValue(node, "isDefault")));
-        style.setIdentifier(getChildValue(node, "Identifier"));
-        style.setTitle(getChildValue(node, "Title"));
-        styles.add(style);
-      }
-    }
-    return styles;
-  }
-
   /**
    * WMTS Capabilities URL에서 특정 타이틀의 레이어 정보를 가져옵니다. // * @param capabilitiesUrl 예:
    * http://localhost:8080/geoserver/gwc/service/wmts?REQUEST=GetCapabilities
@@ -268,7 +130,7 @@ public class WmtsService {
 
         // 타이틀이 일치하면 객체 매핑 시작
         if (title != null && title.trim().equals(targetTitle)) {
-          return parseLayerNode(layerNode, title);
+          return parseLayerNode(workspace, doc, layerNode, title);
         }
       }
 
@@ -279,4 +141,325 @@ public class WmtsService {
 
     return null; // 찾지 못한 경우
   }
+
+  // 레이어 노드를 Java 객체로 변환 20250130
+  private WmtsLayerInfo parseLayerNode(
+      String workspace, Document doc, Node layerNode, String title) {
+    WmtsLayerInfo info = new WmtsLayerInfo();
+
+    info.setWorkspace(workspace); // 20250130
+    info.setTitle(title);
+    info.setIdentifier(getChildValue(layerNode, "Identifier"));
+    info.setAbstractText(getChildValue(layerNode, "Abstract"));
+
+    // Keywords 파싱
+    info.setKeywords(getChildValues(layerNode, "Keywords", "Keyword"));
+
+    // BoundingBox 파싱 (WGS84BoundingBox 기준)
+    info.setBoundingBox(parseBoundingBox(layerNode));
+
+    // Formats 파싱
+    info.setFormats(getChildValuesDirect(layerNode, "Format"));
+
+    // TileMatrixSetLink 파싱 (TileMatrixSet + Zoom Levels)
+    info.setTileMatrixSetLinks(parseTileMatrixSetLinks(layerNode));
+
+    // TileMatrixSetLimits에서 줌 레벨 추출 (개별 zoom 리스트)
+    info.setMatrixIds(parseMatrixIds(layerNode)); // 20260130
+
+    // ResourceURL 파싱
+    info.setResourceUrls(parseResourceUrls(layerNode));
+
+    // Styles 파싱
+    info.setStyles(parseStyles(layerNode));
+
+    // TileMatrixSet의 TileMatrix 정보 파싱
+    List<String> tileMatrixSetNames = new ArrayList<>();
+    if (info.getTileMatrixSetLinks() != null) {
+      for (WmtsLayerInfo.TileMatrixSetLink link : info.getTileMatrixSetLinks()) {
+        tileMatrixSetNames.add(link.getTileMatrixSet());
+      }
+    }
+
+    info.setTileMatrices(parseTileMatrices(doc, tileMatrixSetNames));
+
+    return info;
+  }
+
+  // --- Helper Methods ---
+
+  private WmtsLayerInfo.BoundingBox parseBoundingBox(Node layerNode) {
+    // 보통 <ows:WGS84BoundingBox>를 찾음
+    Node bboxNode = findChildNode(layerNode, "WGS84BoundingBox");
+    if (bboxNode == null) bboxNode = findChildNode(layerNode, "BoundingBox");
+
+    if (bboxNode != null) {
+      WmtsLayerInfo.BoundingBox bbox = new WmtsLayerInfo.BoundingBox();
+
+      // WGS84는 CRS 속성이 없을 수 있음
+      bbox.setCrs(getAttributeValue(bboxNode, "crs"));
+
+      String lowerCorner = getChildValue(bboxNode, "LowerCorner");
+      String upperCorner = getChildValue(bboxNode, "UpperCorner");
+
+      if (lowerCorner != null) {
+        String[] coords = lowerCorner.split(" ");
+        bbox.setLowerCornerX(Double.parseDouble(coords[0]));
+        bbox.setLowerCornerY(Double.parseDouble(coords[1]));
+      }
+
+      if (upperCorner != null) {
+        String[] coords = upperCorner.split(" ");
+        bbox.setUpperCornerX(Double.parseDouble(coords[0]));
+        bbox.setUpperCornerY(Double.parseDouble(coords[1]));
+      }
+
+      return bbox;
+    }
+
+    return null;
+  }
+
+  private List<WmtsLayerInfo.ResourceUrl> parseResourceUrls(Node layerNode) {
+    List<WmtsLayerInfo.ResourceUrl> list = new ArrayList<>();
+    NodeList children = layerNode.getChildNodes();
+    for (int i = 0; i < children.getLength(); i++) {
+      Node node = children.item(i);
+      if (node.getNodeName().contains("ResourceURL")) { // local-name check simplification
+        WmtsLayerInfo.ResourceUrl url = new WmtsLayerInfo.ResourceUrl();
+        url.setFormat(getAttributeValue(node, "format"));
+        url.setResourceType(getAttributeValue(node, "resourceType"));
+        url.setTemplate(getAttributeValue(node, "template"));
+        list.add(url);
+      }
+    }
+    return list;
+  }
+
+  private List<WmtsLayerInfo.Style> parseStyles(Node layerNode) {
+    List<WmtsLayerInfo.Style> styles = new ArrayList<>();
+    NodeList children = layerNode.getChildNodes();
+    for (int i = 0; i < children.getLength(); i++) {
+      Node node = children.item(i);
+      if (node.getNodeName().endsWith("Style")) {
+        WmtsLayerInfo.Style style = new WmtsLayerInfo.Style();
+        style.setDefault(Boolean.parseBoolean(getAttributeValue(node, "isDefault")));
+        style.setIdentifier(getChildValue(node, "Identifier"));
+        style.setTitle(getChildValue(node, "Title"));
+        styles.add(style);
+      }
+    }
+    return styles;
+  }
+
+  /**
+   * TileMatrixSetLimits에서 줌 레벨을 추출합니다. 예: "EPSG:4326:0" → "0", "EPSG:4326:1" → "1"
+   *
+   * @param layerNode Layer 노드
+   * @return 줌 레벨 문자열 리스트
+   */
+  private List<String> parseMatrixIds(Node layerNode) {
+    List<String> matrixIds = new ArrayList<>();
+    NodeList children = layerNode.getChildNodes();
+
+    // 모든 TileMatrixSetLink 찾기
+    for (int i = 0; i < children.getLength(); i++) {
+      Node node = children.item(i);
+      if (node.getNodeName().contains("TileMatrixSetLink")) {
+        // TileMatrixSetLimits 찾기
+        Node limitsNode = findChildNode(node, "TileMatrixSetLimits");
+        if (limitsNode != null) {
+          NodeList limitsList = limitsNode.getChildNodes();
+          // 각 TileMatrixLimits 처리
+          for (int j = 0; j < limitsList.getLength(); j++) {
+            Node limitNode = limitsList.item(j);
+            if (limitNode.getNodeName().contains("TileMatrixLimits")) {
+              // TileMatrix 또는 Identifier 값 추출
+              String identifier = getChildValue(limitNode, "TileMatrix");
+              if (identifier == null) {
+                identifier = getChildValue(limitNode, "Identifier");
+              }
+              // 마지막 콜론 이후 값(줌 레벨) 추출
+              if (identifier != null && identifier.contains(":")) {
+                String[] parts = identifier.split(":");
+                String zoomLevel = parts[parts.length - 1];
+                matrixIds.add(zoomLevel);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return matrixIds;
+  }
+
+  /**
+   * TileMatrixSetLink 정보를 파싱합니다. 각 TileMatrixSetLink에서 TileMatrixSet 이름과 줌 레벨들을 추출합니다.
+   *
+   * @param layerNode Layer 노드
+   * @return TileMatrixSetLink 객체 리스트
+   */
+  private List<WmtsLayerInfo.TileMatrixSetLink> parseTileMatrixSetLinks(Node layerNode) {
+    List<WmtsLayerInfo.TileMatrixSetLink> links = new ArrayList<>();
+    NodeList children = layerNode.getChildNodes();
+
+    // 모든 TileMatrixSetLink 찾기
+    for (int i = 0; i < children.getLength(); i++) {
+      Node node = children.item(i);
+      if (node.getNodeName().contains("TileMatrixSetLink")) {
+
+        // TileMatrixSet 이름 추출
+        String tileMatrixSet = getChildValue(node, "TileMatrixSet");
+
+        // 줌 레벨들 추출
+        List<String> zoomLevels = new ArrayList<>();
+        Node limitsNode = findChildNode(node, "TileMatrixSetLimits");
+        if (limitsNode != null) {
+          NodeList limitsList = limitsNode.getChildNodes();
+          for (int j = 0; j < limitsList.getLength(); j++) {
+            Node limitNode = limitsList.item(j);
+            if (limitNode.getNodeName().contains("TileMatrixLimits")) {
+              // TileMatrix 또는 Identifier 값 추출
+              String identifier = getChildValue(limitNode, "TileMatrix");
+              if (identifier == null) {
+                identifier = getChildValue(limitNode, "Identifier");
+              }
+              // 마지막 콜론 이후 값(줌 레벨) 추출
+              if (identifier != null && identifier.contains(":")) {
+                String[] parts = identifier.split(":");
+                String zoomLevel = parts[parts.length - 1];
+                zoomLevels.add(zoomLevel);
+              }
+            }
+          }
+        }
+
+        // TileMatrixSetLink 객체 생성 및 추가
+        if (tileMatrixSet != null) {
+          WmtsLayerInfo.TileMatrixSetLink link =
+              new WmtsLayerInfo.TileMatrixSetLink(tileMatrixSet, zoomLevels);
+          links.add(link);
+        }
+      }
+    }
+
+    return links;
+  }
+
+  /**
+   * Document에서 TileMatrixSet의 TileMatrix 정보를 파싱합니다.
+   *
+   * @param doc WMTS Capabilities Document
+   * @param tileMatrixSetNames 조회할 TileMatrixSet 이름 리스트
+   * @return TileMatric 객체 리스트
+   */
+  private List<WmtsLayerInfo.TileMatric> parseTileMatrices(
+      Document doc, List<String> tileMatrixSetNames) {
+    List<WmtsLayerInfo.TileMatric> allMatrices = new ArrayList<>();
+
+    try {
+      XPathFactory xPathFactory = XPathFactory.newInstance();
+      XPath xpath = xPathFactory.newXPath();
+
+      // 각 TileMatrixSet 이름에 대해 TileMatrix 찾기
+      for (String tileMatrixSetName : tileMatrixSetNames) {
+        // TileMatrixSet 찾기
+        String expression = "//*[local-name()='TileMatrixSet']";
+        NodeList tileMatrixSetNodes =
+            (NodeList) xpath.compile(expression).evaluate(doc, XPathConstants.NODESET);
+
+        for (int i = 0; i < tileMatrixSetNodes.getLength(); i++) {
+          Node tileMatrixSetNode = tileMatrixSetNodes.item(i);
+          String identifier = getChildValue(tileMatrixSetNode, "Identifier");
+
+          // 일치하는 TileMatrixSet 찾으면 TileMatrix 파싱
+          if (tileMatrixSetName.equals(identifier)) {
+            NodeList children = tileMatrixSetNode.getChildNodes();
+            for (int j = 0; j < children.getLength(); j++) {
+              Node node = children.item(j);
+              if (node.getNodeName().contains("TileMatrix")) {
+                WmtsLayerInfo.TileMatric tileMatric = new WmtsLayerInfo.TileMatric();
+
+                // TileMatrix 정보 추출
+                tileMatric.setScaleDenominator(getChildValue(node, "ScaleDenominator"));
+                tileMatric.setTopLeftCorner(getChildValue(node, "TopLeftCorner"));
+                tileMatric.setIdentifier(getChildValue(node, "Identifier"));
+
+                /* 미사용 정보 주석처리함
+                tileMatric.setTileWidth(getChildValue(node, "TileWidth"));
+                tileMatric.setTileHeight(getChildValue(node, "TileHeight"));
+                tileMatric.setMatrixWidth(getChildValue(node, "MatrixWidth"));
+                tileMatric.setMatrixHeight(getChildValue(node, "MatrixHeight"));
+                */
+
+                allMatrices.add(tileMatric);
+              }
+            }
+            break; // 일치하는 TileMatrixSet 찾았으므로 다음으로
+          }
+        }
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+    return allMatrices;
+  }
+
+  // 특정 노드 아래의 자식 태그 값 추출 (예: <Title>값)
+  private String getChildValue(Node parent, String childName) {
+    Node child = findChildNode(parent, childName);
+    return (child != null) ? child.getTextContent() : null;
+  }
+
+  // 특정 노드 아래의 반복되는 자식 구조 값 추출 (예: Keywords -> Keyword)
+  private List<String> getChildValues(Node parent, String wrapperName, String childName) {
+    List<String> results = new ArrayList<>();
+    Node wrapper = findChildNode(parent, wrapperName);
+    if (wrapper != null) {
+      NodeList children = wrapper.getChildNodes();
+      for (int i = 0; i < children.getLength(); i++) {
+        Node node = children.item(i);
+        if (node.getNodeName().endsWith(childName)) {
+          results.add(node.getTextContent());
+        }
+      }
+    }
+    return results;
+  }
+
+  // Wrapper 없이 바로 반복되는 값 추출 (예: Format)
+  private List<String> getChildValuesDirect(Node parent, String childName) {
+    List<String> results = new ArrayList<>();
+    NodeList children = parent.getChildNodes();
+    for (int i = 0; i < children.getLength(); i++) {
+      Node node = children.item(i);
+      if (node.getNodeName().endsWith(childName)) {
+        results.add(node.getTextContent());
+      }
+    }
+    return results;
+  }
+
+  // 이름으로 자식 노드 찾기 (Local Name 기준)
+  private Node findChildNode(Node parent, String localName) {
+    NodeList children = parent.getChildNodes();
+    for (int i = 0; i < children.getLength(); i++) {
+      Node node = children.item(i);
+      // 네임스페이스 접두사(ows:, wmts:)를 무시하고 태그 이름 확인
+      if (node.getNodeName().endsWith(":" + localName) || node.getNodeName().equals(localName)) {
+        return node;
+      }
+    }
+    return null;
+  }
+
+  private String getAttributeValue(Node node, String attrName) {
+    if (node.hasAttributes()) {
+      Node attr = node.getAttributes().getNamedItem(attrName);
+      if (attr != null) return attr.getNodeValue();
+    }
+    return null;
+  }
 }

src/main/java/com/kamco/cd/kamcoback/mapsheet/dto/MapSheetMngDto.java

@@ -7,6 +7,7 @@ import com.kamco.cd.kamcoback.common.utils.enums.EnumType;
 import com.kamco.cd.kamcoback.common.utils.enums.Enums;
 import com.kamco.cd.kamcoback.common.utils.interfaces.JsonFormatDttm;
 import io.swagger.v3.oas.annotations.media.Schema;
+import java.math.BigDecimal;
 import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.UUID;
@@ -77,6 +78,34 @@ public class MapSheetMngDto {
     @Schema(description = "선택폴더경로", example = "D:\\app\\original-images\\2022")
     private String mngPath;
 
+    // Tile 등록 로직
+    @Schema(description = "url")
+    private String url;
+
+    @Schema(description = "좌측상단 경도", example = "126.0")
+    private BigDecimal minLon;
+
+    @Schema(description = "좌측상단 위도", example = "34.0")
+    private BigDecimal minLat;
+
+    @Schema(description = "우측하단 경도", example = "130.0")
+    private BigDecimal maxLon;
+
+    @Schema(description = "우측하단 위도", example = "38.5")
+    private BigDecimal maxLat;
+
+    @Schema(description = "zoom min", example = "5")
+    private Short minZoom;
+
+    @Schema(description = "zoom max", example = "18")
+    private Short maxZoom;
+
+    @Schema(description = "tag")
+    private String tag;
+
+    @Schema(description = "crs 좌표계")
+    private String crs;
+
     @JsonIgnore private Long createdUid;
   }
 
@@ -155,11 +184,14 @@ public class MapSheetMngDto {
     }
 
     public long getSyncErrorTotCnt() {
-      return this.syncNotPaireCnt + this.syncDuplicateCnt + this.syncFaultCnt;
+      return this.syncNotPaireCnt + this.syncDuplicateCnt + this.syncFaultCnt + this.syncNoFileCnt;
     }
 
     public long getSyncErrorExecTotCnt() {
-      return this.syncNotPaireExecCnt + this.syncDuplicateExecCnt + this.syncFaultExecCnt;
+      return this.syncNotPaireExecCnt
+          + this.syncDuplicateExecCnt
+          + this.syncFaultExecCnt
+          + this.syncNoFileExecCnt;
     }
 
     public String getMngState() {

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

@@ -47,6 +47,9 @@ public class MapSheetMngService {
   private final UploadService uploadService;
   private final UserUtil userUtil = new UserUtil();
 
+  @Value("${file.root}")
+  private String nfsRootDir;
+
   @Value("${file.sync-root-dir}")
   private String syncRootDir;
 
@@ -111,7 +114,6 @@ public class MapSheetMngService {
   public DmlReturn uploadPair(
       MultipartFile tfwFile, String tifFile, Long hstUid, Long tifFileSize) {
 
-    String rootPath = syncRootDir;
     String tmpPath = syncTmpDir;
 
     DmlReturn dmlReturn = new DmlReturn("success", "UPLOAD COMPLETE");
@@ -133,8 +135,8 @@ public class MapSheetMngService {
       return dmlReturn;
     }
 
+    // TODO 삭제?
     MngDto mngDto = mapSheetMngCoreService.findMapSheetMng(errDto.getMngYyyy());
-    String targetYearDir = mngDto.getMngPath();
 
     // 중복체크 -> 도엽50k/uuid 경로에 업로드 할 거라 overwrite 되지 않음
     //    if (!overwrite) {
@@ -337,12 +339,11 @@ public class MapSheetMngService {
 
   public FoldersDto getFolderAll(SrchFoldersDto srchDto) {
 
-    Path startPath = Paths.get(syncRootDir + srchDto.getDirPath());
     String dirPath = syncRootDir + srchDto.getDirPath();
-    String sortType = "name desc";
 
+    log.info("[FIND_FOLDER] DIR : {}", dirPath);
     List<FIleChecker.Folder> folderList =
-        FIleChecker.getFolderAll(dirPath).stream()
+        FIleChecker.getFolderAll(dirPath, nfsRootDir).stream()
             .filter(dir -> dir.getIsValid().equals(true))
             .toList();
 

src/main/java/com/kamco/cd/kamcoback/members/MembersApiController.java

@@ -5,7 +5,6 @@ import com.kamco.cd.kamcoback.members.dto.MembersDto;
 import com.kamco.cd.kamcoback.members.dto.MembersDto.Basic;
 import com.kamco.cd.kamcoback.members.service.AdminService;
 import com.kamco.cd.kamcoback.members.service.MembersService;
-import com.kamco.cd.kamcoback.scheduler.service.MemberInactiveJobService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.media.Content;
@@ -35,7 +34,6 @@ public class MembersApiController {
 
   private final MembersService membersService;
   private final AdminService adminService;
-  private final MemberInactiveJobService memberInactiveJobService;
 
   @Operation(summary = "회원정보 목록", description = "회원정보 조회")
   @ApiResponses(
@@ -159,13 +157,4 @@ public class MembersApiController {
           String employeeNo) {
     return ApiResponseDto.ok(adminService.existsByEmployeeNo(employeeNo));
   }
-
-  @Operation(
-      summary = "라벨러/검수자 최종로그인 28일 경과 이후 사용중지(스케줄링 실행)",
-      description = "라벨러/검수자 최종로그인 28일 경과 이후 사용중지 처리")
-  @GetMapping("/member-inactive-job")
-  public ApiResponseDto<Void> memberInactiveJob() {
-    memberInactiveJobService.memberActive28daysToInactive();
-    return ApiResponseDto.ok(null);
-  }
 }

src/main/java/com/kamco/cd/kamcoback/members/dto/MembersDto.java

@@ -111,8 +111,8 @@ public class MembersDto {
     @EnumValid(enumClass = RoleType.class, message = "userRole은 ADMIN, LABELER, REVIEWER 만 가능합니다.")
     private String userRole;
 
-    @Schema(description = "사번", example = "K20251212001")
+    @Schema(description = "사번", example = "123456")
-    @Size(max = 50)
+    @Size(max = 6)
     private String employeeNo;
 
     @Schema(description = "이름", example = "홍길동")

src/main/java/com/kamco/cd/kamcoback/members/dto/SignInRequest.java

@@ -11,7 +11,7 @@ import lombok.ToString;
 @ToString(exclude = "password")
 public class SignInRequest {
 
-  @Schema(description = "사용자 ID", example = "1234567")
+  @Schema(description = "사용자 ID", example = "123456")
   private String username;
 
   @Schema(description = "비밀번호", example = "qwe123!@#")

src/main/java/com/kamco/cd/kamcoback/menu/service/MenuService.java

@@ -9,8 +9,10 @@ import lombok.RequiredArgsConstructor;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 @Service
+@Transactional(readOnly = true)
 @RequiredArgsConstructor
 public class MenuService {
 

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

@@ -41,21 +41,6 @@ public class ModelMngApiController {
 
   private final ModelMngService modelMngService;
 
-  @Value("${file.sync-root-dir}")
-  private String syncRootDir;
-
-  @Value("${file.sync-tmp-dir}")
-  private String syncTmpDir;
-
-  @Value("${file.sync-file-extention}")
-  private String syncFileExtention;
-
-  @Value("${file.dataset-dir}")
-  private String datasetDir;
-
-  @Value("${file.dataset-tmp-dir}")
-  private String datasetTmpDir;
-
   @Value("${file.model-dir}")
   private String modelDir;
 

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

@@ -21,9 +21,9 @@ public class ModelMngDto {
   @Getter
   @AllArgsConstructor
   public enum ModelType implements EnumType {
-    M1("모델 M1"),
+    G1("G1"),
-    M2("모델 M2"),
+    G2("G2"),
-    M3("모델 M3");
+    G3("G3");
 
     private final String desc;
 

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

@@ -35,27 +35,6 @@ public class ModelMngService {
 
   private final UploadService uploadService;
 
-  @Value("${file.sync-root-dir}")
-  private String syncRootDir;
-
-  @Value("${file.sync-tmp-dir}")
-  private String syncTmpDir;
-
-  @Value("${file.sync-file-extention}")
-  private String syncFileExtention;
-
-  @Value("${file.dataset-dir}")
-  private String datasetDir;
-
-  @Value("${file.dataset-tmp-dir}")
-  private String datasetTmpDir;
-
-  @Value("${file.model-dir}")
-  private String modelDir;
-
-  @Value("${file.model-tmp-dir}")
-  private String modelTmpDir;
-
   @Value("${file.pt-path}")
   private String ptPath;
 

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

@@ -7,6 +7,7 @@ import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto;
 import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto.MapScaleType;
 import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto.MapSheetList;
 import com.kamco.cd.kamcoback.common.enums.DetectionClassification;
+import com.kamco.cd.kamcoback.common.exception.CustomApiException;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataInferenceGeomEntity;
 import com.kamco.cd.kamcoback.postgres.repository.changedetection.ChangeDetectionRepository;
 import java.util.List;
@@ -15,6 +16,7 @@ import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import org.locationtech.jts.geom.Geometry;
 import org.locationtech.jts.geom.Point;
+import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 
 @Service
@@ -96,4 +98,42 @@ public class ChangeDetectionCoreService {
   public List<MapSheetList> getChangeDetectionMapSheet50kList(UUID uuid) {
     return changeDetectionRepository.getChangeDetectionMapSheet50kList(uuid);
   }
+
+  /**
+   * 선택 폴리곤 조회 by object id
+   *
+   * @param chnDtctId 회차 uid 32자
+   * @param cdObjectId geo object uid 32자
+   * @param cdObjectIds geo object uids 32자
+   * @return
+   */
+  public ChangeDetectionDto.PolygonFeatureList getPolygonListByCd(
+      String chnDtctId, String cdObjectId, List<String> cdObjectIds) {
+    return changeDetectionRepository.getPolygonListByCd(chnDtctId, cdObjectId, cdObjectIds);
+  }
+
+  /**
+   * 선택 Point 조회 by object id
+   *
+   * @param chnDtctId 회차 uid 32자
+   * @param cdObjectId geo object uid 32자
+   * @param cdObjectIds geo object uids 32자
+   * @return
+   */
+  public ChangeDetectionDto.PointFeatureList getPointListByCd(
+      String chnDtctId, String cdObjectId, List<String> cdObjectIds) {
+    return changeDetectionRepository.getPointListByCd(chnDtctId, cdObjectId, cdObjectIds);
+  }
+
+  /**
+   * learn uuid 조회
+   *
+   * @param chnDtctId
+   * @return
+   */
+  public UUID getLearnUuid(String chnDtctId) {
+    return changeDetectionRepository
+        .getLearnUuid(chnDtctId)
+        .orElseThrow(() -> new CustomApiException("NOT_FOUND_DATA", HttpStatus.NOT_FOUND));
+  }
 }

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

@@ -1,9 +1,13 @@
 package com.kamco.cd.kamcoback.postgres.core;
 
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.Basic;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LabelSendDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.GukYuinLinkFacts;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.LearnInfo;
 import com.kamco.cd.kamcoback.postgres.repository.Inference.MapSheetLearnRepository;
 import com.kamco.cd.kamcoback.postgres.repository.gukyuin.GukYuinRepository;
+import java.time.LocalDate;
+import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -29,8 +33,8 @@ public class GukYuinCoreService {
     gukYuinRepository.updateGukYuinMastRegResult(resultBody);
   }
 
-  public void updateGukYuinMastRegRemove(Basic resultBody) {
+  public void updateGukYuinMastRegRemove(String chnDtctId) {
-    gukYuinRepository.updateGukYuinMastRegRemove(resultBody);
+    gukYuinRepository.updateGukYuinMastRegRemove(chnDtctId);
   }
 
   public void updateInferenceGeomDataPnuCnt(String chnDtctObjtId, long pnuCnt) {
@@ -41,7 +45,36 @@ public class GukYuinCoreService {
     return gukYuinRepository.findMapSheetAnalDataInferenceGeomUid(chnDtctObjtId);
   }
 
-  public void insertGeoUidPnuData(Long geoUid, String[] pnuList) {
+  public void insertGeoUidPnuData(Long geoUid, String[] pnuList, String chnDtctObjtId) {
-    gukYuinRepository.insertGeoUidPnuData(geoUid, pnuList);
+    gukYuinRepository.insertGeoUidPnuData(geoUid, pnuList, chnDtctObjtId);
+  }
+
+  public LearnInfo findMapSheetLearnInfo(UUID uuid) {
+    return gukYuinRepository.findMapSheetLearnInfo(uuid);
+  }
+
+  public Integer findMapSheetLearnYearStage(Integer compareYyyy, Integer targetYyyy) {
+    return gukYuinRepository.findMapSheetLearnYearStage(compareYyyy, targetYyyy);
+  }
+
+  public void updateAnalInferenceApplyDttm(Basic registRes) {
+    gukYuinRepository.updateAnalInferenceApplyDttm(registRes);
+  }
+
+  public List<LabelSendDto> findLabelingCompleteSendList(LocalDate yesterday) {
+    return gukYuinRepository.findLabelingCompleteSendList(yesterday);
+  }
+
+  public Long findMapSheetLearnInfoByYyyy(
+      Integer compareYyyy, Integer targetYyyy, Integer maxStage) {
+    return gukYuinRepository.findMapSheetLearnInfoByYyyy(compareYyyy, targetYyyy, maxStage);
+  }
+
+  public void updateMapSheetLearnGukyuinEndStatus(Long learnId) {
+    gukYuinRepository.updateMapSheetLearnGukyuinEndStatus(learnId);
+  }
+
+  public void updateMapSheetInferenceLabelEndStatus(Long learnId) {
+    gukYuinRepository.updateMapSheetInferenceLabelEndStatus(learnId);
   }
 }

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

@@ -1,8 +1,11 @@
 package com.kamco.cd.kamcoback.postgres.core;
 
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LearnKeyDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinStatus;
 import com.kamco.cd.kamcoback.postgres.repository.gukyuin.GukYuinRepository;
 import java.util.List;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 @Service
 public class GukYuinJobCoreService {
@@ -13,11 +16,12 @@ public class GukYuinJobCoreService {
     this.gukYuinRepository = gukYuinRepository;
   }
 
-  public List<String> findGukyuinApplyIngUidList() {
+  @Transactional
-    return gukYuinRepository.findGukyuinApplyIngUidList();
+  public void updateGukYuinApplyStateComplete(Long id, GukYuinStatus status) {
+    gukYuinRepository.updateGukYuinApplyStateComplete(id, status);
   }
 
-  public void updateGukYuinApplyStateComplete(String uid) {
+  public List<LearnKeyDto> findGukyuinApplyStatusUidList(List<String> gukYuinStatus) {
-    gukYuinRepository.updateGukYuinApplyStateComplete(uid);
+    return gukYuinRepository.findGukyuinApplyStatusUidList(gukYuinStatus);
   }
 }

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

@@ -0,0 +1,27 @@
+package com.kamco.cd.kamcoback.postgres.core;
+
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.GeomUidDto;
+import com.kamco.cd.kamcoback.postgres.repository.gukyuin.GukYuinLabelJobRepository;
+import java.time.LocalDate;
+import java.util.List;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class GukYuinLabelJobCoreService {
+
+  private final GukYuinLabelJobRepository gukYuinLabelRepository;
+
+  public GukYuinLabelJobCoreService(GukYuinLabelJobRepository gukYuinLabelRepository) {
+    this.gukYuinLabelRepository = gukYuinLabelRepository;
+  }
+
+  public List<GeomUidDto> findYesterdayLabelingCompleteList(LocalDate baseDate) {
+    return gukYuinLabelRepository.findYesterdayLabelingCompleteList(baseDate);
+  }
+
+  @Transactional
+  public void updateAnalDataInferenceGeomSendDttm(Long geoUid) {
+    gukYuinLabelRepository.updateAnalDataInferenceGeomSendDttm(geoUid);
+  }
+}

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

@@ -0,0 +1,44 @@
+package com.kamco.cd.kamcoback.postgres.core;
+
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LearnKeyDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinStatus;
+import com.kamco.cd.kamcoback.postgres.repository.gukyuin.GukYuinPnuJobRepository;
+import java.util.List;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class GukYuinPnuJobCoreService {
+
+  private final GukYuinPnuJobRepository gukYuinPnuRepository;
+
+  public GukYuinPnuJobCoreService(GukYuinPnuJobRepository gukYuinPnuRepository) {
+    this.gukYuinPnuRepository = gukYuinPnuRepository;
+  }
+
+  public void updateGukYuinApplyStateComplete(Long id, GukYuinStatus status) {
+    gukYuinPnuRepository.updateGukYuinApplyStateComplete(id, status);
+  }
+
+  public List<LearnKeyDto> findGukyuinApplyStatusUidList(List<String> gukYuinStatus) {
+    return gukYuinPnuRepository.findGukyuinApplyStatusUidList(gukYuinStatus);
+  }
+
+  public long upsertMapSheetDataAnalGeomPnu(String chnDtctObjtId, String[] pnuList) {
+    return gukYuinPnuRepository.upsertMapSheetDataAnalGeomPnu(chnDtctObjtId, pnuList);
+  }
+
+  @Transactional
+  public void updateInferenceGeomDataPnuCnt(String chnDtctObjtId, long pnuCnt) {
+    gukYuinPnuRepository.updateInferenceGeomDataPnuCnt(chnDtctObjtId, pnuCnt);
+  }
+
+  public Long findMapSheetAnalDataInferenceGeomUid(String chnDtctObjtId) {
+    return gukYuinPnuRepository.findMapSheetAnalDataInferenceGeomUid(chnDtctObjtId);
+  }
+
+  @Transactional
+  public void insertGeoUidPnuData(Long geoUid, String[] pnuList, String chnDtctObjtId) {
+    gukYuinPnuRepository.insertGeoUidPnuData(geoUid, pnuList, chnDtctObjtId);
+  }
+}

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

@@ -0,0 +1,76 @@
+package com.kamco.cd.kamcoback.postgres.core;
+
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectContDto.StbltResult;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LearnKeyDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.RlbDtctMastDto;
+import com.kamco.cd.kamcoback.postgres.entity.PnuEntity;
+import com.kamco.cd.kamcoback.postgres.repository.gukyuin.GukYuinStbltJobRepository;
+import java.time.ZonedDateTime;
+import java.util.List;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class GukYuinStbltJobCoreService {
+
+  private final GukYuinStbltJobRepository gukYuinStbltRepository;
+
+  public GukYuinStbltJobCoreService(GukYuinStbltJobRepository gukYuinStbltRepository) {
+    this.gukYuinStbltRepository = gukYuinStbltRepository;
+  }
+
+  public List<LearnKeyDto> findGukYuinEligibleForSurveyList(String status) {
+    return gukYuinStbltRepository.findGukYuinEligibleForSurveyList(status);
+  }
+
+  @Transactional
+  public void updateGukYuinEligibleForSurvey(String resultUid, RlbDtctMastDto stbltDto) {
+    PnuEntity entity =
+        gukYuinStbltRepository.findPnuEntityByResultUid(resultUid, stbltDto.getPnu());
+
+    if (entity != null) {
+      entity.setPnuDtctId(stbltDto.getPnuDtctId());
+      entity.setPnu(stbltDto.getPnu());
+      entity.setLrmSyncYmd(stbltDto.getLrmSyncYmd());
+      entity.setPnuSyncYmd(stbltDto.getPnuSyncYmd());
+      entity.setMpqdNo(stbltDto.getMpqdNo());
+      entity.setCprsYr(stbltDto.getCprsYr());
+      entity.setCrtrYr(stbltDto.getCrtrYr());
+      entity.setChnDtctSno(stbltDto.getChnDtctSno());
+      entity.setChnDtctId(stbltDto.getChnDtctId());
+      entity.setChnDtctMstId(stbltDto.getChnDtctMstId());
+      entity.setChnDtctObjtId(stbltDto.getChnDtctObjtId());
+      entity.setChnDtctContId(stbltDto.getChnDtctContId());
+      entity.setChnCd(stbltDto.getChnCd());
+      entity.setBfClsCd(stbltDto.getBfClsCd());
+      entity.setBfClsProb(stbltDto.getBfClsProb());
+      entity.setAfClsCd(stbltDto.getAfClsCd());
+      entity.setAfClsProb(stbltDto.getAfClsProb());
+      entity.setPnuSqms(stbltDto.getPnuSqms());
+      entity.setPnuDtctSqms(stbltDto.getPnuDtctSqms());
+      entity.setChnDtctSqms(stbltDto.getChnDtctSqms());
+      entity.setStbltYn(stbltDto.getStbltYn());
+      entity.setIncyCd(stbltDto.getIncyCd());
+      entity.setIncyRsnCont(stbltDto.getIncyRsnCont());
+      entity.setLockYn(stbltDto.getLockYn());
+      entity.setLblYn(stbltDto.getLblYn());
+      entity.setChgYn(stbltDto.getChgYn());
+      entity.setRsatctNo(stbltDto.getRsatctNo());
+      entity.setRmk(stbltDto.getRmk());
+      entity.setCrtDt(stbltDto.getCrtDt());
+      entity.setCrtEpno(stbltDto.getCrtEpno());
+      entity.setCrtIp(stbltDto.getCrtIp());
+      entity.setChgDt(stbltDto.getChgDt());
+      entity.setChgIp(stbltDto.getChgIp());
+      entity.setDelYn(stbltDto.getDelYn().equals("Y"));
+
+      entity.setCreatedDttm(ZonedDateTime.now());
+      gukYuinStbltRepository.save(entity);
+    }
+  }
+
+  @Transactional
+  public void updateGukYuinObjectStbltYn(String resultUid, StbltResult stbResult) {
+    gukYuinStbltRepository.updateGukYuinObjectStbltYn(resultUid, stbResult);
+  }
+}

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

@@ -19,6 +19,7 @@ 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.InferenceResultsTestingDto;
 import com.kamco.cd.kamcoback.mapsheet.dto.MapSheetMngDto.MngListDto;
+import com.kamco.cd.kamcoback.model.dto.ModelMngDto.ModelType;
 import com.kamco.cd.kamcoback.postgres.entity.InferenceResultsTestingEntity;
 import com.kamco.cd.kamcoback.postgres.entity.MapInkx5kEntity;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataInferenceEntity;
@@ -37,10 +38,12 @@ import jakarta.persistence.EntityNotFoundException;
 import jakarta.validation.constraints.NotNull;
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
@@ -81,28 +84,34 @@ public class InferenceResultCoreService {
    * @param req
    */
   public UUID saveInferenceInfo(InferenceResultDto.RegReq req, List<MngListDto> targetList) {
-    String firstMapSheetName = null;
-    String mapSheetName = "";
-    int detectingCnt = 0;
 
-    for (MngListDto dto : targetList) {
+    List<MngListDto> distinctList =
-      if (detectingCnt == 0) {
+        targetList.stream()
-        firstMapSheetName = dto.getMapSheetName();
+            .filter(dto -> dto.getMapSheetName() != null && !dto.getMapSheetName().isBlank())
-      }
+            .collect(
-      detectingCnt++;
+                Collectors.toMap(
-    }
+                    MngListDto::getMapSheetName,
+                    dto -> dto,
+                    (existing, duplicate) -> existing,
+                    LinkedHashMap::new))
+            .values()
+            .stream()
+            .toList();
 
+    int detectingCnt = distinctList.size();
+
+    String mapSheetName;
     if (detectingCnt == 0) {
       mapSheetName = "";
     } else if (detectingCnt == 1) {
-      mapSheetName = firstMapSheetName + " 1건";
+      mapSheetName = distinctList.get(0).getMapSheetName() + " 1건";
     } else {
-      mapSheetName = firstMapSheetName + " 외 " + (detectingCnt - 1) + "건";
+      mapSheetName = distinctList.get(0).getMapSheetName() + " 외 " + (detectingCnt - 1) + "건";
     }
 
     MapSheetLearnEntity mapSheetLearnEntity = new MapSheetLearnEntity();
     mapSheetLearnEntity.setTitle(req.getTitle());
-    mapSheetLearnEntity.setRunningModelType("M1");
+    mapSheetLearnEntity.setRunningModelType(ModelType.G1.getId());
     mapSheetLearnEntity.setM1ModelUuid(req.getModel1Uuid());
     mapSheetLearnEntity.setM2ModelUuid(req.getModel2Uuid());
     mapSheetLearnEntity.setM3ModelUuid(req.getModel3Uuid());
@@ -113,7 +122,7 @@ public class InferenceResultCoreService {
     mapSheetLearnEntity.setCreatedUid(userUtil.getId());
     mapSheetLearnEntity.setMapSheetCnt(mapSheetName);
     mapSheetLearnEntity.setDetectingCnt(0L);
-    mapSheetLearnEntity.setTotalJobs((long) detectingCnt);
+    mapSheetLearnEntity.setTotalJobs((long) targetList.size());
 
     // 회차는 국유인 반영할때 update로 변경됨
     //    mapSheetLearnEntity.setStage(
@@ -293,7 +302,7 @@ public class InferenceResultCoreService {
 
   private void applyModelUpdate(MapSheetLearnEntity entity, SaveInferenceAiDto request) {
     switch (request.getType()) {
-      case "M1" ->
+      case "G1" ->
           applyModelFields(
               request,
               entity::setM1ModelBatchId,
@@ -303,7 +312,7 @@ public class InferenceResultCoreService {
               entity::setM1RunningJobs,
               entity::setM1CompletedJobs,
               entity::setM1FailedJobs);
-      case "M2" ->
+      case "G2" ->
           applyModelFields(
               request,
               entity::setM2ModelBatchId,
@@ -313,7 +322,7 @@ public class InferenceResultCoreService {
               entity::setM2RunningJobs,
               entity::setM2CompletedJobs,
               entity::setM2FailedJobs);
-      case "M3" ->
+      case "G3" ->
           applyModelFields(
               request,
               entity::setM3ModelBatchId,
@@ -489,15 +498,16 @@ public class InferenceResultCoreService {
   }
 
   /**
-   * 추론 결과 shp파일 생성위해서 조회
+   * 추론 결과 조회
    *
    * @param batchIds
    * @return
    */
-  public List<InferenceResultsTestingDto.ShpDto> getInferenceResults(List<Long> batchIds) {
+  public List<InferenceResultsTestingDto.Basic> getInferenceResults(List<Long> batchIds) {
     List<InferenceResultsTestingEntity> list =
         inferenceResultsTestingRepository.getInferenceResultList(batchIds);
-    return list.stream().map(InferenceResultsTestingDto.ShpDto::fromEntity).toList();
+
+    return list.stream().map(InferenceResultsTestingEntity::toDto).toList();
   }
 
   public Long getInferenceResultCnt(List<Long> batchIds) {

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

@@ -1,8 +1,11 @@
 package com.kamco.cd.kamcoback.postgres.core;
 
+import com.kamco.cd.kamcoback.common.exception.CustomApiException;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.AllocateInfoDto;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.InferenceDetail;
+import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.InferenceLearnDto;
+import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelMngState;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelerDetail;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelingStatDto;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.MoveInfo;
@@ -13,12 +16,18 @@ import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.ProjectInfo;
 import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.WorkProgressInfo;
 import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.WorkerStatistics;
 import com.kamco.cd.kamcoback.postgres.entity.LabelingAssignmentEntity;
+import com.kamco.cd.kamcoback.postgres.repository.batch.BatchStepHistoryRepository;
 import com.kamco.cd.kamcoback.postgres.repository.label.LabelAllocateRepository;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.time.LocalDate;
 import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.domain.Page;
+import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 
 @Service
@@ -26,6 +35,10 @@ import org.springframework.stereotype.Service;
 public class LabelAllocateCoreService {
 
   private final LabelAllocateRepository labelAllocateRepository;
+  private final BatchStepHistoryRepository batchStepHistoryRepository;
+
+  @Value("${file.dataset-response}")
+  private String responsePath;
 
   public List<AllocateInfoDto> fetchNextIds(Long lastId, Long batchSize, UUID uuid) {
     return labelAllocateRepository.fetchNextIds(lastId, batchSize, uuid);
@@ -234,4 +247,47 @@ public class LabelAllocateCoreService {
   public Long findLabelingIngProcessCnt() {
     return labelAllocateRepository.findLabelingIngProcessCnt();
   }
+
+  public boolean isDownloadable(UUID uuid) {
+    InferenceLearnDto dto = labelAllocateRepository.findLabelingIngProcessId(uuid);
+
+    if (dto == null) {
+      return false;
+    }
+
+    // 파일이 있는지만 확인
+    Path path = Paths.get(responsePath).resolve(dto.getLearnUid() + ".zip");
+    if (!Files.isRegularFile(path)) {
+      return false; // exists 포함
+    }
+
+    String state = dto.getAnalState();
+    boolean isLabelingIng =
+        LabelMngState.ASSIGNED.getId().equals(state) || LabelMngState.ING.getId().equals(state);
+
+    if (isLabelingIng) {
+      Long analId = dto.getAnalId();
+      if (analId == null) {
+        return false;
+      }
+      return batchStepHistoryRepository.isDownloadable(analId);
+    }
+
+    return true;
+  }
+
+  public String findLearnUid(UUID uuid) {
+    return labelAllocateRepository
+        .findLearnUid(uuid)
+        .orElseThrow(() -> new CustomApiException("NOT_FOUND_DATA", HttpStatus.NOT_FOUND));
+  }
+
+  public List<AllocateInfoDto> fetchNextIdsAddStbltYn(
+      UUID uuid, LocalDate baseDate, Long lastId, Long totalCnt) {
+    return labelAllocateRepository.fetchNextIdsAddStbltYn(uuid, baseDate, lastId, totalCnt);
+  }
+
+  public Long findAllocateAddCnt(UUID uuid, LocalDate baseDate) {
+    return labelAllocateRepository.findAllocateAddCnt(uuid, baseDate);
+  }
 }

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

@@ -6,7 +6,10 @@ import com.kamco.cd.kamcoback.common.enums.LayerType;
 import com.kamco.cd.kamcoback.common.exception.CustomApiException;
 import com.kamco.cd.kamcoback.common.utils.UserUtil;
 import com.kamco.cd.kamcoback.layer.dto.LayerDto;
+import com.kamco.cd.kamcoback.layer.dto.LayerDto.IsMapYn;
+import com.kamco.cd.kamcoback.layer.dto.LayerDto.LayerMapDto;
 import com.kamco.cd.kamcoback.layer.dto.LayerDto.OrderReq;
+import com.kamco.cd.kamcoback.layer.dto.LayerDto.TileUrlDto;
 import com.kamco.cd.kamcoback.layer.dto.WmsDto.WmsAddDto;
 import com.kamco.cd.kamcoback.layer.dto.WmtsDto.WmtsAddDto;
 import com.kamco.cd.kamcoback.postgres.entity.MapLayerEntity;
@@ -25,6 +28,7 @@ import org.springframework.stereotype.Service;
 @Service
 @RequiredArgsConstructor
 public class MapLayerCoreService {
+
   private final MapLayerRepository mapLayerRepository;
   private final UserUtil userUtil;
   private final ObjectMapper objectMapper;
@@ -63,10 +67,6 @@ public class MapLayerCoreService {
             .findDetailByUuid(uuid)
             .orElseThrow(() -> new CustomApiException("NOT_FOUND_DATA", HttpStatus.NOT_FOUND));
 
-    if (LayerType.TILE.getId().equals(entity.getLayerType())) {
-      throw new CustomApiException("UNPROCESSABLE_ENTITY", HttpStatus.CONFLICT);
-    }
-
     entity.setIsDeleted(true);
     entity.setUpdatedUid(userUtil.getId());
     entity.setUpdatedDttm(ZonedDateTime.now());
@@ -87,6 +87,10 @@ public class MapLayerCoreService {
       entity.setDescription(dto.getDescription());
     }
 
+    if (dto.getLayerName() != null) {
+      entity.setLayerName(dto.getLayerName());
+    }
+
     if (dto.getUrl() != null) {
       entity.setUrl(dto.getUrl());
     }
@@ -127,10 +131,40 @@ public class MapLayerCoreService {
       entity.setIsLabelingMap(dto.getIsLabelingMap());
     }
 
+    if (dto.getCrs() != null) {
+      entity.setCrs(dto.getCrs());
+    }
+
     entity.setUpdatedUid(userUtil.getId());
     entity.setUpdatedDttm(ZonedDateTime.now());
   }
 
+  /**
+   * 맵 노출 여부
+   *
+   * @param uuid
+   * @param isMapYn
+   */
+  public void updateIsMap(UUID uuid, IsMapYn isMapYn) {
+    MapLayerEntity entity =
+        mapLayerRepository
+            .findDetailByUuid(uuid)
+            .orElseThrow(() -> new CustomApiException("NOT_FOUND_DATA", HttpStatus.NOT_FOUND));
+
+    LayerDto.MapType mapType;
+
+    try {
+      mapType = LayerDto.MapType.valueOf(isMapYn.getMapType());
+    } catch (IllegalArgumentException e) {
+      throw new CustomApiException("BAD_REQUEST", HttpStatus.BAD_REQUEST);
+    }
+
+    switch (mapType) {
+      case CHANGE_MAP -> entity.setIsChangeMap(isMapYn.getIsMapYn());
+      case LABELING_MAP -> entity.setIsLabelingMap(isMapYn.getIsMapYn());
+    }
+  }
+
   /**
    * 순서 수정
    *
@@ -180,15 +214,10 @@ public class MapLayerCoreService {
    * @param dto
    */
   public UUID saveTile(LayerDto.AddReq dto) {
-    LayerDto.SearchReq searchReq = new LayerDto.SearchReq();
+    Long order = mapLayerRepository.findSortOrderDesc();
-    searchReq.setLayerType(LayerType.TILE.getId());
-    List<LayerDto.Basic> entityList = mapLayerRepository.findAllLayer(searchReq);
-
-    if (!entityList.isEmpty()) {
-      throw new CustomApiException("DUPLICATE_DATA", HttpStatus.CONFLICT);
-    }
 
     MapLayerEntity mapLayerEntity = new MapLayerEntity();
+    mapLayerEntity.setLayerName(dto.getLayerName());
     mapLayerEntity.setDescription(dto.getDescription());
     mapLayerEntity.setUrl(dto.getUrl());
     mapLayerEntity.setTag(dto.getTag());
@@ -198,11 +227,12 @@ public class MapLayerCoreService {
     mapLayerEntity.setMaxLat(dto.getMaxLat());
     mapLayerEntity.setMinZoom(dto.getMin());
     mapLayerEntity.setMaxZoom(dto.getMax());
+    mapLayerEntity.setCrs(dto.getCrs());
 
     mapLayerEntity.setCreatedUid(userUtil.getId());
     mapLayerEntity.setIsChangeMap(true);
-    mapLayerEntity.setIsLabelingMap(false);
+    mapLayerEntity.setIsLabelingMap(true);
-    mapLayerEntity.setOrder(1L);
+    mapLayerEntity.setOrder(order + 1);
     mapLayerEntity.setLayerType(LayerType.TILE.getId());
     mapLayerEntity.setUpdatedDttm(ZonedDateTime.now());
     return mapLayerRepository.save(mapLayerEntity).getUuid();
@@ -218,6 +248,7 @@ public class MapLayerCoreService {
     Long order = mapLayerRepository.findSortOrderDesc();
 
     MapLayerEntity mapLayerEntity = new MapLayerEntity();
+    mapLayerEntity.setLayerName(addDto.getLayerName());
     mapLayerEntity.setDescription(addDto.getDescription());
     mapLayerEntity.setUrl(addDto.getUrl());
     mapLayerEntity.setTag(addDto.getTag());
@@ -225,6 +256,7 @@ public class MapLayerCoreService {
     mapLayerEntity.setIsChangeMap(true);
     mapLayerEntity.setIsLabelingMap(true);
     mapLayerEntity.setLayerType(LayerType.GEOJSON.getId());
+    mapLayerEntity.setCrs(addDto.getCrs());
     mapLayerEntity.setUpdatedDttm(ZonedDateTime.now());
     mapLayerEntity.setOrder(order + 1);
     return mapLayerRepository.save(mapLayerEntity).getUuid();
@@ -247,6 +279,7 @@ public class MapLayerCoreService {
     }
 
     MapLayerEntity mapLayerEntity = new MapLayerEntity();
+    mapLayerEntity.setLayerName(addDto.getLayerName());
     mapLayerEntity.setTitle(addDto.getTitle());
     mapLayerEntity.setDescription(addDto.getDescription());
     mapLayerEntity.setCreatedUid(userUtil.getId());
@@ -279,6 +312,7 @@ public class MapLayerCoreService {
     }
 
     MapLayerEntity mapLayerEntity = new MapLayerEntity();
+    mapLayerEntity.setLayerName(addDto.getLayerName());
     mapLayerEntity.setTitle(addDto.getTitle());
     mapLayerEntity.setDescription(addDto.getDescription());
     mapLayerEntity.setCreatedUid(userUtil.getId());
@@ -291,4 +325,16 @@ public class MapLayerCoreService {
     mapLayerEntity.setTag(addDto.getTag());
     return mapLayerRepository.save(mapLayerEntity).getUuid();
   }
+
+  public List<LayerMapDto> findLayerMapList(String type) {
+    return mapLayerRepository.findLayerMapList(type);
+  }
+
+  public LayerDto.YearTileDto getChangeDetectionTileUrl(Integer beforeYear, Integer afterYear) {
+    return mapLayerRepository.getChangeDetectionTileUrl(beforeYear, afterYear);
+  }
+
+  public TileUrlDto getChangeDetectionTileOneYearUrl(Integer year) {
+    return mapLayerRepository.getChangeDetectionTileOneYearUrl(year);
+  }
 }

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

@@ -162,6 +162,9 @@ public class MapSheetMngCoreService {
             saved.getMngYyyy(), saved.getMngPath());
     mapSheetMngRepository.updateYearState(saved.getMngYyyy(), "DONE");
 
+    // 년도별 Tile 정보 등록
+    mapSheetMngRepository.insertMapSheetMngTile(addReq);
+
     return hstCnt;
   }
 
@@ -280,11 +283,19 @@ public class MapSheetMngCoreService {
 
     // 4) 파일 생성
     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());
-
+      log.info("GeoJsonFileWriter: {}", "scene_inference_" + yyyy);
       Scene scene = new Scene();
       scene.setFeatures(sceneInference);
       scene.setFilePath(outputPath.toString());
@@ -294,7 +305,7 @@ public class MapSheetMngCoreService {
     } catch (IOException e) {
       log.error(
           "FAIL_CREATE_MAP_SHEET_FILE: yyyy={}, isAll={}, path={}", yyyy, isAll, outputPath, e);
-      throw new CustomApiException("FAIL_CREATE_MAP_SHEET_FILE", HttpStatus.INTERNAL_SERVER_ERROR);
+      throw new CustomApiException("INTERNAL_SERVER_ERROR", HttpStatus.INTERNAL_SERVER_ERROR, e);
     }
   }
 
@@ -331,4 +342,9 @@ public class MapSheetMngCoreService {
   public List<MngListCompareDto> getByHstMapSheetCompareList(int mngYyyy, List<String> mapId) {
     return mapSheetMngYearRepository.findByHstMapSheetCompareList(mngYyyy, mapId);
   }
+
+  public List<String> getMapSheetMngHst(Integer year) {
+    List<MapSheetMngHstEntity> entity = mapSheetMngRepository.getMapSheetMngHst(year);
+    return entity.stream().map(MapSheetMngHstEntity::getMapSheetNum).toList();
+  }
 }

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

@@ -6,6 +6,7 @@ import com.kamco.cd.kamcoback.postgres.repository.mapsheet.MapSheetMngYearReposi
 import com.kamco.cd.kamcoback.postgres.repository.scheduler.MapSheetMngFileJobRepository;
 import com.kamco.cd.kamcoback.scheduler.dto.MapSheetMngDto;
 import com.kamco.cd.kamcoback.scheduler.dto.MapSheetMngDto.MngHstDto;
+import com.kamco.cd.kamcoback.scheduler.dto.MapSheetMngDto.YearMinMax;
 import jakarta.validation.Valid;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
@@ -67,9 +68,10 @@ public class MapSheetMngFileJobCoreService {
     return mapSheetMngFileJobRepository.findNotYetMapSheetMng();
   }
 
-  public Long findByHstMapSheetBeforeYyyyListCount(int strtYyyy, int endYyyy, String mapSheetNum) {
+  public Long findByHstMapSheetBeforeYyyyListCount(
+      int mngYyyy, int strtYyyy, int endYyyy, String mapSheetNum) {
     return mapSheetMngFileJobRepository.findByHstMapSheetBeforeYyyyListCount(
-        strtYyyy, endYyyy, mapSheetNum);
+        mngYyyy, strtYyyy, endYyyy, mapSheetNum);
   }
 
   public void updateException5kMapSheet(String mapSheetNum, CommonUseStatus commonUseStatus) {
@@ -79,4 +81,16 @@ public class MapSheetMngFileJobCoreService {
   public void saveSheetMngYear() {
     mapSheetMngYearRepository.saveFileInfo();
   }
+
+  public YearMinMax findYearMinMaxInfo() {
+    return mapSheetMngYearRepository.findYearMinMaxInfo();
+  }
+
+  public Long findMngYyyyCnt(Integer mngYyyy) {
+    return mapSheetMngFileJobRepository.findMngYyyyCnt(mngYyyy);
+  }
+
+  public Long findMapSheetUseExceptCnt(String mapSheetNum) {
+    return mapSheetMngFileJobRepository.findMapSheetUseExceptCnt(mapSheetNum);
+  }
 }

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

@@ -0,0 +1,37 @@
+package com.kamco.cd.kamcoback.postgres.core;
+
+import com.kamco.cd.kamcoback.postgres.repository.scheduler.TrainingDataLabelJobRepository;
+import com.kamco.cd.kamcoback.scheduler.dto.TrainingDataReviewJobDto.InspectorPendingDto;
+import com.kamco.cd.kamcoback.scheduler.dto.TrainingDataReviewJobDto.Tasks;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.UUID;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class TrainingDataLabelJobCoreService {
+
+  private final TrainingDataLabelJobRepository trainingDataLabelJobRepository;
+
+  public List<Tasks> findCompletedYesterdayUnassigned(LocalDate baseDate) {
+    return trainingDataLabelJobRepository.findCompletedYesterdayUnassigned(baseDate);
+  }
+
+  public void assignReviewerBatch(List<UUID> assignmentUids, String reviewerId) {
+    trainingDataLabelJobRepository.assignReviewerBatch(assignmentUids, reviewerId);
+  }
+
+  public List<InspectorPendingDto> findInspectorPendingByRound(Long analUid) {
+    return trainingDataLabelJobRepository.findInspectorPendingByRound(analUid);
+  }
+
+  public void lockInspectors(Long analUid, List<String> reviewerIds) {
+    trainingDataLabelJobRepository.lockInspectors(analUid, reviewerIds);
+  }
+
+  public void updateGeomUidTestState(List<Long> geomUids) {
+    trainingDataLabelJobRepository.updateGeomUidTestState(geomUids);
+  }
+}

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

@@ -4,10 +4,8 @@ import com.kamco.cd.kamcoback.postgres.repository.scheduler.TrainingDataReviewJo
 import com.kamco.cd.kamcoback.scheduler.dto.TrainingDataReviewJobDto.AnalCntInfo;
 import com.kamco.cd.kamcoback.scheduler.dto.TrainingDataReviewJobDto.AnalMapSheetList;
 import com.kamco.cd.kamcoback.scheduler.dto.TrainingDataReviewJobDto.CompleteLabelData;
-import com.kamco.cd.kamcoback.scheduler.dto.TrainingDataReviewJobDto.InspectorPendingDto;
+import java.time.LocalDate;
-import com.kamco.cd.kamcoback.scheduler.dto.TrainingDataReviewJobDto.Tasks;
 import java.util.List;
-import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
@@ -17,41 +15,14 @@ public class TrainingDataReviewJobCoreService {
 
   private final TrainingDataReviewJobRepository trainingDataReviewJobRepository;
 
-  public List<Tasks> findCompletedYesterdayUnassigned() {
-    return trainingDataReviewJobRepository.findCompletedYesterdayUnassigned();
-  }
-
-  public void assignReviewer(UUID assignmentUid, String reviewerId) {
-    trainingDataReviewJobRepository.assignReviewer(assignmentUid, reviewerId);
-  }
-
-  public void assignReviewerBatch(List<UUID> assignmentUids, String reviewerId) {
-    trainingDataReviewJobRepository.assignReviewerBatch(assignmentUids, reviewerId);
-  }
-
-  public Tasks findAssignmentTask(String assignmentUid) {
-    return trainingDataReviewJobRepository.findAssignmentTask(assignmentUid);
-  }
-
-  public List<InspectorPendingDto> findInspectorPendingByRound(Long analUid) {
-    return trainingDataReviewJobRepository.findInspectorPendingByRound(analUid);
-  }
-
-  public void lockInspectors(Long analUid, List<String> reviewerIds) {
-    trainingDataReviewJobRepository.lockInspectors(analUid, reviewerIds);
-  }
-
-  public void updateGeomUidTestState(List<Long> geomUids) {
-    trainingDataReviewJobRepository.updateGeomUidTestState(geomUids);
-  }
-
   public List<CompleteLabelData> findCompletedYesterdayLabelingList(
-      Long analUid, String mapSheetNum) {
+      Long analUid, String mapSheetNum, LocalDate baseDate) {
-    return trainingDataReviewJobRepository.findCompletedYesterdayLabelingList(analUid, mapSheetNum);
+    return trainingDataReviewJobRepository.findCompletedYesterdayLabelingList(
+        analUid, mapSheetNum, baseDate);
   }
 
-  public List<AnalMapSheetList> findCompletedAnalMapSheetList(Long analUid) {
+  public List<AnalMapSheetList> findCompletedAnalMapSheetList(Long analUid, LocalDate baseDate) {
-    return trainingDataReviewJobRepository.findCompletedAnalMapSheetList(analUid);
+    return trainingDataReviewJobRepository.findCompletedAnalMapSheetList(analUid, baseDate);
   }
 
   public List<AnalCntInfo> findAnalCntInfoList() {

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

@@ -0,0 +1,62 @@
+package com.kamco.cd.kamcoback.postgres.entity;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import java.time.LocalDateTime;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Entity
+@Table(name = "batch_step_history")
+public class BatchStepHistoryEntity {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "id", nullable = false)
+  private Long id;
+
+  @NotNull
+  @Column(name = "anal_uid", nullable = false)
+  private Long analUid;
+
+  @Size(max = 255)
+  @NotNull
+  @Column(name = "result_uid", nullable = false)
+  private String resultUid;
+
+  @Size(max = 100)
+  @NotNull
+  @Column(name = "step_name", nullable = false, length = 100)
+  private String stepName;
+
+  @Size(max = 50)
+  @NotNull
+  @Column(name = "status", nullable = false, length = 50)
+  private String status;
+
+  @Column(name = "error_message", length = Integer.MAX_VALUE)
+  private String errorMessage;
+
+  @NotNull
+  @Column(name = "started_dttm", nullable = false)
+  private LocalDateTime startedDttm;
+
+  @Column(name = "completed_dttm")
+  private LocalDateTime completedDttm;
+
+  @NotNull
+  @Column(name = "created_dttm", nullable = false)
+  private LocalDateTime createdDttm;
+
+  @NotNull
+  @Column(name = "updated_dttm", nullable = false)
+  private LocalDateTime updatedDttm;
+}

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

@@ -1,5 +1,6 @@
 package com.kamco.cd.kamcoback.postgres.entity;
 
+import com.kamco.cd.kamcoback.inference.dto.InferenceResultsTestingDto;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.Id;
@@ -84,4 +85,28 @@ public class InferenceResultsTestingEntity {
 
   @Column(name = "geometry", columnDefinition = "geometry")
   private Geometry geometry;
+
+  public InferenceResultsTestingDto.Basic toDto() {
+    return new InferenceResultsTestingDto.Basic(
+        this.probability,
+        this.beforeYear,
+        this.afterYear,
+        this.mapId,
+        this.modelVersion,
+        this.clsModelPath,
+        this.clsModelVersion,
+        this.cdModelType,
+        this.id,
+        this.modelName,
+        this.batchId,
+        this.area,
+        this.beforeC,
+        this.beforeP,
+        this.afterC,
+        this.afterP,
+        this.seq,
+        this.createdDate,
+        this.uid,
+        this.geometry);
+  }
 }

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

@@ -43,6 +43,10 @@ public class MapLayerEntity {
   @Column(name = "title", length = 200)
   private String title;
 
+  @Size(max = 255)
+  @Column(name = "layer_name")
+  private String layerName;
+
   @Column(name = "description", length = Integer.MAX_VALUE)
   private String description;
 
@@ -103,9 +107,13 @@ public class MapLayerEntity {
   @Column(name = "is_deleted")
   private Boolean isDeleted = false;
 
+  @Column(name = "crs")
+  private String crs;
+
   public LayerDto.Detail toDto() {
     return new LayerDto.Detail(
         this.uuid,
+        this.layerName,
         this.layerType,
         this.title,
         this.description,
@@ -120,6 +128,7 @@ public class MapLayerEntity {
         this.maxLat,
         this.minZoom,
         this.maxZoom,
-        this.createdDttm);
+        this.createdDttm,
+        this.crs);
   }
 }

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

@@ -156,6 +156,12 @@ public class MapSheetAnalDataInferenceGeomEntity {
   @JoinColumn(name = "map_5k_id", referencedColumnName = "fid")
   private MapInkx5kEntity map5k;
 
+  @Column(name = "label_send_dttm")
+  private ZonedDateTime labelSendDttm;
+
+  @Column(name = "lock_yn")
+  private String lockYn;
+
   public InferenceDetailDto.DetailListEntity toEntity() {
     DetectionClassification classification = DetectionClassification.fromString(classBeforeCd);
     Clazzes comparedClazz = new Clazzes(classification, classBeforeProb);

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

@@ -199,6 +199,9 @@ public class MapSheetLearnEntity {
   @Column(name = "total_jobs")
   private Long totalJobs;
 
+  @Column(name = "chn_dtct_mst_id")
+  private String chnDtctMstId;
+
   public InferenceResultDto.ResultList toDto() {
     return new InferenceResultDto.ResultList(
         this.uuid,

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

@@ -0,0 +1,58 @@
+package com.kamco.cd.kamcoback.postgres.entity;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotNull;
+import java.math.BigDecimal;
+import java.time.ZonedDateTime;
+import lombok.Getter;
+import lombok.Setter;
+import org.hibernate.annotations.ColumnDefault;
+
+@Getter
+@Setter
+@Entity
+@Table(name = "tb_map_sheet_mng_tile")
+public class MapSheetMngTileEntity {
+
+  @Id
+  @Column(name = "mng_yyyy", nullable = false)
+  private Integer mngYyyy;
+
+  @Column(name = "url", length = Integer.MAX_VALUE)
+  private String url;
+
+  @Column(name = "min_lon", precision = 10, scale = 7)
+  private BigDecimal minLon;
+
+  @Column(name = "min_lat", precision = 10, scale = 7)
+  private BigDecimal minLat;
+
+  @Column(name = "max_lon", precision = 10, scale = 7)
+  private BigDecimal maxLon;
+
+  @Column(name = "max_lat", precision = 10, scale = 7)
+  private BigDecimal maxLat;
+
+  @Column(name = "min_zoom")
+  private Short minZoom;
+
+  @Column(name = "max_zoom")
+  private Short maxZoom;
+
+  @Column(name = "tag")
+  private String tag;
+
+  @Column(name = "crs")
+  private String crs;
+
+  @NotNull
+  @ColumnDefault("now()")
+  @Column(name = "created_dttm", nullable = false)
+  private ZonedDateTime createdDttm = ZonedDateTime.now();
+
+  @Column(name = "updated_dttm")
+  private ZonedDateTime updatedDttm;
+}

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

@@ -12,7 +12,7 @@ import jakarta.persistence.SequenceGenerator;
 import jakarta.persistence.Table;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
-import java.time.OffsetDateTime;
+import java.time.ZonedDateTime;
 import lombok.Getter;
 import lombok.Setter;
 import org.hibernate.annotations.ColumnDefault;
@@ -39,7 +39,7 @@ public class PnuEntity {
   private String pnu;
 
   @Column(name = "created_dttm")
-  private OffsetDateTime createdDttm;
+  private ZonedDateTime createdDttm;
 
   @Column(name = "created_uid")
   private Long createdUid;
@@ -47,4 +47,140 @@ public class PnuEntity {
   @ColumnDefault("false")
   @Column(name = "del_yn")
   private Boolean delYn;
+
+  @Size(max = 40)
+  @Column(name = "pnu_dtct_id", length = 40)
+  private String pnuDtctId;
+
+  @Size(max = 10)
+  @Column(name = "lrm_sync_ymd", length = 10)
+  private String lrmSyncYmd;
+
+  @Size(max = 10)
+  @Column(name = "pnu_sync_ymd", length = 10)
+  private String pnuSyncYmd;
+
+  @Size(max = 20)
+  @Column(name = "mpqd_no", length = 20)
+  private String mpqdNo;
+
+  @Size(max = 10)
+  @Column(name = "cprs_yr", length = 10)
+  private String cprsYr;
+
+  @Size(max = 10)
+  @Column(name = "crtr_yr", length = 10)
+  private String crtrYr;
+
+  @Size(max = 255)
+  @Column(name = "chn_dtct_id")
+  private String chnDtctId;
+
+  @Size(max = 10)
+  @Column(name = "chn_dtct_mst_id", length = 10)
+  private String chnDtctMstId;
+
+  @Size(max = 255)
+  @Column(name = "chn_dtct_objt_id")
+  private String chnDtctObjtId;
+
+  @Size(max = 255)
+  @Column(name = "chn_dtct_cont_id")
+  private String chnDtctContId;
+
+  @Size(max = 50)
+  @Column(name = "chn_cd", length = 50)
+  private String chnCd;
+
+  @Size(max = 50)
+  @Column(name = "chn_dtct_prob", length = 50)
+  private String chnDtctProb;
+
+  @Size(max = 50)
+  @Column(name = "bf_cls_cd", length = 50)
+  private String bfClsCd;
+
+  @Size(max = 50)
+  @Column(name = "bf_cls_prob", length = 50)
+  private String bfClsProb;
+
+  @Size(max = 50)
+  @Column(name = "af_cls_cd", length = 50)
+  private String afClsCd;
+
+  @Size(max = 50)
+  @Column(name = "af_cls_prob", length = 50)
+  private String afClsProb;
+
+  @Size(max = 100)
+  @Column(name = "pnu_sqms", length = 100)
+  private String pnuSqms;
+
+  @Size(max = 100)
+  @Column(name = "pnu_dtct_sqms", length = 100)
+  private String pnuDtctSqms;
+
+  @Size(max = 100)
+  @Column(name = "chn_dtct_sqms", length = 100)
+  private String chnDtctSqms;
+
+  @Size(max = 1)
+  @Column(name = "stblt_yn", length = 1)
+  private String stbltYn;
+
+  @Size(max = 30)
+  @Column(name = "incy_cd", length = 30)
+  private String incyCd;
+
+  @Size(max = 255)
+  @Column(name = "incy_rsn_cont")
+  private String incyRsnCont;
+
+  @Size(max = 1)
+  @Column(name = "lock_yn", length = 1)
+  private String lockYn;
+
+  @Size(max = 1)
+  @Column(name = "lbl_yn", length = 1)
+  private String lblYn;
+
+  @Size(max = 1)
+  @Column(name = "chg_yn", length = 1)
+  private String chgYn;
+
+  @Size(max = 50)
+  @Column(name = "rsatct_no", length = 50)
+  private String rsatctNo;
+
+  @Size(max = 100)
+  @Column(name = "rmk", length = 100)
+  private String rmk;
+
+  @Size(max = 20)
+  @Column(name = "crt_dt", length = 20)
+  private String crtDt;
+
+  @Size(max = 20)
+  @Column(name = "crt_epno", length = 20)
+  private String crtEpno;
+
+  @Size(max = 20)
+  @Column(name = "crt_ip", length = 20)
+  private String crtIp;
+
+  @Size(max = 20)
+  @Column(name = "chg_dt", length = 20)
+  private String chgDt;
+
+  @Size(max = 20)
+  @Column(name = "chg_epno", length = 20)
+  private String chgEpno;
+
+  @Size(max = 20)
+  @Column(name = "chg_ip", length = 20)
+  private String chgIp;
+
+  @Size(max = 10)
+  @Column(name = "chn_dtct_sno", length = 10)
+  private String chnDtctSno;
 }

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

@@ -35,17 +35,17 @@ public class MapSheetLearn5kRepositoryImpl implements MapSheetLearn5kRepositoryC
     final StringPath errorMsgPath;
 
     switch (type) {
-      case "M1" -> {
+      case "G1" -> {
         failPath = mapSheetLearn5kEntity.isM1Fail;
         jobIdPath = mapSheetLearn5kEntity.m1JobId;
         errorMsgPath = mapSheetLearn5kEntity.m1ErrorMessage;
       }
-      case "M2" -> {
+      case "G2" -> {
         failPath = mapSheetLearn5kEntity.isM2Fail;
         jobIdPath = mapSheetLearn5kEntity.m2JobId;
         errorMsgPath = mapSheetLearn5kEntity.m2ErrorMessage;
       }
-      case "M3" -> {
+      case "G3" -> {
         failPath = mapSheetLearn5kEntity.isM3Fail;
         jobIdPath = mapSheetLearn5kEntity.m3JobId;
         errorMsgPath = mapSheetLearn5kEntity.m3ErrorMessage;
@@ -85,15 +85,15 @@ public class MapSheetLearn5kRepositoryImpl implements MapSheetLearn5kRepositoryC
     final StringPath errorMsgPath;
 
     switch (type) {
-      case "M1" -> {
+      case "G1" -> {
         failPath = mapSheetLearn5kEntity.isM1Fail;
         jobIdPath = mapSheetLearn5kEntity.m1JobId;
       }
-      case "M2" -> {
+      case "G2" -> {
         failPath = mapSheetLearn5kEntity.isM2Fail;
         jobIdPath = mapSheetLearn5kEntity.m2JobId;
       }
-      case "M3" -> {
+      case "G3" -> {
         failPath = mapSheetLearn5kEntity.isM3Fail;
         jobIdPath = mapSheetLearn5kEntity.m3JobId;
       }
@@ -135,15 +135,15 @@ public class MapSheetLearn5kRepositoryImpl implements MapSheetLearn5kRepositoryC
     BooleanPath failPath;
 
     switch (type) {
-      case "M1" -> {
+      case "G1" -> {
         jobIdPath = mapSheetLearn5kEntity.m1JobId;
         failPath = mapSheetLearn5kEntity.isM1Fail;
       }
-      case "M2" -> {
+      case "G2" -> {
         jobIdPath = mapSheetLearn5kEntity.m2JobId;
         failPath = mapSheetLearn5kEntity.isM2Fail;
       }
-      case "M3" -> {
+      case "G3" -> {
         jobIdPath = mapSheetLearn5kEntity.m3JobId;
         failPath = mapSheetLearn5kEntity.isM3Fail;
       }
@@ -180,13 +180,13 @@ public class MapSheetLearn5kRepositoryImpl implements MapSheetLearn5kRepositoryC
     BooleanPath failPath;
 
     switch (type) {
-      case "M1" -> {
+      case "G1" -> {
         jobIdPath = mapSheetLearn5kEntity.m1JobId;
       }
-      case "M2" -> {
+      case "G2" -> {
         jobIdPath = mapSheetLearn5kEntity.m2JobId;
       }
-      case "M3" -> {
+      case "G3" -> {
         jobIdPath = mapSheetLearn5kEntity.m3JobId;
       }
       default -> {

src/main/java/com/kamco/cd/kamcoback/postgres/repository/batch/BatchStepHistoryRepository.java

@@ -0,0 +1,7 @@
+package com.kamco.cd.kamcoback.postgres.repository.batch;
+
+import com.kamco.cd.kamcoback.postgres.entity.BatchStepHistoryEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface BatchStepHistoryRepository
+    extends JpaRepository<BatchStepHistoryEntity, Long>, BatchStepHistoryRepositoryCustom {}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/batch/BatchStepHistoryRepositoryCustom.java

@@ -0,0 +1,5 @@
+package com.kamco.cd.kamcoback.postgres.repository.batch;
+
+public interface BatchStepHistoryRepositoryCustom {
+  boolean isDownloadable(Long analUid);
+}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/batch/BatchStepHistoryRepositoryImpl.java

@@ -0,0 +1,37 @@
+package com.kamco.cd.kamcoback.postgres.repository.batch;
+
+import com.kamco.cd.kamcoback.postgres.entity.QBatchStepHistoryEntity;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@RequiredArgsConstructor
+public class BatchStepHistoryRepositoryImpl implements BatchStepHistoryRepositoryCustom {
+  private final JPAQueryFactory queryFactory;
+
+  @Override
+  public boolean isDownloadable(Long analUid) {
+    QBatchStepHistoryEntity h = QBatchStepHistoryEntity.batchStepHistoryEntity;
+
+    boolean startedExists =
+        queryFactory
+                .selectOne()
+                .from(h)
+                .where(
+                    h.analUid.eq(analUid), h.stepName.eq("zipResponseStep"), h.status.eq("STARTED"))
+                .fetchFirst()
+            != null;
+
+    boolean successExists =
+        queryFactory
+                .selectOne()
+                .from(h)
+                .where(
+                    h.analUid.eq(analUid), h.stepName.eq("zipResponseStep"), h.status.eq("SUCCESS"))
+                .fetchFirst()
+            != null;
+
+    return successExists && !startedExists;
+  }
+}

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

@@ -4,6 +4,7 @@ import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto;
 import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto.MapScaleType;
 import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto.MapSheetList;
 import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
 
 public interface ChangeDetectionRepositoryCustom {
@@ -28,4 +29,18 @@ public interface ChangeDetectionRepositoryCustom {
   List<ChangeDetectionDto.MapSheetList> getChangeDetectionMapSheetList(UUID uuid);
 
   List<MapSheetList> getChangeDetectionMapSheet50kList(UUID uuid);
+
+  ChangeDetectionDto.PolygonFeatureList getPolygonListByCd(
+      String chnDtctId, String cdObjectId, List<String> cdObjectIds);
+
+  ChangeDetectionDto.PointFeatureList getPointListByCd(
+      String chnDtctId, String cdObjectId, List<String> cdObjectIds);
+
+  ChangeDetectionDto.PolygonFeatureList getSelectedChangeDetectionPolygonListByPnu(
+      String chnDtctId, String pnu);
+
+  ChangeDetectionDto.PointFeatureList getSelectedChangeDetectionPointListByPnu(
+      String chnDtctId, String pnu);
+
+  Optional<UUID> getLearnUuid(String chnDtctId);
 }

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

@@ -8,6 +8,7 @@ import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataInferenceG
 import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalInferenceEntity.mapSheetAnalInferenceEntity;
 import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalSttcEntity.mapSheetAnalSttcEntity;
 import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetLearnEntity.mapSheetLearnEntity;
+import static com.kamco.cd.kamcoback.postgres.entity.QPnuEntity.pnuEntity;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
@@ -16,11 +17,14 @@ import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto;
 import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto.DetectSearchType;
 import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto.MapScaleType;
 import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto.MapSheetList;
+import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto.PointFeatureList;
+import com.kamco.cd.kamcoback.changedetection.dto.ChangeDetectionDto.PolygonFeatureList;
 import com.kamco.cd.kamcoback.inference.dto.InferenceResultDto.Status;
 import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataInferenceGeomEntity;
 import com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataInferenceEntity;
 import com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalInferenceEntity;
 import com.kamco.cd.kamcoback.postgres.entity.QMapSheetLearnEntity;
+import com.querydsl.core.BooleanBuilder;
 import com.querydsl.core.types.Projections;
 import com.querydsl.core.types.dsl.BooleanExpression;
 import com.querydsl.core.types.dsl.CaseBuilder;
@@ -30,10 +34,13 @@ import com.querydsl.jpa.JPAExpressions;
 import com.querydsl.jpa.impl.JPAQueryFactory;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.UUID;
 import java.util.stream.Collectors;
 import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;
+import org.springframework.stereotype.Repository;
 
+@Repository
 public class ChangeDetectionRepositoryImpl extends QuerydslRepositorySupport
     implements ChangeDetectionRepositoryCustom {
 
@@ -226,7 +233,9 @@ public class ChangeDetectionRepositoryImpl extends QuerydslRepositorySupport
                     mapSheetAnalDataInferenceGeomEntity.targetYyyy,
                     mapSheetAnalDataInferenceGeomEntity.classAfterProb,
                     mapSheetAnalDataInferenceGeomEntity.classAfterCd.toUpperCase(),
-                    mapSheetAnalDataInferenceGeomEntity.cdProb))
+                    mapSheetAnalDataInferenceGeomEntity.cdProb,
+                    mapSheetAnalDataInferenceGeomEntity.uuid,
+                    mapSheetAnalDataInferenceGeomEntity.resultUid))
             .from(mapSheetAnalDataInferenceGeomEntity)
             .innerJoin(mapSheetAnalDataInferenceEntity)
             .on(mapSheetAnalDataInferenceGeomEntity.dataUid.eq(mapSheetAnalDataInferenceEntity.id))
@@ -261,7 +270,9 @@ public class ChangeDetectionRepositoryImpl extends QuerydslRepositorySupport
                           data.getAfterYear(),
                           data.getAfterConfidence(),
                           data.getAfterClass(),
-                          data.getCdProb());
+                          data.getCdProb(),
+                          data.getUuid(),
+                          data.getResultUid());
 
                   return new ChangeDetectionDto.PolygonFeature(
                       data.getType(), jsonNode, properties);
@@ -371,4 +382,275 @@ public class ChangeDetectionRepositoryImpl extends QuerydslRepositorySupport
                 "{0} || {1}", imageryEntity.cogMiddlePath, imageryEntity.cogFilename))
         .otherwise("");
   }
+
+  @Override
+  public PolygonFeatureList getPolygonListByCd(
+      String chnDtctId, String cdObjectId, List<String> cdObjectIds) {
+    BooleanBuilder builder = new BooleanBuilder();
+    builder.and(mapSheetLearnEntity.uid.eq(chnDtctId));
+    builder.and(
+        mapSheetAnalDataInferenceGeomEntity
+            .resultUid
+            .eq(chnDtctId)
+            .or(mapSheetAnalDataInferenceGeomEntity.resultUid.in(cdObjectIds)));
+
+    List<ChangeDetectionDto.PolygonQueryData> list =
+        queryFactory
+            .select(
+                Projections.constructor(
+                    ChangeDetectionDto.PolygonQueryData.class,
+                    Expressions.stringTemplate("{0}", "Feature"),
+                    Expressions.stringTemplate(
+                        "ST_AsGeoJSON({0})", mapSheetAnalDataInferenceGeomEntity.geom),
+                    mapSheetAnalDataInferenceGeomEntity.geoUid,
+                    mapSheetAnalDataInferenceGeomEntity.area,
+                    mapSheetAnalDataInferenceGeomEntity.compareYyyy,
+                    mapSheetAnalDataInferenceGeomEntity.classBeforeProb,
+                    mapSheetAnalDataInferenceGeomEntity.classBeforeCd.toUpperCase(),
+                    mapSheetAnalDataInferenceGeomEntity.targetYyyy,
+                    mapSheetAnalDataInferenceGeomEntity.classAfterProb,
+                    mapSheetAnalDataInferenceGeomEntity.classAfterCd.toUpperCase(),
+                    mapSheetAnalDataInferenceGeomEntity.cdProb,
+                    mapSheetAnalDataInferenceGeomEntity.uuid,
+                    mapSheetAnalDataInferenceGeomEntity.resultUid))
+            .from(mapSheetAnalDataInferenceGeomEntity)
+            .innerJoin(mapSheetAnalDataInferenceEntity)
+            .on(mapSheetAnalDataInferenceGeomEntity.dataUid.eq(mapSheetAnalDataInferenceEntity.id))
+            .innerJoin(mapSheetAnalInferenceEntity)
+            .on(mapSheetAnalInferenceEntity.id.eq(mapSheetAnalDataInferenceEntity.analUid))
+            .innerJoin(mapSheetLearnEntity)
+            .on(mapSheetLearnEntity.id.eq(mapSheetAnalInferenceEntity.learnId))
+            .where(builder)
+            .orderBy(mapSheetAnalDataInferenceGeomEntity.mapSheetNum.asc())
+            .fetch();
+
+    ObjectMapper mapper = new ObjectMapper();
+    List<ChangeDetectionDto.PolygonFeature> result =
+        list.stream()
+            .map(
+                data -> {
+                  String geoJson = data.getGeometry();
+                  JsonNode jsonNode;
+                  try {
+                    jsonNode = mapper.readTree(geoJson);
+                  } catch (JsonProcessingException e) {
+                    throw new RuntimeException(e);
+                  }
+
+                  ChangeDetectionDto.PolygonProperties properties =
+                      new ChangeDetectionDto.PolygonProperties(
+                          data.getGeoUid(),
+                          data.getArea(),
+                          data.getBeforeYear(),
+                          data.getBeforeConfidence(),
+                          data.getBeforeClass(),
+                          data.getAfterYear(),
+                          data.getAfterConfidence(),
+                          data.getAfterClass(),
+                          data.getCdProb(),
+                          data.getUuid(),
+                          data.getResultUid());
+
+                  return new ChangeDetectionDto.PolygonFeature(
+                      data.getType(), jsonNode, properties);
+                })
+            .collect(Collectors.toList());
+
+    ChangeDetectionDto.PolygonFeatureList polygonList = new ChangeDetectionDto.PolygonFeatureList();
+    polygonList.setType("FeatureCollection");
+    polygonList.setFeatures(result);
+    return polygonList;
+  }
+
+  @Override
+  public PointFeatureList getPointListByCd(
+      String chnDtctId, String cdObjectId, List<String> cdObjectIds) {
+    BooleanBuilder builder = new BooleanBuilder();
+    builder.and(mapSheetLearnEntity.uid.eq(chnDtctId));
+    builder.and(
+        mapSheetAnalDataInferenceGeomEntity
+            .resultUid
+            .eq(chnDtctId)
+            .or(mapSheetAnalDataInferenceGeomEntity.resultUid.in(cdObjectIds)));
+
+    List<ChangeDetectionDto.PointQueryData> list =
+        queryFactory
+            .select(
+                Projections.constructor(
+                    ChangeDetectionDto.PointQueryData.class,
+                    Expressions.stringTemplate("{0}", "Feature"),
+                    Expressions.stringTemplate(
+                        "ST_AsGeoJSON({0})",
+                        mapSheetAnalDataInferenceGeomEntity.geomCenter), // point
+                    Projections.constructor(
+                        ChangeDetectionDto.PointProperties.class,
+                        mapSheetAnalDataInferenceGeomEntity.geoUid,
+                        mapSheetAnalDataInferenceGeomEntity.classAfterCd.toUpperCase())))
+            .from(mapSheetAnalDataInferenceGeomEntity)
+            .innerJoin(mapSheetAnalDataInferenceEntity)
+            .on(mapSheetAnalDataInferenceGeomEntity.dataUid.eq(mapSheetAnalDataInferenceEntity.id))
+            .innerJoin(mapSheetAnalInferenceEntity)
+            .on(mapSheetAnalInferenceEntity.id.eq(mapSheetAnalDataInferenceEntity.analUid))
+            .innerJoin(mapSheetLearnEntity)
+            .on(mapSheetLearnEntity.id.eq(mapSheetAnalInferenceEntity.learnId))
+            .where(builder)
+            .fetch();
+
+    ObjectMapper mapper = new ObjectMapper();
+    List<ChangeDetectionDto.PointFeature> result =
+        list.stream()
+            .map(
+                data -> {
+                  String geoJson = data.getGeometry();
+                  JsonNode jsonNode;
+                  try {
+                    jsonNode = mapper.readTree(geoJson);
+                  } catch (JsonProcessingException e) {
+                    throw new RuntimeException(e);
+                  }
+
+                  return new ChangeDetectionDto.PointFeature(
+                      data.getType(), jsonNode, data.getProperties());
+                })
+            .collect(Collectors.toList());
+
+    return new ChangeDetectionDto.PointFeatureList("FeatureCollection", result);
+  }
+
+  @Override
+  public PolygonFeatureList getSelectedChangeDetectionPolygonListByPnu(
+      String chnDtctId, String pnu) {
+    BooleanBuilder builder = new BooleanBuilder();
+    builder.and(mapSheetLearnEntity.uid.eq(chnDtctId));
+    builder.and(pnuEntity.pnu.eq(pnu));
+
+    List<ChangeDetectionDto.PolygonQueryData> list =
+        queryFactory
+            .select(
+                Projections.constructor(
+                    ChangeDetectionDto.PolygonQueryData.class,
+                    Expressions.stringTemplate("{0}", "Feature"),
+                    Expressions.stringTemplate(
+                        "ST_AsGeoJSON({0})", mapSheetAnalDataInferenceGeomEntity.geom),
+                    mapSheetAnalDataInferenceGeomEntity.geoUid,
+                    mapSheetAnalDataInferenceGeomEntity.area,
+                    mapSheetAnalDataInferenceGeomEntity.compareYyyy,
+                    mapSheetAnalDataInferenceGeomEntity.classBeforeProb,
+                    mapSheetAnalDataInferenceGeomEntity.classBeforeCd.toUpperCase(),
+                    mapSheetAnalDataInferenceGeomEntity.targetYyyy,
+                    mapSheetAnalDataInferenceGeomEntity.classAfterProb,
+                    mapSheetAnalDataInferenceGeomEntity.classAfterCd.toUpperCase(),
+                    mapSheetAnalDataInferenceGeomEntity.cdProb))
+            .from(mapSheetAnalDataInferenceGeomEntity)
+            .innerJoin(mapSheetAnalDataInferenceEntity)
+            .on(mapSheetAnalDataInferenceGeomEntity.dataUid.eq(mapSheetAnalDataInferenceEntity.id))
+            .innerJoin(mapSheetAnalInferenceEntity)
+            .on(mapSheetAnalInferenceEntity.id.eq(mapSheetAnalDataInferenceEntity.analUid))
+            .innerJoin(mapSheetLearnEntity)
+            .on(mapSheetLearnEntity.id.eq(mapSheetAnalInferenceEntity.learnId))
+            .innerJoin(pnuEntity.geo, mapSheetAnalDataInferenceGeomEntity)
+            .where(builder)
+            .orderBy(mapSheetAnalDataInferenceGeomEntity.mapSheetNum.asc())
+            .fetch();
+
+    ObjectMapper mapper = new ObjectMapper();
+    List<ChangeDetectionDto.PolygonFeature> result =
+        list.stream()
+            .map(
+                data -> {
+                  String geoJson = data.getGeometry();
+                  JsonNode jsonNode;
+                  try {
+                    jsonNode = mapper.readTree(geoJson);
+                  } catch (JsonProcessingException e) {
+                    throw new RuntimeException(e);
+                  }
+
+                  ChangeDetectionDto.PolygonProperties properties =
+                      new ChangeDetectionDto.PolygonProperties(
+                          data.getGeoUid(),
+                          data.getArea(),
+                          data.getBeforeYear(),
+                          data.getBeforeConfidence(),
+                          data.getBeforeClass(),
+                          data.getAfterYear(),
+                          data.getAfterConfidence(),
+                          data.getAfterClass(),
+                          data.getCdProb(),
+                          data.getUuid(),
+                          data.getResultUid());
+
+                  return new ChangeDetectionDto.PolygonFeature(
+                      data.getType(), jsonNode, properties);
+                })
+            .collect(Collectors.toList());
+
+    ChangeDetectionDto.PolygonFeatureList polygonList = new ChangeDetectionDto.PolygonFeatureList();
+    polygonList.setType("FeatureCollection");
+    polygonList.setFeatures(result);
+    return polygonList;
+  }
+
+  @Override
+  public PointFeatureList getSelectedChangeDetectionPointListByPnu(String chnDtctId, String pnu) {
+    BooleanBuilder builder = new BooleanBuilder();
+    builder.and(mapSheetLearnEntity.uid.eq(chnDtctId));
+    builder.and(pnuEntity.pnu.eq(pnu));
+
+    List<ChangeDetectionDto.PointQueryData> list =
+        queryFactory
+            .select(
+                Projections.constructor(
+                    ChangeDetectionDto.PointQueryData.class,
+                    Expressions.stringTemplate("{0}", "Feature"),
+                    Expressions.stringTemplate(
+                        "ST_AsGeoJSON({0})",
+                        mapSheetAnalDataInferenceGeomEntity.geomCenter), // point
+                    Projections.constructor(
+                        ChangeDetectionDto.PointProperties.class,
+                        mapSheetAnalDataInferenceGeomEntity.geoUid,
+                        mapSheetAnalDataInferenceGeomEntity.classAfterCd.toUpperCase())))
+            .from(mapSheetAnalDataInferenceGeomEntity)
+            .innerJoin(mapSheetAnalDataInferenceEntity)
+            .on(mapSheetAnalDataInferenceGeomEntity.dataUid.eq(mapSheetAnalDataInferenceEntity.id))
+            .innerJoin(mapSheetAnalInferenceEntity)
+            .on(mapSheetAnalInferenceEntity.id.eq(mapSheetAnalDataInferenceEntity.analUid))
+            .innerJoin(mapSheetLearnEntity)
+            .on(mapSheetLearnEntity.id.eq(mapSheetAnalInferenceEntity.learnId))
+            .innerJoin(pnuEntity.geo, mapSheetAnalDataInferenceGeomEntity)
+            .where(builder)
+            .fetch();
+
+    ObjectMapper mapper = new ObjectMapper();
+    List<ChangeDetectionDto.PointFeature> result =
+        list.stream()
+            .map(
+                data -> {
+                  String geoJson = data.getGeometry();
+                  JsonNode jsonNode;
+                  try {
+                    jsonNode = mapper.readTree(geoJson);
+                  } catch (JsonProcessingException e) {
+                    throw new RuntimeException(e);
+                  }
+
+                  return new ChangeDetectionDto.PointFeature(
+                      data.getType(), jsonNode, data.getProperties());
+                })
+            .collect(Collectors.toList());
+
+    return new ChangeDetectionDto.PointFeatureList("FeatureCollection", result);
+  }
+
+  @Override
+  public Optional<UUID> getLearnUuid(String chnDtctId) {
+    return Optional.ofNullable(
+        queryFactory
+            .select(mapSheetAnalInferenceEntity.uuid)
+            .from(mapSheetLearnEntity)
+            .innerJoin(mapSheetAnalInferenceEntity)
+            .on(mapSheetAnalInferenceEntity.learnId.eq(mapSheetLearnEntity.id))
+            .where(mapSheetLearnEntity.uid.eq(chnDtctId))
+            .fetchOne());
+  }
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/gukyuin/GukYuinLabelJobRepository.java

@@ -0,0 +1,7 @@
+package com.kamco.cd.kamcoback.postgres.repository.gukyuin;
+
+import com.kamco.cd.kamcoback.postgres.entity.MapSheetLearnEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface GukYuinLabelJobRepository
+    extends JpaRepository<MapSheetLearnEntity, Long>, GukYuinLabelJobRepositoryCustom {}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/gukyuin/GukYuinLabelJobRepositoryCustom.java

@@ -0,0 +1,12 @@
+package com.kamco.cd.kamcoback.postgres.repository.gukyuin;
+
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.GeomUidDto;
+import java.time.LocalDate;
+import java.util.List;
+
+public interface GukYuinLabelJobRepositoryCustom {
+
+  List<GeomUidDto> findYesterdayLabelingCompleteList(LocalDate baseDate);
+
+  void updateAnalDataInferenceGeomSendDttm(Long geoUid);
+}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/gukyuin/GukYuinLabelJobRepositoryImpl.java

@@ -0,0 +1,77 @@
+package com.kamco.cd.kamcoback.postgres.repository.gukyuin;
+
+import static com.kamco.cd.kamcoback.postgres.entity.QLabelingAssignmentEntity.labelingAssignmentEntity;
+import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataInferenceGeomEntity.mapSheetAnalDataInferenceGeomEntity;
+import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalInferenceEntity.mapSheetAnalInferenceEntity;
+import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetLearnEntity.mapSheetLearnEntity;
+
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.GeomUidDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinStatus;
+import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.InspectState;
+import com.querydsl.core.types.Projections;
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@RequiredArgsConstructor
+public class GukYuinLabelJobRepositoryImpl implements GukYuinLabelJobRepositoryCustom {
+
+  private final JPAQueryFactory queryFactory;
+  @PersistenceContext private EntityManager em;
+
+  @Override
+  public List<GeomUidDto> findYesterdayLabelingCompleteList(LocalDate baseDate) {
+    ZoneId zone = ZoneId.of("Asia/Seoul");
+
+    // baseDate가 null이면 기존처럼 "어제"로 처리
+    LocalDate targetDate =
+        (baseDate != null) ? baseDate : ZonedDateTime.now(zone).toLocalDate().minusDays(1);
+
+    ZonedDateTime targetStart = targetDate.atStartOfDay(zone);
+    ZonedDateTime nextStart = targetStart.plusDays(1);
+
+    BooleanExpression inTargetDay =
+        labelingAssignmentEntity
+            .inspectStatDttm
+            .goe(targetStart)
+            .and(labelingAssignmentEntity.inspectStatDttm.lt(nextStart));
+
+    return queryFactory
+        .select(
+            Projections.constructor(
+                GeomUidDto.class,
+                labelingAssignmentEntity.inferenceGeomUid,
+                mapSheetAnalDataInferenceGeomEntity.resultUid))
+        .from(labelingAssignmentEntity)
+        .innerJoin(mapSheetAnalDataInferenceGeomEntity)
+        .on(
+            labelingAssignmentEntity.inferenceGeomUid.eq(
+                mapSheetAnalDataInferenceGeomEntity.geoUid))
+        .innerJoin(mapSheetAnalInferenceEntity)
+        .on(labelingAssignmentEntity.analUid.eq(mapSheetAnalInferenceEntity.id))
+        .innerJoin(mapSheetLearnEntity)
+        .on(
+            mapSheetAnalInferenceEntity.learnId.eq(mapSheetLearnEntity.id),
+            mapSheetLearnEntity.applyStatus.in(
+                GukYuinStatus.GUK_COMPLETED.getId(), GukYuinStatus.PNU_COMPLETED.getId()))
+        .where(labelingAssignmentEntity.inspectState.eq(InspectState.COMPLETE.getId()), inTargetDay)
+        .fetch();
+  }
+
+  @Override
+  public void updateAnalDataInferenceGeomSendDttm(Long geoUid) {
+    queryFactory
+        .update(mapSheetAnalDataInferenceGeomEntity)
+        .set(mapSheetAnalDataInferenceGeomEntity.labelSendDttm, ZonedDateTime.now())
+        .where(mapSheetAnalDataInferenceGeomEntity.geoUid.eq(geoUid))
+        .execute();
+  }
+}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/gukyuin/GukYuinPnuJobRepository.java

@@ -0,0 +1,7 @@
+package com.kamco.cd.kamcoback.postgres.repository.gukyuin;
+
+import com.kamco.cd.kamcoback.postgres.entity.MapSheetLearnEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface GukYuinPnuJobRepository
+    extends JpaRepository<MapSheetLearnEntity, Long>, GukYuinPnuJobRepositoryCustom {}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/gukyuin/GukYuinPnuJobRepositoryCustom.java

@@ -0,0 +1,20 @@
+package com.kamco.cd.kamcoback.postgres.repository.gukyuin;
+
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LearnKeyDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinStatus;
+import java.util.List;
+
+public interface GukYuinPnuJobRepositoryCustom {
+
+  void updateInferenceGeomDataPnuCnt(String chnDtctObjtId, long pnuCnt);
+
+  Long findMapSheetAnalDataInferenceGeomUid(String chnDtctObjtId);
+
+  void insertGeoUidPnuData(Long geoUid, String[] pnuList, String chnDtctObjtId);
+
+  void updateGukYuinApplyStateComplete(Long id, GukYuinStatus status);
+
+  List<LearnKeyDto> findGukyuinApplyStatusUidList(List<String> gukYuinStatus);
+
+  long upsertMapSheetDataAnalGeomPnu(String uid, String[] pnuList);
+}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/gukyuin/GukYuinPnuJobRepositoryImpl.java

@@ -0,0 +1,123 @@
+package com.kamco.cd.kamcoback.postgres.repository.gukyuin;
+
+import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataInferenceGeomEntity.mapSheetAnalDataInferenceGeomEntity;
+import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetLearnEntity.mapSheetLearnEntity;
+import static com.kamco.cd.kamcoback.postgres.entity.QPnuEntity.pnuEntity;
+
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LearnKeyDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinStatus;
+import com.kamco.cd.kamcoback.postgres.entity.PnuEntity;
+import com.querydsl.core.types.Projections;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.transaction.Transactional;
+import java.time.ZonedDateTime;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@RequiredArgsConstructor
+public class GukYuinPnuJobRepositoryImpl implements GukYuinPnuJobRepositoryCustom {
+
+  private final JPAQueryFactory queryFactory;
+  @PersistenceContext private EntityManager em;
+
+  @Override
+  public void updateInferenceGeomDataPnuCnt(String chnDtctObjtId, long pnuCnt) {
+    queryFactory
+        .update(mapSheetAnalDataInferenceGeomEntity)
+        .set(mapSheetAnalDataInferenceGeomEntity.pnu, pnuCnt)
+        .where(mapSheetAnalDataInferenceGeomEntity.resultUid.eq(chnDtctObjtId))
+        .execute();
+  }
+
+  @Override
+  public Long findMapSheetAnalDataInferenceGeomUid(String chnDtctObjtId) {
+    return queryFactory
+        .select(mapSheetAnalDataInferenceGeomEntity.geoUid)
+        .from(mapSheetAnalDataInferenceGeomEntity)
+        .where(mapSheetAnalDataInferenceGeomEntity.resultUid.eq(chnDtctObjtId))
+        .fetchOne();
+  }
+
+  @Override
+  public void insertGeoUidPnuData(Long geoUid, String[] pnuList, String chnDtctObjtId) {
+    for (String pnu : pnuList) {
+      PnuEntity entity =
+          queryFactory
+              .selectFrom(pnuEntity)
+              .where(pnuEntity.pnu.eq(pnu), pnuEntity.chnDtctObjtId.eq(chnDtctObjtId))
+              .fetchOne();
+      if (entity == null) {
+        queryFactory
+            .insert(pnuEntity)
+            .columns(
+                pnuEntity.geo.geoUid, pnuEntity.pnu, pnuEntity.createdDttm, pnuEntity.chnDtctObjtId)
+            .values(geoUid, pnu, ZonedDateTime.now(), chnDtctObjtId)
+            .execute();
+      }
+    }
+  }
+
+  @Override
+  public List<LearnKeyDto> findGukyuinApplyStatusUidList(List<String> status) {
+    return queryFactory
+        .select(
+            Projections.constructor(
+                LearnKeyDto.class,
+                mapSheetLearnEntity.id,
+                mapSheetLearnEntity.uid,
+                mapSheetLearnEntity.chnDtctMstId))
+        .from(mapSheetLearnEntity)
+        .where(mapSheetLearnEntity.applyStatus.in(status))
+        .fetch();
+  }
+
+  @Override
+  public long upsertMapSheetDataAnalGeomPnu(String chnDtctObjtId, String[] pnuList) {
+    long length = pnuList.length;
+    queryFactory
+        .update(mapSheetAnalDataInferenceGeomEntity)
+        .set(mapSheetAnalDataInferenceGeomEntity.pnu, length)
+        .where(mapSheetAnalDataInferenceGeomEntity.resultUid.eq(chnDtctObjtId))
+        .execute();
+
+    Long geoUid =
+        queryFactory
+            .select(mapSheetAnalDataInferenceGeomEntity.geoUid)
+            .from(mapSheetAnalDataInferenceGeomEntity)
+            .where(mapSheetAnalDataInferenceGeomEntity.resultUid.eq(chnDtctObjtId))
+            .fetchOne();
+
+    long succCnt = 0;
+    for (String pnu : pnuList) {
+      long result =
+          queryFactory
+              .insert(pnuEntity)
+              .columns(
+                  pnuEntity.geo.geoUid,
+                  pnuEntity.pnu,
+                  pnuEntity.createdDttm,
+                  pnuEntity.chnDtctObjtId)
+              .values(geoUid, pnu, ZonedDateTime.now(), chnDtctObjtId)
+              .execute();
+      if (result > 0) {
+        succCnt++;
+      }
+    }
+    return succCnt;
+  }
+
+  @Override
+  @Transactional
+  public void updateGukYuinApplyStateComplete(Long id, GukYuinStatus status) {
+    queryFactory
+        .update(mapSheetLearnEntity)
+        .set(mapSheetLearnEntity.applyStatus, status.getId())
+        .set(mapSheetLearnEntity.applyStatusDttm, ZonedDateTime.now())
+        .where(mapSheetLearnEntity.id.eq(id))
+        .execute();
+  }
+}

src/main/java/com/kamco/cd/kamcoback/postgres/repository/gukyuin/GukYuinRepositoryCustom.java

@@ -1,21 +1,48 @@
 package com.kamco.cd.kamcoback.postgres.repository.gukyuin;
 
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.Basic;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LabelSendDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.LearnKeyDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.GeomUidDto;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinDto.LearnInfo;
+import com.kamco.cd.kamcoback.gukyuin.dto.GukYuinStatus;
+import java.time.LocalDate;
 import java.util.List;
+import java.util.UUID;
 
 public interface GukYuinRepositoryCustom {
 
   void updateGukYuinMastRegResult(Basic resultBody);
 
-  void updateGukYuinMastRegRemove(Basic resultBody);
+  void updateGukYuinMastRegRemove(String chnDtctId);
 
   void updateInferenceGeomDataPnuCnt(String chnDtctObjtId, long pnuCnt);
 
   Long findMapSheetAnalDataInferenceGeomUid(String chnDtctObjtId);
 
-  void insertGeoUidPnuData(Long geoUid, String[] pnuList);
+  void insertGeoUidPnuData(Long geoUid, String[] pnuList, String chnDtctObjtId);
 
-  List<String> findGukyuinApplyIngUidList();
+  void updateGukYuinApplyStateComplete(Long id, GukYuinStatus status);
 
-  void updateGukYuinApplyStateComplete(String uid);
+  List<LearnKeyDto> findGukyuinApplyStatusUidList(List<String> gukYuinStatus);
+
+  long upsertMapSheetDataAnalGeomPnu(String uid, String[] pnuList);
+
+  LearnInfo findMapSheetLearnInfo(UUID uuid);
+
+  Integer findMapSheetLearnYearStage(Integer compareYyyy, Integer targetYyyy);
+
+  void updateAnalInferenceApplyDttm(Basic registRes);
+
+  List<GeomUidDto> findYesterdayLabelingCompleteList();
+
+  void updateAnalDataInferenceGeomSendDttm(Long geoUid);
+
+  List<LabelSendDto> findLabelingCompleteSendList(LocalDate yesterday);
+
+  Long findMapSheetLearnInfoByYyyy(Integer compareYyyy, Integer targetYyyy, Integer maxStage);
+
+  void updateMapSheetLearnGukyuinEndStatus(Long learnId);
+
+  void updateMapSheetInferenceLabelEndStatus(Long learnId);
 }