Merge pull request 'feat/infer_dev_260211' (#80) from feat/infer_dev_260211 into develop

Reviewed-on: #80

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,10 +15,6 @@ services:
       - SPRING_PROFILES_ACTIVE=dev
       - TZ=Asia/Seoul
     volumes:
-      - /mnt/nfs_share/images:/app/original-images
-      - /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

docker-compose-prod.yml

@@ -0,0 +1,50 @@
+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:
+    build:
+      context: .
+      dockerfile: Dockerfile-prod
+      args:
+        UID: 1000        # manager01 UID
+        GID: 1000        # manager01 GID
+    image: kamco-cd-api:${IMAGE_TAG:-latest}
+    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/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/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);
   }
 
@@ -57,6 +60,7 @@ public class ExternalJarRunner {
     addArg(args, "upload-shp", register);
     //    addArg(args, "layer", layer);
 
+    addArg(args, "spring.profiles.active", profile);
     execJar(jarPath, args);
   }
 

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", "");
-    MenuDto.Basic basic =
-        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) {
+    publisher.publishEvent(
-    if (request.getUserPrincipal() instanceof UsernamePasswordAuthenticationToken auth
+        new DownloadAuditEvent(userId, uri, normalizedUri, ip, status, downloadUuid));
-        && auth.getPrincipal() instanceof CustomUserDetails userDetails) {
-      return userDetails.getMember().getId();
   }
+
+  private UUID extractUuidFromUri(String uri) {
+    try {
+      String[] parts = uri.split("/");
+      String last = parts[parts.length - 1];
+      return UUID.fromString(last);
+    } catch (Exception e) {
       return null;
     }
   }
+}

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,21 +71,33 @@ 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",
@@ -90,24 +106,21 @@ public class SecurityConfig {
                         "/api/layer/tile-url",
                         "/api/layer/tile-url-year")
                     .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();
   }
@@ -118,23 +131,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/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/dto/ChngDetectContDto.java

@@ -137,4 +137,15 @@ public class ChngDetectContDto {
     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

@@ -247,45 +247,45 @@ public class ChngDetectMastDto {
   @AllArgsConstructor
   public static class RlbDtctMastDto {
 
-    private String pnuDtctId;
+    private String pnuDtctId; // PNU탐지ID
-    private String pnu;
+    private String pnu; // PNU코드(19자리)
-    private String lrmSyncYmd;
+    private String lrmSyncYmd; // 지적도동기화일자(YYYYMMDD)
-    private String pnuSyncYmd;
+    private String pnuSyncYmd; // PNU동기화일자(YYYYMMDD)
-    private String mpqdNo; // 도엽번호
+    private String mpqdNo; // 도곽번호
     private String cprsYr; // 비교년도
     private String crtrYr; // 기준년도
-    private String chnDtctSno; // 회차
+    private String chnDtctSno; // 회차, 변화탐지순번
-    private String chnDtctId;
+    private String chnDtctId; // 변화탐지ID(UUID)
 
-    private String chnDtctMstId;
+    private String chnDtctMstId; // 변화탐지마스터ID
-    private String chnDtctObjtId;
+    private String chnDtctObjtId; // 변화탐지객체ID
-    private String chnDtctContId;
+    private String chnDtctContId; // 변화탐지내용ID
-    private String chnCd;
+    private String chnCd; // 변화코드
-    private String chnDtctProb;
+    private String chnDtctProb; // 변화탐지정확도(0~1)
 
     private String bfClsCd; // 이전분류코드
-    private String bfClsProb; // 이전분류정확도
+    private String bfClsProb; // 이전분류정확도(0~1)
     private String afClsCd; // 이후분류코드
-    private String afClsProb; // 이후분류정확도
+    private String afClsProb; // 이후분류정확도(0~1)
 
-    private String pnuSqms;
+    private String pnuSqms; // PNU면적(㎡)
-    private String pnuDtctSqms;
+    private String pnuDtctSqms; // PNU탐지면적(㎡)
-    private String chnDtctSqms;
+    private String chnDtctSqms; // 변화탐지면적(㎡)
-    private String stbltYn;
+    private String stbltYn; // 적합여부(Y/N) - 안정성 (Y:부적합, N:적합)
-    private String incyCd;
+    private String incyCd; // 부적합코드
-    private String incyRsnCont;
+    private String incyRsnCont; // 부적합사유내용
-    private String lockYn;
+    private String lockYn; // 잠금여부(Y/N)
-    private String lblYn;
+    private String lblYn; // 라벨여부(Y/N)
-    private String chgYn;
+    private String chgYn; // 변경여부(Y/N)
-    private String rsatctNo;
+    private String rsatctNo; // 부동산등기번호
-    private String rmk;
+    private String rmk; // 비고
 
     private String crtDt; // 생성일시
     private String crtEpno; // 생성사원번호
     private String crtIp; // 생성사원아이피
-    private String chgDt;
+    private String chgDt; // 변경일시
-    private String chgEpno;
+    private String chgEpno; // 변경자사번
-    private String chgIp;
+    private String chgIp; // 변경자IP
     private String delYn; // 삭제여부
   }
 

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

@@ -452,20 +452,15 @@ public class GukYuinApiService {
       return new ResponseObj(ApiResponseCode.DUPLICATE_DATA, "이미 국유인 연동을 한 회차입니다.");
     }
 
+    if (!Files.isDirectory(Path.of("/kamco-nfs/dataset/export/" + info.getUid()))) {
+      return new ResponseObj(
+          ApiResponseCode.NOT_FOUND_DATA, "파일 경로에 회차 실행 파일이 생성되지 않았습니다. 확인 부탁드립니다.");
+    }
+
     // 비교년도,기준년도로 전송한 데이터 있는지 확인 후 회차 번호 생성
     Integer maxStage =
         gukyuinCoreService.findMapSheetLearnYearStage(info.getCompareYyyy(), info.getTargetYyyy());
 
-    // 1회차를 종료 상태로 처리하고 2회차를 보내야 함
-    // 추론(learn), 학습데이터(inference) 둘 다 종료 처리
-    if (maxStage > 0) {
-      Long learnId =
-          gukyuinCoreService.findMapSheetLearnInfoByYyyy(
-              info.getCompareYyyy(), info.getTargetYyyy(), maxStage);
-      gukyuinCoreService.updateMapSheetLearnGukyuinEndStatus(learnId);
-      gukyuinCoreService.updateMapSheetInferenceLabelEndStatus(learnId);
-    }
-
     // reqDto 셋팅
     ChnDetectMastReqDto reqDto = new ChnDetectMastReqDto();
     reqDto.setCprsYr(String.valueOf(info.getCompareYyyy()));
@@ -474,9 +469,14 @@ public class GukYuinApiService {
     reqDto.setChnDtctId(info.getUid());
     reqDto.setPathNm("/kamco-nfs/dataset/export/" + info.getUid());
 
-    if (!Files.isDirectory(Path.of("/kamco-nfs/dataset/export/" + info.getUid()))) {
+    // 1회차를 종료 상태로 처리하고 2회차를 보내야 함
-      return new ResponseObj(
+    // 추론(learn), 학습데이터(inference) 둘 다 종료 처리
-          ApiResponseCode.NOT_FOUND_DATA, "파일 경로에 회차 실행 파일이 생성되지 않았습니다. 확인 부탁드립니다.");
+    if (maxStage > 0) {
+      Long learnId =
+          gukyuinCoreService.findMapSheetLearnInfoByYyyy(
+              info.getCompareYyyy(), info.getTargetYyyy(), maxStage);
+      gukyuinCoreService.updateMapSheetLearnGukyuinEndStatus(learnId);
+      gukyuinCoreService.updateMapSheetInferenceLabelEndStatus(learnId);
     }
 
     // 국유인 /chn/mast/regist 전송

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(
@@ -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);
+  @Operation(summary = "shp 파일 다운로드 이력 조회", description = "추론관리 분석결과 shp 파일 다운로드 이력 조회")
-
-    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 파일 다운로드 이력")
   @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/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/service/InferenceResultService.java

@@ -248,7 +248,7 @@ public class InferenceResultService {
     saveInferenceAiDto.setUuid(uuid);
     saveInferenceAiDto.setBatchId(batchId);
     saveInferenceAiDto.setStatus(Status.IN_PROGRESS.getId());
-    saveInferenceAiDto.setType("M1");
+    saveInferenceAiDto.setType("G1");
     saveInferenceAiDto.setInferStartDttm(ZonedDateTime.now());
     saveInferenceAiDto.setModelComparePath(modelComparePath.getFilePath());
     saveInferenceAiDto.setModelTargetPath(modelTargetPath.getFilePath());
@@ -414,9 +414,9 @@ public class InferenceResultService {
 
     String modelType = "";
 
-    if (modelInfo.getModelType().equals(ModelType.M1.getId())) {
+    if (modelInfo.getModelType().equals(ModelType.G1.getId())) {
       modelType = "G1";
-    } else if (modelInfo.getModelType().equals(ModelType.M2.getId())) {
+    } else if (modelInfo.getModelType().equals(ModelType.G2.getId())) {
       modelType = "G2";
     } else {
       modelType = "G3";

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,34 @@ 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.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 +52,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 +352,110 @@ 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));
+  }
 }

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

@@ -359,4 +359,15 @@ 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;
+  }
 }

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

@@ -16,25 +16,28 @@ 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.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 +276,30 @@ 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);
+  }
 }

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

