Build with DisasterGPT

package com.disastergpt.dto;

import com.fasterxml.jackson.annotation.JsonAlias;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;

public class ReportRequest {

    private String templateId = "기상상황보고";
    private String baseDatetime;   // "2026-03-29 22:00"
    private String airforceForecast = "";

    @JsonProperty("template_id") @JsonAlias("templateId")
    public String getTemplateId() { return templateId; }
    public void setTemplateId(String v) { this.templateId = v; }

    @JsonProperty("base_datetime") @JsonAlias("baseDatetime")
    public String getBaseDatetime() { return baseDatetime; }
    public void setBaseDatetime(String v) { this.baseDatetime = v; }

    @JsonProperty("airforce_forecast") @JsonAlias("airforceForecast")
    public String getAirforceForecast() { return airforceForecast; }
    public void setAirforceForecast(String v) { this.airforceForecast = v; }
}

package com.disastergpt.dto;

import com.fasterxml.jackson.annotation.JsonAlias;
import com.fasterxml.jackson.annotation.JsonProperty;

public class EditRequest {

    private String currentPlan = "";
    private String weatherContext = "";
    private String instruction = "";

    @JsonProperty("current_plan") @JsonAlias("currentPlan")
    public String getCurrentPlan() { return currentPlan; }
    public void setCurrentPlan(String v) { this.currentPlan = v; }

    @JsonProperty("weather_context") @JsonAlias("weatherContext")
    public String getWeatherContext() { return weatherContext; }
    public void setWeatherContext(String v) { this.weatherContext = v; }

    @JsonProperty("instruction")
    public String getInstruction() { return instruction; }
    public void setInstruction(String v) { this.instruction = v; }
}

server:
  port: 8080

disastergpt:
  api:
    base-url: https://sw-kim.com
    key: ${DISASTER_API_KEY:}   # 환경변수로 주입

package com.disastergpt.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class WebClientConfig {

    @Value("${disastergpt.api.base-url}")
    private String baseUrl;

    @Value("${disastergpt.api.key}")
    private String apiKey;

    @Bean
    public WebClient disasterGptWebClient(WebClient.Builder builder) {
        return builder
                .baseUrl(baseUrl)
                .defaultHeader("X-API-KEY", apiKey)
                // X-Trace-ID는 ChatService에서 요청 시 직접 주입 (Reactor Context 기반)
                .codecs(cfg -> cfg.defaultCodecs().maxInMemorySize(10 * 1024 * 1024)) // 10MB
                .build();
    }
}

package com.disastergpt.service;

import com.disastergpt.dto.ChatRequest;
import com.disastergpt.dto.ChatResponse;
import com.disastergpt.dto.StreamChunk;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.MediaType;
import org.springframework.http.codec.ServerSentEvent;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

@Service
public class ChatService {

    private static final Logger log = LoggerFactory.getLogger(ChatService.class);

    private final WebClient webClient;
    private final ObjectMapper objectMapper;

    public ChatService(WebClient disasterGptWebClient, ObjectMapper objectMapper) {
        this.webClient = disasterGptWebClient;
        this.objectMapper = objectMapper;
    }

    /** 단일 응답 (테스트·배치용) */
    public Mono<ChatResponse> chat(ChatRequest request, String traceId) {
        log.info("[TRACE {}][FASTAPI ][CALL    ] POST /api/chat", traceId);
        long start = System.currentTimeMillis();
        return webClient.post()
                .uri("/api/chat")
                .header("X-Trace-ID", traceId)
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue(request)
                .retrieve()
                .bodyToMono(ChatResponse.class)
                .doOnSuccess(r -> log.info("[TRACE {}][FASTAPI ][DONE    ] elapsed={}ms answer={}ch",
                        traceId, System.currentTimeMillis() - start,
                        r != null && r.getAnswer() != null ? r.getAnswer().length() : 0));
    }