@@ -31,6 +31,9 @@ public class LayerDto {
     @Schema(description = "uuid")
     private UUID uuid;
 
+    @Schema(description = "레이어명")
+    private String layerName;
+
     @Schema(example = "WMTS", description = "유형 (TILE/GEOJSON/WMTS/WMS)")
     private String layerType;
 
@@ -63,6 +66,9 @@ public class LayerDto {
     @Schema(description = "uuid")
     private UUID uuid;
 
+    @Schema(description = "레이어명")
+    private String layerName;
+
     @Schema(description = "유형 (TILE/GEOJSON/WMTS/WMS)")
     private String layerType;
 
@@ -119,6 +125,9 @@ public class LayerDto {
   @Schema(name = "LayerAddReq")
   public static class AddReq {
 
+    @Schema(description = "레이어명")
+    private String layerName;
+
     @Schema(description = "title WMS, WMTS 선택한 tile")
     private String title;
 
@@ -215,6 +224,9 @@ public class LayerDto {
   @Schema(name = "LayerMapDto")
   public static class LayerMapDto {
 
+    @Schema(description = "레이어명")
+    private String layerName;
+
     @Schema(example = "WMTS", description = "유형 (TILE/GEOJSON/WMTS/WMS)")
     private String layerType;
 
@@ -268,6 +280,7 @@ public class LayerDto {
     private String crs;
 
     public LayerMapDto(
+        String layerName,
         String layerType,
         String tag,
         Long sortOrder,
@@ -282,6 +295,7 @@ public class LayerDto {
         UUID uuid,
         String rawJsonString,
         String crs) {
+      this.layerName = layerName;
       this.layerType = layerType;
       this.tag = tag;
       this.sortOrder = sortOrder;

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/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/service/LayerService.java

@@ -9,7 +9,6 @@ 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;
@@ -79,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);
       }
 
@@ -89,6 +89,7 @@ public class LayerService {
         addDto.setDescription(dto.getDescription());
         addDto.setTitle(dto.getTitle());
         addDto.setTag(dto.getTag());
+        addDto.setLayerName(dto.getLayerName());
         return mapLayerCoreService.saveWms(addDto);
       }
 
@@ -165,24 +166,6 @@ public class LayerService {
     return wmsService.getTile();
   }
 
-  /**
-   * wms 저장
-   *
-   * @param dto
-   * @return
-   */
-  @Transactional
-  public UUID saveWms(WmsAddReqDto dto) {
-    // 선택한 tile 상세정보 조회
-    WmsLayerInfo info = wmsService.getDetail(dto.getTitle());
-    WmsAddDto addDto = new WmsAddDto();
-    addDto.setWmsLayerInfo(info);
-    addDto.setDescription(dto.getDescription());
-    addDto.setTitle(dto.getTitle());
-    addDto.setTag(dto.getTag());
-    return mapLayerCoreService.saveWms(addDto);
-  }
-
   public List<LayerMapDto> findLayerMapList(String type) {
     List<LayerMapDto> layerMapDtoList = mapLayerCoreService.findLayerMapList(type);
     layerMapDtoList.forEach(

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

@@ -134,7 +134,6 @@ public class MapSheetMngService {
     }
 
     MngDto mngDto = mapSheetMngCoreService.findMapSheetMng(errDto.getMngYyyy());
-    String targetYearDir = mngDto.getMngPath();
 
     // 중복체크 -> 도엽50k/uuid 경로에 업로드 할 거라 overwrite 되지 않음
     //    if (!overwrite) {

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/GukYuinStbltJobCoreService.java

@@ -1,5 +1,6 @@
 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;
@@ -24,13 +25,10 @@ public class GukYuinStbltJobCoreService {
 
   @Transactional
   public void updateGukYuinEligibleForSurvey(String resultUid, RlbDtctMastDto stbltDto) {
-    String chnDtctObjtId = "";
     PnuEntity entity =
         gukYuinStbltRepository.findPnuEntityByResultUid(resultUid, stbltDto.getPnu());
 
     if (entity != null) {
-      chnDtctObjtId = resultUid;
-
       entity.setPnuDtctId(stbltDto.getPnuDtctId());
       entity.setPnu(stbltDto.getPnu());
       entity.setLrmSyncYmd(stbltDto.getLrmSyncYmd());
@@ -68,8 +66,11 @@ public class GukYuinStbltJobCoreService {
 
       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

@@ -110,7 +110,7 @@ public class InferenceResultCoreService {
 
     MapSheetLearnEntity mapSheetLearnEntity = new MapSheetLearnEntity();
     mapSheetLearnEntity.setTitle(req.getTitle());
-    mapSheetLearnEntity.setRunningModelType("M1");
+    mapSheetLearnEntity.setRunningModelType("G1");
     mapSheetLearnEntity.setM1ModelUuid(req.getModel1Uuid());
     mapSheetLearnEntity.setM2ModelUuid(req.getModel2Uuid());
     mapSheetLearnEntity.setM3ModelUuid(req.getModel3Uuid());
@@ -301,7 +301,7 @@ public class InferenceResultCoreService {
 
   private void applyModelUpdate(MapSheetLearnEntity entity, SaveInferenceAiDto request) {
     switch (request.getType()) {
-      case "M1" ->
+      case "G1" ->
           applyModelFields(
               request,
               entity::setM1ModelBatchId,
@@ -311,7 +311,7 @@ public class InferenceResultCoreService {
               entity::setM1RunningJobs,
               entity::setM1CompletedJobs,
               entity::setM1FailedJobs);
-      case "M2" ->
+      case "G2" ->
           applyModelFields(
               request,
               entity::setM2ModelBatchId,
@@ -321,7 +321,7 @@ public class InferenceResultCoreService {
               entity::setM2RunningJobs,
               entity::setM2CompletedJobs,
               entity::setM2FailedJobs);
-      case "M3" ->
+      case "G3" ->
           applyModelFields(
               request,
               entity::setM3ModelBatchId,

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,34 @@ 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));
+  }
 }

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

@@ -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());
     }
@@ -213,6 +217,7 @@ public class MapLayerCoreService {
     Long order = mapLayerRepository.findSortOrderDesc();
 
     MapLayerEntity mapLayerEntity = new MapLayerEntity();
+    mapLayerEntity.setLayerName(dto.getLayerName());
     mapLayerEntity.setDescription(dto.getDescription());
     mapLayerEntity.setUrl(dto.getUrl());
     mapLayerEntity.setTag(dto.getTag());
@@ -243,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());
@@ -273,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());
@@ -305,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());

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/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;
 
@@ -109,6 +113,7 @@ public class MapLayerEntity {
   public LayerDto.Detail toDto() {
     return new LayerDto.Detail(
         this.uuid,
+        this.layerName,
         this.layerType,
         this.title,
         this.description,

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/gukyuin/GukYuinStbltJobRepositoryCustom.java

@@ -1,5 +1,6 @@
 package com.kamco.cd.kamcoback.postgres.repository.gukyuin;
 
+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;
@@ -12,4 +13,6 @@ public interface GukYuinStbltJobRepositoryCustom {
   void updateGukYuinEligibleForSurvey(String resultUid, RlbDtctMastDto stbltDto);
 
   PnuEntity findPnuEntityByResultUid(String resultUid, String pnu);
+
+  void updateGukYuinObjectStbltYn(String resultUid, StbltResult stbResult);
 }

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

@@ -7,6 +7,7 @@ import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetLearnEntity.mapShe
 import static com.kamco.cd.kamcoback.postgres.entity.QPnuEntity.pnuEntity;
 
 import com.kamco.cd.kamcoback.common.enums.ImageryFitStatus;
+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.gukyuin.dto.GukYuinStatus;
@@ -90,4 +91,19 @@ public class GukYuinStbltJobRepositoryImpl implements GukYuinStbltJobRepositoryC
         .where(pnuEntity.pnu.eq(pnu), pnuEntity.chnDtctObjtId.eq(resultUid))
         .fetchOne();
   }
+
+  @Override
+  public void updateGukYuinObjectStbltYn(String resultUid, StbltResult stbResult) {
+    queryFactory
+        .update(mapSheetAnalDataInferenceGeomEntity)
+        .set(
+            mapSheetAnalDataInferenceGeomEntity.fitState,
+            stbResult.getStbltYn().equals("Y")
+                ? ImageryFitStatus.UNFIT.getId()
+                : ImageryFitStatus.FIT.getId()) // 적합여부가 Y 이면 부적합인 것, N 이면 적합한 것이라고 함
+        .set(mapSheetAnalDataInferenceGeomEntity.fitStateDttm, ZonedDateTime.now())
+        .set(mapSheetAnalDataInferenceGeomEntity.fitStateCmmnt, stbResult.getIncyCmnt())
+        .where(mapSheetAnalDataInferenceGeomEntity.resultUid.eq(resultUid))
+        .execute();
+  }
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/label/LabelAllocateRepositoryCustom.java

@@ -3,6 +3,7 @@ package com.kamco.cd.kamcoback.postgres.repository.label;
 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.LabelerDetail;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelingStatDto;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.MoveInfo;
@@ -15,6 +16,7 @@ import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.WorkerStatistics;
 import com.kamco.cd.kamcoback.postgres.entity.LabelingAssignmentEntity;
 import java.time.LocalDate;
 import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
 import org.springframework.data.domain.Page;
 
@@ -104,4 +106,8 @@ public interface LabelAllocateRepositoryCustom {
   void updateAnalInferenceMngState(UUID uuid, String status);
 
   Long findLabelingIngProcessCnt();
+
+  InferenceLearnDto findLabelingIngProcessId(UUID uuid);
+
+  Optional<String> findLearnUid(UUID uuid);
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/label/LabelAllocateRepositoryImpl.java

@@ -6,6 +6,7 @@ import static com.kamco.cd.kamcoback.postgres.entity.QLabelingLabelerEntity.labe
 import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataInferenceEntity.mapSheetAnalDataInferenceEntity;
 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 static com.kamco.cd.kamcoback.postgres.entity.QMemberEntity.memberEntity;
 
 import com.kamco.cd.kamcoback.common.enums.ImageryFitStatus;
@@ -13,6 +14,7 @@ import com.kamco.cd.kamcoback.common.enums.StatusType;
 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.InspectState;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelMngState;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelState;
@@ -49,6 +51,7 @@ import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -1824,4 +1827,33 @@ public class LabelAllocateRepositoryImpl implements LabelAllocateRepositoryCusto
                 LabelMngState.ASSIGNED.getId(), LabelMngState.ING.getId()))
         .fetchOne();
   }
+
+  @Override
+  public InferenceLearnDto findLabelingIngProcessId(UUID uuid) {
+    return queryFactory
+        .select(
+            Projections.constructor(
+                InferenceLearnDto.class,
+                mapSheetAnalInferenceEntity.uuid,
+                mapSheetLearnEntity.uid,
+                mapSheetAnalInferenceEntity.analState,
+                mapSheetAnalInferenceEntity.id))
+        .from(mapSheetLearnEntity)
+        .join(mapSheetAnalInferenceEntity)
+        .on(mapSheetAnalInferenceEntity.learnId.eq(mapSheetLearnEntity.id))
+        .where(mapSheetAnalInferenceEntity.uuid.eq(uuid))
+        .fetchOne();
+  }
+
+  @Override
+  public Optional<String> findLearnUid(UUID uuid) {
+    return Optional.ofNullable(
+        queryFactory
+            .select(mapSheetLearnEntity.uid)
+            .from(mapSheetLearnEntity)
+            .innerJoin(mapSheetAnalInferenceEntity)
+            .on(mapSheetAnalInferenceEntity.learnId.eq(mapSheetLearnEntity.id))
+            .where(mapSheetAnalInferenceEntity.uuid.eq(uuid))
+            .fetchOne());
+  }
 }

src/main/java/com/kamco/cd/kamcoback/postgres/repository/label/LabelWorkRepositoryImpl.java

@@ -134,20 +134,16 @@ public class LabelWorkRepositoryImpl implements LabelWorkRepositoryCustom {
               .and(mapSheetAnalDataInferenceGeomEntity.labelStateDttm.lt(end)));
     }
 
-    // labelTotCnt: pnu가 있고 pass_yn = false (부적합)인 건수만 라벨링 대상
+    // labelTotCnt: pnu가 있고 fitState = UNFIT 인 건수만 라벨링 대상
     NumberExpression<Long> labelTotCntExpr =
         new CaseBuilder()
             .when(
                 mapSheetAnalDataInferenceGeomEntity
                     .pnu
-                    .isNotNull()
+                    .gt(0)
                     .and(
-                        mapSheetAnalDataInferenceGeomEntity.pnu
+                        mapSheetAnalDataInferenceGeomEntity.fitState.eq(
-                            .isNotNull()) // TODO: 이노팸 연동 후 0 이상이라고 해야할 듯
+                            ImageryFitStatus.UNFIT.getId())))
-                //
-                // .and(mapSheetAnalDataInferenceGeomEntity.passYn.eq(Boolean.FALSE))  //TODO: 추후
-                // 라벨링 대상 조건 수정하기
-                )
             .then(1L)
             .otherwise(0L)
             .sum();
@@ -201,7 +197,7 @@ public class LabelWorkRepositoryImpl implements LabelWorkRepositoryCustom {
                     new CaseBuilder()
                         .when(
                             mapSheetAnalDataInferenceGeomEntity.labelState.eq(
-                                LabelState.DONE.getId())) // "LABEL_COMPLETE"?
+                                LabelState.DONE.getId()))
                         .then(1L)
                         .otherwise(0L)
                         .sum(),

src/main/java/com/kamco/cd/kamcoback/postgres/repository/layer/MapLayerRepositoryImpl.java

@@ -46,6 +46,7 @@ public class MapLayerRepositoryImpl implements MapLayerRepositoryCustom {
       if (searchReq.getTag() != null) {
         whereBuilder.and(mapLayerEntity.tag.toLowerCase().eq(searchReq.getTag().toLowerCase()));
       }
+
       if (searchReq.getLayerType() != null) {
         whereBuilder.and(
             mapLayerEntity.layerType.toLowerCase().eq(searchReq.getLayerType().toLowerCase()));
@@ -57,6 +58,7 @@ public class MapLayerRepositoryImpl implements MapLayerRepositoryCustom {
             Projections.constructor(
                 LayerDto.Basic.class,
                 mapLayerEntity.uuid,
+                mapLayerEntity.layerName,
                 mapLayerEntity.layerType,
                 mapLayerEntity.description,
                 mapLayerEntity.tag,
@@ -101,6 +103,7 @@ public class MapLayerRepositoryImpl implements MapLayerRepositoryCustom {
         .select(
             Projections.constructor(
                 LayerMapDto.class,
+                mapLayerEntity.layerName,
                 mapLayerEntity.layerType,
                 mapLayerEntity.tag,
                 mapLayerEntity.order,

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

@@ -168,13 +168,13 @@ public class AuditLogRepositoryImpl extends QuerydslRepositorySupport
     whereBuilder.and(auditLogEntity.eventStatus.ne(EventStatus.valueOf("FAILED")));
     whereBuilder.and(auditLogEntity.eventType.eq(EventType.valueOf("DOWNLOAD")));
 
-    if (req.getMenuId() != null && !req.getMenuId().isEmpty()) {
+    //    if (req.getMenuId() != null && !req.getMenuId().isEmpty()) {
-      whereBuilder.and(auditLogEntity.menuUid.eq(req.getMenuId()));
+    //      whereBuilder.and(auditLogEntity.menuUid.eq(req.getMenuId()));
-    }
+    //    }
 
     if (req.getUuid() != null) {
-      whereBuilder.and(auditLogEntity.requestUri.contains("/api/inference/download/"));
+      whereBuilder.and(auditLogEntity.requestUri.contains(req.getRequestUri()));
-      whereBuilder.and(auditLogEntity.requestUri.endsWith(String.valueOf(req.getUuid())));
+      whereBuilder.and(auditLogEntity.downloadUuid.eq(req.getUuid()));
     }
 
     if (req.getSearchValue() != null && !req.getSearchValue().isEmpty()) {

src/main/java/com/kamco/cd/kamcoback/postgres/repository/scheduler/TrainingDataReviewJobRepositoryImpl.java

@@ -7,6 +7,7 @@ import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetLearnEntity.mapShe
 
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.InspectState;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelMngState;
+import com.kamco.cd.kamcoback.model.dto.ModelMngDto.ModelType;
 import com.kamco.cd.kamcoback.postgres.entity.LabelingAssignmentEntity;
 import com.kamco.cd.kamcoback.scheduler.dto.TrainingDataReviewJobDto.AnalCntInfo;
 import com.kamco.cd.kamcoback.scheduler.dto.TrainingDataReviewJobDto.AnalMapSheetList;
@@ -58,10 +59,10 @@ public class TrainingDataReviewJobRepositoryImpl extends QuerydslRepositorySuppo
                     Properties.class,
                     new CaseBuilder()
                         .when(mapSheetLearnDataGeomEntity.classAfterCd.in("building", "container"))
-                        .then("M1")
+                        .then(ModelType.G1.getId())
                         .when(mapSheetLearnDataGeomEntity.classAfterCd.eq("waste"))
-                        .then("M2")
+                        .then(ModelType.G2.getId())
-                        .otherwise("M3"),
+                        .otherwise(ModelType.G3.getId()),
                     mapSheetLearnDataGeomEntity.classBeforeCd,
                     mapSheetLearnDataGeomEntity.classAfterCd)))
         .from(labelingAssignmentEntity)

src/main/java/com/kamco/cd/kamcoback/postgres/repository/trainingdata/TrainingDataLabelRepositoryImpl.java

@@ -10,6 +10,7 @@ import static com.kamco.cd.kamcoback.postgres.entity.QPnuEntity.pnuEntity;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.kamco.cd.kamcoback.common.enums.DetectionClassification;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelMngState;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelState;
 import com.kamco.cd.kamcoback.postgres.entity.LabelingAssignmentEntity;
@@ -305,6 +306,10 @@ public class TrainingDataLabelRepositoryImpl extends QuerydslRepositorySupport
             queryFactory
                 .select(labelingAssignmentEntity.count())
                 .from(labelingAssignmentEntity)
+                .innerJoin(mapSheetAnalInferenceEntity)
+                .on(
+                    labelingAssignmentEntity.analUid.eq(mapSheetAnalInferenceEntity.id),
+                    mapSheetAnalInferenceEntity.analState.ne(LabelMngState.FINISH.getId()))
                 .where(labelingAssignmentEntity.workerUid.eq(userId))
                 .fetchOne();
 
@@ -325,6 +330,10 @@ public class TrainingDataLabelRepositoryImpl extends QuerydslRepositorySupport
             queryFactory
                 .select(labelingAssignmentEntity.count())
                 .from(labelingAssignmentEntity)
+                .innerJoin(mapSheetAnalInferenceEntity)
+                .on(
+                    labelingAssignmentEntity.analUid.eq(mapSheetAnalInferenceEntity.id),
+                    mapSheetAnalInferenceEntity.analState.ne(LabelMngState.FINISH.getId()))
                 .where(
                     labelingAssignmentEntity.workerUid.eq(userId),
                     labelingAssignmentEntity.workState.eq("ASSIGNED"))
@@ -353,6 +362,10 @@ public class TrainingDataLabelRepositoryImpl extends QuerydslRepositorySupport
             queryFactory
                 .select(labelingAssignmentEntity.count())
                 .from(labelingAssignmentEntity)
+                .innerJoin(mapSheetAnalInferenceEntity)
+                .on(
+                    labelingAssignmentEntity.analUid.eq(mapSheetAnalInferenceEntity.id),
+                    mapSheetAnalInferenceEntity.analState.ne(LabelMngState.FINISH.getId()))
                 .where(
                     labelingAssignmentEntity.workerUid.eq(userId),
                     labelingAssignmentEntity.workState.in(
@@ -492,6 +505,9 @@ public class TrainingDataLabelRepositoryImpl extends QuerydslRepositorySupport
                           mapSheetAnalDataInferenceGeomEntityEntity.getClassBeforeCd() != null
                               ? mapSheetAnalDataInferenceGeomEntityEntity.getClassBeforeCd()
                               : "")
+                      .classificationName(
+                          DetectionClassification.fromStrDesc(
+                              mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterCd()))
                       .probability(
                           mapSheetAnalDataInferenceGeomEntityEntity.getClassBeforeProb() != null
                               ? mapSheetAnalDataInferenceGeomEntityEntity.getClassBeforeProb()
@@ -503,6 +519,9 @@ public class TrainingDataLabelRepositoryImpl extends QuerydslRepositorySupport
                           mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterCd() != null
                               ? mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterCd()
                               : "")
+                      .classificationName(
+                          DetectionClassification.fromStrDesc(
+                              mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterCd()))
                       .probability(
                           mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterProb() != null
                               ? mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterProb()
@@ -524,12 +543,17 @@ public class TrainingDataLabelRepositoryImpl extends QuerydslRepositorySupport
               .build();
 
       var inspectionResultInfo =
-          InspectionResultInfo.builder()
+          queryFactory
-              .verificationResult(convertInspectState(assignment.toDto().getInspectState()))
+              .select(
-              .inappropriateReason("")
+                  Projections.constructor(
-              //        .memo(assignment.toDto().getInspectMemo() != null ?
+                      InspectionResultInfo.class,
-              // assignment.toDto().getInspectMemo() : "")
+                      mapSheetAnalDataInferenceGeomEntity.fitState,
-              .build();
+                      mapSheetAnalDataInferenceGeomEntity.fitStateCmmnt))
+              .from(mapSheetAnalDataInferenceGeomEntity)
+              .where(
+                  mapSheetAnalDataInferenceGeomEntity.geoUid.eq(
+                      mapSheetAnalDataInferenceGeomEntityEntity.getGeoUid()))
+              .fetchOne();
 
       // 6. Geometry를 GeoJSON으로 변환
       InferenceDataGeometry inferData =

src/main/java/com/kamco/cd/kamcoback/postgres/repository/trainingdata/TrainingDataReviewRepositoryImpl.java

@@ -11,6 +11,7 @@ import static com.kamco.cd.kamcoback.postgres.entity.QPnuEntity.pnuEntity;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.kamco.cd.kamcoback.common.enums.DetectionClassification;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.InspectState;
 import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelMngState;
 import com.kamco.cd.kamcoback.postgres.entity.LabelingAssignmentEntity;
@@ -24,7 +25,6 @@ import com.kamco.cd.kamcoback.trainingdata.dto.TrainingDataReviewDto.DetailRes;
 import com.kamco.cd.kamcoback.trainingdata.dto.TrainingDataReviewDto.GeoFeatureRequest.Properties;
 import com.kamco.cd.kamcoback.trainingdata.dto.TrainingDataReviewDto.InferenceDataGeometry;
 import com.kamco.cd.kamcoback.trainingdata.dto.TrainingDataReviewDto.InferenceDataGeometry.InferenceProperties;
-import com.kamco.cd.kamcoback.trainingdata.dto.TrainingDataReviewDto.InspectionResultInfo;
 import com.kamco.cd.kamcoback.trainingdata.dto.TrainingDataReviewDto.LearnDataGeometry;
 import com.kamco.cd.kamcoback.trainingdata.dto.TrainingDataReviewDto.LearnDataGeometry.LearnProperties;
 import com.kamco.cd.kamcoback.trainingdata.dto.TrainingDataReviewDto.ReviewGeometryInfo;
@@ -314,6 +314,10 @@ public class TrainingDataReviewRepositoryImpl extends QuerydslRepositorySupport
             queryFactory
                 .select(labelingAssignmentEntity.count())
                 .from(labelingAssignmentEntity)
+                .innerJoin(mapSheetAnalInferenceEntity)
+                .on(
+                    labelingAssignmentEntity.analUid.eq(mapSheetAnalInferenceEntity.id),
+                    mapSheetAnalInferenceEntity.analState.ne(LabelMngState.FINISH.getId()))
                 .where(labelingAssignmentEntity.inspectorUid.eq(userId))
                 .fetchOne();
 
@@ -334,6 +338,10 @@ public class TrainingDataReviewRepositoryImpl extends QuerydslRepositorySupport
             queryFactory
                 .select(labelingAssignmentEntity.count())
                 .from(labelingAssignmentEntity)
+                .innerJoin(mapSheetAnalInferenceEntity)
+                .on(
+                    labelingAssignmentEntity.analUid.eq(mapSheetAnalInferenceEntity.id),
+                    mapSheetAnalInferenceEntity.analState.ne(LabelMngState.FINISH.getId()))
                 .where(
                     labelingAssignmentEntity.inspectorUid.eq(userId),
                     labelingAssignmentEntity.inspectState.eq("UNCONFIRM"))
@@ -362,6 +370,10 @@ public class TrainingDataReviewRepositoryImpl extends QuerydslRepositorySupport
             queryFactory
                 .select(labelingAssignmentEntity.count())
                 .from(labelingAssignmentEntity)
+                .innerJoin(mapSheetAnalInferenceEntity)
+                .on(
+                    labelingAssignmentEntity.analUid.eq(mapSheetAnalInferenceEntity.id),
+                    mapSheetAnalInferenceEntity.analState.ne(LabelMngState.FINISH.getId()))
                 .where(
                     labelingAssignmentEntity.inspectorUid.eq(userId),
                     labelingAssignmentEntity.inspectState.in("COMPLETE", "EXCEPT"),
@@ -483,7 +495,7 @@ public class TrainingDataReviewRepositoryImpl extends QuerydslRepositorySupport
               queryFactory
                   .select(memberEntity.name)
                   .from(memberEntity)
-                  .where(memberEntity.userId.eq(assignment.toDto().getWorkerUid()))
+                  .where(memberEntity.employeeNo.eq(assignment.toDto().getWorkerUid()))
                   .fetchFirst();
           if (workerName == null) {
             workerName = "";
@@ -520,6 +532,9 @@ public class TrainingDataReviewRepositoryImpl extends QuerydslRepositorySupport
                           mapSheetAnalDataInferenceGeomEntityEntity.getClassBeforeCd() != null
                               ? mapSheetAnalDataInferenceGeomEntityEntity.getClassBeforeCd()
                               : "")
+                      .classificationName(
+                          DetectionClassification.fromStrDesc(
+                              mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterCd()))
                       .probability(
                           mapSheetAnalDataInferenceGeomEntityEntity.getClassBeforeProb() != null
                               ? mapSheetAnalDataInferenceGeomEntityEntity.getClassBeforeProb()
@@ -531,6 +546,9 @@ public class TrainingDataReviewRepositoryImpl extends QuerydslRepositorySupport
                           mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterCd() != null
                               ? mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterCd()
                               : "")
+                      .classificationName(
+                          DetectionClassification.fromStrDesc(
+                              mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterCd()))
                       .probability(
                           mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterProb() != null
                               ? mapSheetAnalDataInferenceGeomEntityEntity.getClassAfterProb()
@@ -553,11 +571,17 @@ public class TrainingDataReviewRepositoryImpl extends QuerydslRepositorySupport
               .build();
 
       var inspectionResultInfo =
-          InspectionResultInfo.builder()
+          queryFactory
-              .verificationResult(convertInspectState(assignment.toDto().getInspectState()))
+              .select(
-              .inappropriateReason("")
+                  Projections.constructor(
-              .memo("")
+                      TrainingDataReviewDto.InspectionResultInfo.class,
-              .build();
+                      mapSheetAnalDataInferenceGeomEntity.fitState,
+                      mapSheetAnalDataInferenceGeomEntity.fitStateCmmnt))
+              .from(mapSheetAnalDataInferenceGeomEntity)
+              .where(
+                  mapSheetAnalDataInferenceGeomEntity.geoUid.eq(
+                      mapSheetAnalDataInferenceGeomEntityEntity.getGeoUid()))
+              .fetchOne();
 
       // 6. Geometry를 GeoJSON으로 변환
       InferenceDataGeometry inferData =

src/main/java/com/kamco/cd/kamcoback/scheduler/TRAINING_DATA_GEOJSON_QUERY.sql

@@ -60,10 +60,10 @@ select msldge1_0.geo_uid,
        st_asgeojson(msldge1_0.geom),
        case
          when (msldge1_0.class_after_cd in ('building', 'container'))
-           then cast('M1' as varchar)
+           then cast('G1' as varchar)
          when (msldge1_0.class_after_cd = 'waste')
-           then cast('M2' as varchar)
+           then cast('G2' as varchar)
-         else 'M3'
+         else 'G3'
          end,
        msldge1_0.class_before_cd,
        msldge1_0.class_after_cd

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

@@ -20,4 +20,15 @@ public class AsyncConfig {
     ex.initialize();
     return ex;
   }
+
+  @Bean(name = "auditLogExecutor")
+  public Executor auditLogExecutor() {
+    ThreadPoolTaskExecutor exec = new ThreadPoolTaskExecutor();
+    exec.setCorePoolSize(2);
+    exec.setMaxPoolSize(8);
+    exec.setQueueCapacity(2000);
+    exec.setThreadNamePrefix("auditlog-");
+    exec.initialize();
+    return exec;
+  }
 }

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

@@ -1,5 +1,6 @@
 package com.kamco.cd.kamcoback.scheduler.service;
 
+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.RlbDtctDto;
 import com.kamco.cd.kamcoback.gukyuin.dto.ChngDetectMastDto.RlbDtctMastDto;
@@ -10,6 +11,8 @@ import java.time.LocalDate;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
 import org.springframework.beans.factory.annotation.Value;
@@ -37,7 +40,7 @@ public class GukYuinApiStbltJobService {
   }
 
   /** 국유인 연동 후, 실태조사 적합여부 확인하여 update */
-  @Scheduled(cron = "0 0 3 * * *") // 0 0 3 * * *
+  @Scheduled(cron = "0 0 3 * * *")
   public void findGukYuinEligibleForSurvey() {
     if (isLocalProfile()) {
       return;
@@ -68,6 +71,42 @@ public class GukYuinApiStbltJobService {
           gukYuinStbltJobCoreService.updateGukYuinEligibleForSurvey(resultUid, stbltDto);
         }
 
+        Map<String, StbltResult> resultMap =
+            result.getResult().stream()
+                .collect(Collectors.groupingBy(RlbDtctMastDto::getChnDtctObjtId))
+                .entrySet()
+                .stream()
+                .collect(
+                    Collectors.toMap(
+                        Map.Entry::getKey,
+                        e -> {
+                          List<RlbDtctMastDto> pnuList = e.getValue();
+
+                          boolean hasY = pnuList.stream().anyMatch(v -> "Y".equals(v.getStbltYn()));
+
+                          String fitYn = hasY ? "Y" : "N";
+
+                          RlbDtctMastDto selected =
+                              hasY
+                                  ? pnuList.stream()
+                                      .filter(v -> "Y".equals(v.getStbltYn()))
+                                      .findFirst()
+                                      .orElse(null)
+                                  : pnuList.stream()
+                                      .filter(v -> "N".equals(v.getStbltYn()))
+                                      .findFirst()
+                                      .orElse(null);
+
+                          if (selected == null) {
+                            return null; // 방어 코드
+                          }
+
+                          return new StbltResult(
+                              fitYn, selected.getIncyCd(), selected.getIncyRsnCont());
+                        }));
+
+        resultMap.forEach(gukYuinStbltJobCoreService::updateGukYuinObjectStbltYn);
+
       } catch (Exception e) {
         log.error("[GUKYUIN] failed uid={}", dto.getChnDtctMstId(), e);
       }

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

@@ -122,7 +122,7 @@ public class MapSheetInferenceJobService {
    * @return
    */
   private Long resolveBatchId(InferenceBatchSheet sheet) {
-    // M3 > M2 > M1
+    // G3 > G2 > G1
     if (sheet.getM3BatchId() != null) {
       return sheet.getM3BatchId();
     }
@@ -216,12 +216,12 @@ public class MapSheetInferenceJobService {
     updateProcessingEndTimeByModel(job, sheet.getUuid(), now, currentType);
 
     // M3이면 전체 종료
-    if ("M3".equals(currentType)) {
+    if ("G3".equals(currentType)) {
       endAll(sheet, now);
       return;
     }
 
-    // 다음 모델 실행 (M1->M2, M2->M3)
+    // 다음 모델 실행 (G1->G2, G2->G3)
     String nextType = nextModelType(currentType);
     UUID nextModelUuid = resolveModelUuid(sheet, nextType);
 
@@ -240,7 +240,7 @@ public class MapSheetInferenceJobService {
     save.setUuid(sheet.getUuid());
     save.setStatus(Status.END.getId());
     save.setInferEndDttm(now);
-    save.setType("M3"); // 마지막 모델 기준
+    save.setType("G3"); // 마지막 모델 기준
     inferenceResultCoreService.update(save);
 
     // 추론 종료일때 geom 데이터 저장
@@ -266,11 +266,11 @@ public class MapSheetInferenceJobService {
    * @return
    */
   private String nextModelType(String currentType) {
-    if ("M1".equals(currentType)) {
+    if ("G1".equals(currentType)) {
-      return "M2";
+      return "G2";
     }
-    if ("M2".equals(currentType)) {
+    if ("G2".equals(currentType)) {
-      return "M3";
+      return "G3";
     }
     throw new IllegalArgumentException("Unknown runningModelType: " + currentType);
   }
@@ -283,13 +283,13 @@ public class MapSheetInferenceJobService {
    * @return
    */
   private UUID resolveModelUuid(InferenceBatchSheet sheet, String type) {
-    if ("M1".equals(type)) {
+    if ("G1".equals(type)) {
       return sheet.getM1ModelUuid();
     }
-    if ("M2".equals(type)) {
+    if ("G2".equals(type)) {
       return sheet.getM2ModelUuid();
     }
-    if ("M3".equals(type)) {
+    if ("G3".equals(type)) {
       return sheet.getM3ModelUuid();
     }
     throw new IllegalArgumentException("Unknown type: " + type);
@@ -379,13 +379,13 @@ public class MapSheetInferenceJobService {
    * @return String
    */
   private String modelToInferenceType(String type) {
-    if ("M1".equals(type)) {
+    if ("G1".equals(type)) {
       return "G1";
     }
-    if ("M2".equals(type)) {
+    if ("G2".equals(type)) {
       return "G2";
     }
-    if ("M3".equals(type)) {
+    if ("G3".equals(type)) {
       return "G3";
     }
     throw new IllegalArgumentException("Unknown type: " + type);

src/main/java/com/kamco/cd/kamcoback/trainingdata/dto/TrainingDataLabelDto.java

@@ -6,6 +6,7 @@ import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.kamco.cd.kamcoback.common.enums.ImageryFitStatus;
 import com.kamco.cd.kamcoback.common.utils.geometry.GeometryDeserializer;
 import io.swagger.v3.oas.annotations.media.Schema;
 import java.util.List;
@@ -372,9 +373,12 @@ public class TrainingDataLabelDto {
   @AllArgsConstructor
   public static class ClassificationInfo {
 
-    @Schema(description = "분류", example = "일반토지")
+    @Schema(description = "분류", example = "land")
     private String classification;
 
+    @Schema(description = "분류 한글명", example = "일반토지")
+    private String classificationName;
+
     @Schema(description = "확률", example = "80.0")
     private Double probability;
   }
@@ -382,9 +386,7 @@ public class TrainingDataLabelDto {
   @Schema(name = "InspectionResultInfo", description = "실태조사결과정보")
   @Getter
   @Setter
-  @Builder
   @NoArgsConstructor
-  @AllArgsConstructor
   public static class InspectionResultInfo {
 
     @Schema(description = "검증결과 (미확인/제외/완료)", example = "미확인")
@@ -395,6 +397,11 @@ public class TrainingDataLabelDto {
 
     @Schema(description = "메모")
     private String memo;
+
+    public InspectionResultInfo(String verificationResult, String inappropriateReason) {
+      this.verificationResult = ImageryFitStatus.fromCode(verificationResult).getText();
+      this.inappropriateReason = inappropriateReason;
+    }
   }
 
   @Schema(name = "SummaryRes", description = "작업 통계 응답")

src/main/java/com/kamco/cd/kamcoback/trainingdata/dto/TrainingDataReviewDto.java

@@ -6,6 +6,7 @@ import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.kamco.cd.kamcoback.common.enums.ImageryFitStatus;
 import com.kamco.cd.kamcoback.common.utils.geometry.GeometryDeserializer;
 import io.swagger.v3.oas.annotations.media.Schema;
 import java.util.List;
@@ -368,9 +369,12 @@ public class TrainingDataReviewDto {
   @AllArgsConstructor
   public static class ClassificationInfo {
 
-    @Schema(description = "분류", example = "일반토지")
+    @Schema(description = "분류", example = "land")
     private String classification;
 
+    @Schema(description = "분류한글명", example = "일반토지")
+    private String classificationName;
+
     @Schema(description = "확률", example = "80.0")
     private Double probability;
   }
@@ -378,9 +382,7 @@ public class TrainingDataReviewDto {
   @Schema(name = "InspectionResultInfo", description = "실태조사결과정보")
   @Getter
   @Setter
-  @Builder
   @NoArgsConstructor
-  @AllArgsConstructor
   public static class InspectionResultInfo {
 
     @Schema(description = "검증결과 (미확인/제외/완료)", example = "미확인")
@@ -391,6 +393,11 @@ public class TrainingDataReviewDto {
 
     @Schema(description = "메모")
     private String memo;
+
+    public InspectionResultInfo(String verificationResult, String inappropriateReason) {
+      this.verificationResult = ImageryFitStatus.fromCode(verificationResult).getText();
+      this.inappropriateReason = inappropriateReason;
+    }
   }
 
   @Schema(name = "SummaryRes", description = "작업 통계 응답")

src/main/java/com/kamco/cd/kamcoback/upload/UploadApiController.java

@@ -29,27 +29,12 @@ public class UploadApiController {
 
   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;
-
   /*
     @Operation(summary = "데이터셋 대용량 업로드 세션 시작", description = "데이터셋 대용량 파일 업로드 세션을 시작합니다.")
     @ApiResponses(

src/main/resources/application-dev.yml

@@ -16,6 +16,10 @@ spring:
         format_sql: true                  # ⚠️ 선택 - SQL 포맷팅 (가독성)
         jdbc:
           batch_size: 1000           # ✅ 추가 (JDBC batch)
+    open-in-view: false
+  mvc:
+    async:
+      request-timeout: 300s   # 5분 (예: 30s, 120s, 10m 등도 가능)
 
   datasource:
     url: jdbc:postgresql://192.168.2.127:15432/kamco_cds
@@ -83,35 +87,38 @@ mapsheet:
   upload:
     skipGdalValidation: true
   shp:
-    baseurl: /app/tmp/detect/result
+    baseurl: /app/tmp/detect/result  #현재사용안함
 
 
 
 file:
   #sync-root-dir: D:/kamco-nfs/images/
   sync-root-dir: /kamco-nfs/images/
-  sync-tmp-dir: ${file.sync-root-dir}/tmp
+  sync-tmp-dir: /kamco-nfs/requests/temp              # image upload temp dir
+  #sync-tmp-dir: ${file.sync-root-dir}/tmp
   sync-file-extention: tfw,tif
   sync-auto-exception-start-year: 2024
   sync-auto-exception-before-year-cnt: 3
 
-  #dataset-dir: D:/kamco-nfs/dataset/
+  #dataset-dir: D:/kamco-nfs/model_output/
-  dataset-dir: /kamco-nfs/dataset/export/
+  dataset-dir: /kamco-nfs/model_output/export/        # 마운트경로 AI 추론결과
   dataset-tmp-dir: ${file.dataset-dir}tmp/
 
   #model-dir: D:/kamco-nfs/ckpt/model/
-  model-dir: /kamco-nfs/ckpt/model/
+  model-dir: /kamco-nfs/ckpt/model/                   # 학습서버에서 트레이닝한 모델업로드경로
   model-tmp-dir: ${file.model-dir}tmp/
   model-file-extention: pth,json,py
 
   pt-path: /kamco-nfs/ckpt/model/v6-cls-checkpoints/
   pt-FileName: yolov8_6th-6m.pt
 
+  dataset-response: /kamco-nfs/dataset/response/
+
 inference:
   url: http://192.168.2.183:8000/jobs
   batch-url: http://192.168.2.183:8000/batches
-  geojson-dir: /kamco-nfs/requests/
+  geojson-dir: /kamco-nfs/requests/                   # 추론실행을 위한 파일생성경로
-  jar-path: /kamco-nfs/dataset/shp/shp-exporter.jar
+  jar-path: /kamco-nfs/repo/jar/shp-exporter.jar
   inference-server-name: server1,server2,server3,server4
 
 gukyuin:
@@ -120,10 +127,12 @@ gukyuin:
   cdi: ${gukyuin.url}/api/kcd/cdi
 
 training-data:
-  geojson-dir: /kamco-nfs/model_output/labeling/
+  geojson-dir: /kamco-nfs/dataset/request/
 
 layer:
   geoserver-url: https://kamco.geo-dev.gs.dabeeo.com
   wms-path: geoserver/cd
   wmts-path: geoserver/cd/gwc/service
   workspace: cd
+
+

src/main/resources/application-prod.yml

@@ -18,12 +18,38 @@ spring:
           batch_size: 1000           # ✅ 추가 (JDBC batch)
 
   datasource:
-    url: jdbc:postgresql://10.100.0.10:25432/temp
+    url: jdbc:postgresql://kamco-cd-postgis:5432/kamco_cds
-    username: temp
+    #url: jdbc:postgresql://localhost:15432/kamco_cds
-    password: temp123!
+    username: kamco_cds
+    password: kamco_cds_Q!W@E#R$
     hikari:
       minimum-idle: 10
       maximum-pool-size: 20
+      connection-timeout: 60000        # 60초 연결 타임아웃
+      idle-timeout: 300000            # 5분 유휴 타임아웃
+      max-lifetime: 1800000           # 30분 최대 수명
+      leak-detection-threshold: 60000  # 연결 누수 감지
+
+  transaction:
+    default-timeout: 300              # 5분 트랜잭션 타임아웃
+
+  data:
+    redis:
+      host: 127.0.0.1
+      port: 16379
+      password: kamco
+
+  servlet:
+    multipart:
+      enabled: true
+      max-file-size: 4GB
+      max-request-size: 4GB
+      file-size-threshold: 10MB
+
+server:
+  tomcat:
+    max-swallow-size: 4GB
+    max-http-form-post-size: 4GB
 
 jwt:
   secret: "kamco_token_9b71e778-19a3-4c1d-97bf-2d687de17d5b"
@@ -34,28 +60,39 @@ token:
   refresh-cookie-name: kamco   # 개발용 쿠키 이름
   refresh-cookie-secure: true   # 로컬 http 테스트면 false
 
+logging:
+  level:
+    root: INFO
+    org.springframework.web: INFO
+    org.springframework.security: INFO
+
+    # 헬스체크 노이즈 핵심만 다운
+    org.springframework.security.web.FilterChainProxy: INFO
+    org.springframework.security.web.authentication.AnonymousAuthenticationFilter: INFO
+    org.springframework.security.web.authentication.Http403ForbiddenEntryPoint: INFO
+    org.springframework.web.servlet.DispatcherServlet: INFO
+
+
 mapsheet:
   upload:
     skipGdalValidation: true
   shp:
-    baseurl: /app/detect/result
+    baseurl: /app/detect/result #현재사용안함
-
-
 
 file:
   #sync-root-dir: D:/kamco-nfs/images/
   sync-root-dir: /kamco-nfs/images/
-  sync-tmp-dir: ${file.sync-root-dir}/tmp
+  sync-tmp-dir: ${file.sync-root-dir}/tmp       # image upload temp dir
   sync-file-extention: tfw,tif
   sync-auto-exception-start-year: 2025
   sync-auto-exception-before-year-cnt: 3
 
-  #dataset-dir: D:/kamco-nfs/dataset/
+  #dataset-dir: D:/kamco-nfs/model_output/ #변경 model_output
-  dataset-dir: /kamco-nfs/dataset/export/
+  dataset-dir: /kamco-nfs/model_output/export/  # 마운트경로 AI 추론결과
   dataset-tmp-dir: ${file.dataset-dir}tmp/
 
   #model-dir: D:/kamco-nfs/ckpt/model/
-  model-dir: /kamco-nfs/ckpt/model/
+  model-dir: /kamco-nfs/ckpt/model/             # 학습서버에서 트레이닝한 모델업로드경로
   model-tmp-dir: ${file.model-dir}tmp/
   model-file-extention: pth,json,py
 
@@ -63,19 +100,18 @@ file:
   pt-FileName: yolov8_6th-6m.pt
 
 inference:
-  url: http://192.168.2.183:8000/jobs
+  url: http://127.0.0.1:8000/jobs
-  batch-url: http://192.168.2.183:8000/batches
+  batch-url: http://127.0.0.1:8000/batches
-  geojson-dir: /kamco-nfs/requests/
+  geojson-dir: /kamco-nfs/requests/                 # 학습서버에서 트레이닝한 모델업로드경로
-  jar-path: /kamco-nfs/dataset/shp/shp-exporter.jar
+  jar-path: /kamco-nfs/repo/jar/shp-exporter.jar    # 추론실행을 위한 파일생성경로
   inference-server-name: server1,server2,server3,server4
 
 gukyuin:
-  #url:  http://localhost:8080
+  url: http://127.0.0.1:5301
-  url: http://192.168.2.129:5301
   cdi: ${gukyuin.url}/api/kcd/cdi
 
 training-data:
-  geojson-dir: /kamco-nfs/model_output/labeling/
+  geojson-dir: /kamco-nfs/dataset/request/
 
 layer:
   geoserver-url: https://kamco.geo-dev.gs.dabeeo.com

src/main/resources/application-prod.yml_bak

@@ -0,0 +1,120 @@
+spring:
+  config:
+    activate:
+      on-profile: prod
+
+  jpa:
+    show-sql: true
+    hibernate:
+      ddl-auto: validate
+    properties:
+      hibernate:
+        default_batch_fetch_size: 100     # ✅ 성능 - N+1 쿼리 방지
+        order_updates: true               # ✅ 성능 - 업데이트 순서 정렬로 데드락 방지
+        order_inserts: true
+        use_sql_comments: true            # ⚠️ 선택 - SQL에 주석 추가 (디버깅용)
+        format_sql: true                  # ⚠️ 선택 - SQL 포맷팅 (가독성)
+        jdbc:
+          batch_size: 1000           # ✅ 추가 (JDBC batch)
+
+  datasource:
+    url: jdbc:postgresql://kamco-cd-postgis:5432/kamco_cds
+    #url: jdbc:postgresql://localhost:15432/kamco_cds
+    username: kamco_cds
+    password: kamco_cds_Q!W@E#R$
+    hikari:
+      minimum-idle: 10
+      maximum-pool-size: 20
+      connection-timeout: 60000        # 60초 연결 타임아웃
+      idle-timeout: 300000            # 5분 유휴 타임아웃
+      max-lifetime: 1800000           # 30분 최대 수명
+      leak-detection-threshold: 60000  # 연결 누수 감지
+
+  transaction:
+    default-timeout: 300              # 5분 트랜잭션 타임아웃
+
+  data:
+    redis:
+      host: 127.0.0.1
+      port: 16379
+      password: kamco
+
+  servlet:
+    multipart:
+      enabled: true
+      max-file-size: 4GB
+      max-request-size: 4GB
+      file-size-threshold: 10MB
+
+server:
+  tomcat:
+    max-swallow-size: 4GB
+    max-http-form-post-size: 4GB
+
+jwt:
+  secret: "kamco_token_9b71e778-19a3-4c1d-97bf-2d687de17d5b"
+  access-token-validity-in-ms: 86400000      # 1일
+  refresh-token-validity-in-ms: 604800000    # 7일
+
+token:
+  refresh-cookie-name: kamco   # 개발용 쿠키 이름
+  refresh-cookie-secure: true   # 로컬 http 테스트면 false
+
+logging:
+  level:
+    root: INFO
+    org.springframework.web: INFO
+    org.springframework.security: INFO
+
+    # 헬스체크 노이즈 핵심만 다운
+    org.springframework.security.web.FilterChainProxy: INFO
+    org.springframework.security.web.authentication.AnonymousAuthenticationFilter: INFO
+    org.springframework.security.web.authentication.Http403ForbiddenEntryPoint: INFO
+    org.springframework.web.servlet.DispatcherServlet: INFO
+
+
+mapsheet:
+  upload:
+    skipGdalValidation: true
+  shp:
+    baseurl: /app/detect/result #현재사용안함
+
+file:
+  #sync-root-dir: D:/kamco-nfs/images/
+  sync-root-dir: /kamco-nfs/images/
+  sync-tmp-dir: ${file.sync-root-dir}/tmp       # image upload temp dir
+  sync-file-extention: tfw,tif
+  sync-auto-exception-start-year: 2025
+  sync-auto-exception-before-year-cnt: 3
+
+  #dataset-dir: D:/kamco-nfs/model_output/ #변경 model_output
+  dataset-dir: /kamco-nfs/model_output/export/  # 마운트경로 AI 추론결과
+  dataset-tmp-dir: ${file.dataset-dir}tmp/
+
+  #model-dir: D:/kamco-nfs/ckpt/model/
+  model-dir: /kamco-nfs/ckpt/model/             # 학습서버에서 트레이닝한 모델업로드경로
+  model-tmp-dir: ${file.model-dir}tmp/
+  model-file-extention: pth,json,py
+
+  pt-path: /kamco-nfs/ckpt/model/v6-cls-checkpoints/
+  pt-FileName: yolov8_6th-6m.pt
+
+inference:
+  url: http://127.0.0.1:8000/jobs
+  batch-url: http://127.0.0.1:8000/batches
+  geojson-dir: /kamco-nfs/requests/                 # 학습서버에서 트레이닝한 모델업로드경로
+  jar-path: /kamco-nfs/repo/jar/shp-exporter.jar    # 추론실행을 위한 파일생성경로
+  inference-server-name: server1,server2,server3,server4
+
+gukyuin:
+  url: http://127.0.0.1:5301
+  cdi: ${gukyuin.url}/api/kcd/cdi
+
+training-data:
+  geojson-dir: /kamco-nfs/dataset/request/
+
+layer:
+  geoserver-url: https://kamco.geo-dev.gs.dabeeo.com
+  wms-path: geoserver/cd
+  wmts-path: geoserver/cd/gwc/service
+  workspace: cd

src/main/resources/static/download_progress_test.html

@@ -0,0 +1,83 @@
+<!doctype html>
+<html lang="ko">
+<head>
+  <meta charset="utf-8" />
+  <title>라벨 ZIP 다운로드</title>
+</head>
+<body>
+<h3>라벨 ZIP 다운로드</h3>
+
+UUID:
+<input id="uuid" value="6d8d49dc-0c9d-4124-adc7-b9ca610cc394" />
+<br><br>
+
+JWT Token:
+<input id="token" style="width:600px;" placeholder="Bearer 토큰 붙여넣기" />
+<br><br>
+
+<button onclick="download()">다운로드</button>
+
+<br><br>
+<progress id="bar" value="0" max="100" style="width:400px;"></progress>
+<div id="status"></div>
+
+<script>
+  async function download() {
+    const uuid = document.getElementById("uuid").value.trim();
+    const token = document.getElementById("token").value.trim();
+
+    if (!uuid) {
+      alert("UUID 입력하세요");
+      return;
+    }
+
+    if (!token) {
+      alert("토큰 입력하세요");
+      return;
+    }
+
+    const url = `/api/training-data/stage/download/${uuid}`;
+
+    const res = await fetch(url, {
+      headers: {
+        "Authorization": token.startsWith("Bearer ")
+          ? token
+          : `Bearer ${token}`,
+        "kamco-download-uuid": uuid
+      }
+    });
+
+    if (!res.ok) {
+      document.getElementById("status").innerText =
+        "실패: " + res.status;
+      return;
+    }
+
+    const total = parseInt(res.headers.get("Content-Length") || "0", 10);
+    const reader = res.body.getReader();
+    const chunks = [];
+    let received = 0;
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      received += value.length;
+
+      if (total) {
+        document.getElementById("bar").value =
+          (received / total) * 100;
+      }
+    }
+
+    const blob = new Blob(chunks);
+    const a = document.createElement("a");
+    a.href = URL.createObjectURL(blob);
+    a.download = uuid + ".zip";
+    a.click();
+
+    document.getElementById("status").innerText = "완료 ✅";
+  }
+</script>
+</body>
+</html>