    /** SSE 스트리밍 — StreamChunk Flux 반환 */
    public Flux<StreamChunk> chatStream(ChatRequest request, String traceId) {
        log.info("[TRACE {}][FASTAPI ][STREAM  ] POST /api/chat/stream", traceId);
        AtomicInteger chunkNo = new AtomicInteger(0);
        AtomicLong start = new AtomicLong(System.currentTimeMillis());

        return webClient.post()
                .uri("/api/chat/stream")
                .header("X-Trace-ID", traceId)
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue(request)
                .retrieve()
                .bodyToFlux(new ParameterizedTypeReference<ServerSentEvent<String>>() {})
                .filter(event -> event.data() != null && !event.data().isEmpty())
                .map(ServerSentEvent::data)
                .takeUntil("[DONE]"::equals)
                .filter(data -> !"[DONE]".equals(data))
                .flatMap(data -> {
                    try {
                        StreamChunk chunk = objectMapper.readValue(data, StreamChunk.class);
                        int no = chunkNo.incrementAndGet();
                        if ("refs".equals(chunk.getType())) {
                            log.info("[TRACE {}][SSE     ][REFS    ] refs={}docs",
                                    traceId, chunk.getRefs() != null ? chunk.getRefs().size() : 0);
                        } else if ("status".equals(chunk.getType())) {
                            log.info("[TRACE {}][SSE     ][STATUS  ] {}", traceId, chunk.getContent());
                        } else if ("chunk".equals(chunk.getType()) && (no == 1 || no % 20 == 0)) {
                            log.info("[TRACE {}][SSE     ][CHUNK   ] #{} content={}ch",
                                    traceId, no,
                                    chunk.getContent() != null ? chunk.getContent().length() : 0);
                        } else if ("error".equals(chunk.getType())) {
                            log.error("[TRACE {}][SSE     ][ERROR   ] {}", traceId, chunk.getContent());
                        }
                        return Flux.just(chunk);
                    } catch (Exception e) {
                        return Flux.empty();
                    }
                })
                .doOnComplete(() -> log.info("[TRACE {}][SSE     ][DONE    ] total_chunks={} elapsed={}ms",
                        traceId, chunkNo.get(), System.currentTimeMillis() - start.get()));
    }
}

package com.disastergpt.service;

import com.disastergpt.dto.EditRequest;
import com.disastergpt.dto.ReportRequest;
import com.disastergpt.dto.StreamChunk;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.MediaType;
import org.springframework.http.codec.ServerSentEvent;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Service
public class ReportService {

    private static final Logger log = LoggerFactory.getLogger(ReportService.class);

    private final WebClient webClient;
    private final ObjectMapper objectMapper;

    public ReportService(WebClient disasterGptWebClient, ObjectMapper objectMapper) {
        this.webClient = disasterGptWebClient;
        this.objectMapper = objectMapper;
    }

    /** FastAPI /api/report/generate SSE 스트림 프록시 */
    public Flux<StreamChunk> generateStream(ReportRequest request, String traceId) {
        log.info("[TRACE {}][REPORT  ][GENERATE] base_datetime={}",
                traceId, request.getBaseDatetime());

        return webClient.post()
                .uri("/api/report/generate")
                .header("X-Trace-ID", traceId)
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue(request)
                .retrieve()
                .bodyToFlux(new ParameterizedTypeReference<ServerSentEvent<String>>() {})
                .filter(e -> e.data() != null && !e.data().isEmpty())
                .map(ServerSentEvent::data)
                .takeUntil("[DONE]"::equals)
                .filter(data -> !"[DONE]".equals(data))
                .flatMap(data -> {
                    try {
                        return Flux.just(objectMapper.readValue(data, StreamChunk.class));
                    } catch (Exception e) {
                        return Flux.empty();
                    }
                });
    }

    /** FastAPI /api/report/edit-stream 프록시 — LangGraph 우회 직접 LLM 편집 */
    public Flux<StreamChunk> editStream(EditRequest request, String traceId) {
        log.info("[TRACE {}][REPORT  ][EDIT    ] POST /api/report/edit-stream", traceId);
        return webClient.post()
                .uri("/api/report/edit-stream")
                .header("X-Trace-ID", traceId)
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue(request)
                .retrieve()
                .bodyToFlux(new ParameterizedTypeReference<ServerSentEvent<String>>() {})
                .filter(e -> e.data() != null && !e.data().isEmpty())
                .map(ServerSentEvent::data)
                .takeUntil("[DONE]"::equals)
                .filter(data -> !"[DONE]".equals(data))
                .flatMap(data -> {
                    try {
                        return Flux.just(objectMapper.readValue(data, StreamChunk.class));
                    } catch (Exception e) {
                        return Flux.empty();
                    }
                });
    }

    /** FastAPI /api/report/download/{reportId}?format=docx|pdf 프록시 */
    public Mono<byte[]> downloadFile(String reportId, String format, String traceId) {
        log.info("[TRACE {}][REPORT  ][DOWNLOAD] id={} format={}", traceId, reportId, format);
        return webClient.get()
                .uri(u -> u.path("/api/report/download/{id}").queryParam("format", format).build(reportId))
                .header("X-Trace-ID", traceId)
                .retrieve()
                .bodyToMono(byte[].class);
    }
}

package com.disastergpt.controller;

import com.disastergpt.dto.ChatRequest;
import com.disastergpt.dto.ChatResponse;
import com.disastergpt.dto.StreamChunk;
import com.disastergpt.filter.TraceFilter;
import com.disastergpt.service.ChatService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.MediaType;
import org.springframework.http.codec.ServerSentEvent;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/chat")
public class ChatController {

    private static final Logger log = LoggerFactory.getLogger(ChatController.class);
    private final ChatService chatService;

    public ChatController(ChatService chatService) {
        this.chatService = chatService;
    }

    /** POST /chat — 단일 응답 */
    @PostMapping
    public Mono<ChatResponse> chat(@RequestBody ChatRequest request,
                                    ServerWebExchange exchange) {
        return Mono.deferContextual(ctx -> {
            String tid = ctx.getOrDefault(TraceFilter.TRACE_ID_KEY, "--------");
            log.info("[TRACE {}][REQUEST ][CHAT    ] question=\"{}\"", tid,
                    request.getQuestion() != null ? request.getQuestion() : "");
            return chatService.chat(request, tid);
        });
    }

    /**
     * POST /chat/stream — SSE 스트리밍
     *
     * curl -X POST http://localhost:8080/chat/stream \
     *   -H "Content-Type: application/json" \
     *   -H "Accept: text/event-stream" \
     *   -d '{"question":"화재 시 대피 요령은?"}'
     */
    @PostMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<StreamChunk>> chatStream(@RequestBody ChatRequest request,
                                                            ServerWebExchange exchange) {
        return Flux.deferContextual(ctx -> {
            String tid = ctx.getOrDefault(TraceFilter.TRACE_ID_KEY, "--------");
            log.info("[TRACE {}][REQUEST ][STREAM  ] question=\"{}\" pdf={}",
                    tid, request.getQuestion(), request.getSelectedPdf());
            return chatService.chatStream(request, tid)
                    .map(chunk -> ServerSentEvent.<StreamChunk>builder()
                            .data(chunk)
                            .build());
        });
    }
}

package com.disastergpt.controller;

import com.disastergpt.dto.EditRequest;
import com.disastergpt.dto.ReportRequest;
import com.disastergpt.dto.StreamChunk;
import com.disastergpt.filter.TraceFilter;
import com.disastergpt.service.ReportService;
import org.springframework.http.ContentDisposition;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.codec.ServerSentEvent;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;

@RestController
@RequestMapping("/report")
public class ReportController {

    private final ReportService reportService;

    public ReportController(ReportService reportService) {
        this.reportService = reportService;
    }

    /** POST /report/generate — SSE 스트리밍 프록시 */
    @PostMapping(value = "/generate", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<StreamChunk>> generate(
            @RequestBody ReportRequest request,
            ServerWebExchange exchange) {
        return Flux.deferContextual(ctx -> {
            String tid = ctx.getOrDefault(TraceFilter.TRACE_ID_KEY, "--------");
            return reportService.generateStream(request, tid)
                    .map(chunk -> ServerSentEvent.<StreamChunk>builder()
                            .data(chunk)
                            .build());
        });
    }

    /** POST /report/edit-stream — 조치사항 AI 편집 SSE (LangGraph 우회) */
    @PostMapping(value = "/edit-stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<StreamChunk>> editStream(
            @RequestBody EditRequest request,
            ServerWebExchange exchange) {
        return Flux.deferContextual(ctx -> {
            String tid = ctx.getOrDefault(TraceFilter.TRACE_ID_KEY, "--------");
            return reportService.editStream(request, tid)
                    .map(chunk -> ServerSentEvent.<StreamChunk>builder()
                            .data(chunk)
                            .build());
        });
    }

    /** GET /report/download/{reportId}?format=docx|pdf — 파일 다운로드 */
    @GetMapping("/download/{reportId}")
    public Mono<ResponseEntity<byte[]>> download(
            @PathVariable String reportId,
            @RequestParam(defaultValue = "docx") String format,
            ServerWebExchange exchange) {
        return Flux.deferContextual(ctx -> {
            String tid = ctx.getOrDefault(TraceFilter.TRACE_ID_KEY, "--------");
            return reportService.downloadFile(reportId, format, tid).flux();
        }).next().map(bytes -> {
            String ext = format.toLowerCase();
            MediaType mediaType = "pdf".equals(ext) ? MediaType.APPLICATION_PDF
                    : MediaType.parseMediaType(
                    "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
            String filename = "기상상황보고_" + reportId + "." + ext;
            HttpHeaders headers = new HttpHeaders();
            headers.setContentDisposition(
                    ContentDisposition.attachment()
                            .filename(filename, StandardCharsets.UTF_8)
                            .build());
            return ResponseEntity.ok()
                    .headers(headers)
                    .contentType(mediaType)
                    .body(bytes);
        });
    }
}

package com.disastergpt.controller;

import org.springframework.web.bind.annotation.*;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/documents")
public class DocumentController {

    private final WebClient webClient;

    public DocumentController(WebClient disasterGptWebClient) {
        this.webClient = disasterGptWebClient;
    }

    /**
     * GET /documents
     * 응답: {"documents":[{"id":0,"name":"...","filename":"...","total_pages":42},...]}
     */
    @GetMapping
    public Mono<String> listDocuments() {
        return webClient.get()
                .uri("/api/documents")
                .retrieve()
                .bodyToMono(String.class);
    }

    /**
     * GET /documents/{docId}/page/{page}
     * 응답: {"image":"base64_png","page":0,"total_pages":42}
     * - docId: /documents 응답의 id 값 (0-based)
     * - page:  0-based 페이지 번호, 범위 초과 시 404
     */
    @GetMapping("/{docId}/page/{page}")
    public Mono<String> getPage(@PathVariable int docId, @PathVariable int page) {
        return webClient.get()
                .uri("/api/documents/{docId}/page/{page}", docId, page)
                .retrieve()
                .bodyToMono(String.class);
    }
}

package com.disastergpt.filter;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebFilter;
import org.springframework.web.server.WebFilterChain;
import reactor.core.publisher.Mono;

import java.util.UUID;

/**
 * 모든 요청에 trace_id를 부여하고 응답 헤더(X-Trace-ID)에 추가.
 * - 인바운드 X-Trace-ID 헤더가 있으면 재사용
 * - 없으면 UUID 앞 8자리 신규 생성
 * traceId는 Reactor Context에 저장 → Service에서 꺼내 FastAPI로 전달
 */
@Component
public class TraceFilter implements WebFilter {

    private static final Logger log = LoggerFactory.getLogger(TraceFilter.class);
    public static final String TRACE_ID_KEY = "traceId";
    public static final String TRACE_HEADER = "X-Trace-ID";

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        String traceId = exchange.getRequest().getHeaders().getFirst(TRACE_HEADER);
        if (traceId == null || traceId.isBlank()) {
            traceId = UUID.randomUUID().toString().replace("-", "").substring(0, 8);
        }
        final String tid = traceId;

        exchange.getResponse().getHeaders().add(TRACE_HEADER, tid);
        log.info("[TRACE {}][FILTER  ][ASSIGN  ] method={} uri={}",
                tid, exchange.getRequest().getMethod(),
                exchange.getRequest().getURI().getPath());

        return chain.filter(exchange)
                .contextWrite(ctx -> ctx.put(TRACE_ID_KEY, tid));
    }
}