Merge branch 'jenkins_with_weblogic' of ssh://192.168.240.178:18081/eapim/eapim-admin into jenkins_with_weblogic

This commit is contained in:
Rinjae
2026-01-07 17:27:16 +09:00
67 changed files with 2863 additions and 287 deletions
@@ -15,12 +15,9 @@ class RequestWrapper extends HttpServletRequestWrapper {
// GS인증 크로스사이트스크립트 보안성 문제로 XSS 공격을 방지하기 위한 악성 스크립트 패턴 정의.
// 2025.05.27 패턴 추가
// 2025.12.30 src 패턴 수정 - 화이트리스트 방식 (http, https, data:image/ 만 허용)
private static final Pattern[] PATTERNS = new Pattern[] {
Pattern.compile("<script>(.*?)</script>", Pattern.CASE_INSENSITIVE),
Pattern.compile("src[\r\n]*=[\r\n]*\\\'(.*?)\\\'",
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
Pattern.compile("src[\r\n]*=[\r\n]*\\\"(.*?)\\\"",
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
Pattern.compile("</script>", Pattern.CASE_INSENSITIVE),
Pattern.compile("<script(.*?)>",
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
@@ -46,6 +43,22 @@ class RequestWrapper extends HttpServletRequestWrapper {
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL)
};
// src 속성 화이트리스트 패턴 - data:image/만 허용
private static final Pattern SRC_ATTR_PATTERN = Pattern.compile(
"(src\\s*=\\s*)([\"'])([^\"']*?)\\2",
Pattern.CASE_INSENSITIVE);
// 허용되는 src 값 패턴 (화이트리스트) - data:image/만 허용
private static final Pattern ALLOWED_SRC_PATTERN = Pattern.compile(
"^data:image/.*",
Pattern.CASE_INSENSITIVE);
// XSS 문자 변환을 건너뛸 파라미터 목록 (리치 텍스트 에디터 콘텐츠 등)
// XSS 패턴 필터링은 적용하지만 &lt;, &gt; 등으로 변환하지 않음
private static final String[] SKIP_CHAR_CONVERT_PARAMS = {"contents", "content", "description"};
// 현재 처리 중인 파라미터명 (cleanXSS에서 문자 변환 여부 결정에 사용)
private ThreadLocal<String> currentParameter = new ThreadLocal<>();
public RequestWrapper(HttpServletRequest servletRequest) {
super(servletRequest);
@@ -60,8 +73,13 @@ class RequestWrapper extends HttpServletRequestWrapper {
int count = values.length;
String[] encodedValues = new String[count];
for (int i = 0; i < count; i++) {
encodedValues[i] = cleanXSS(values[i]);
currentParameter.set(parameter);
try {
for (int i = 0; i < count; i++) {
encodedValues[i] = cleanXSS(values[i]);
}
} finally {
currentParameter.remove();
}
return encodedValues;
@@ -74,13 +92,19 @@ class RequestWrapper extends HttpServletRequestWrapper {
for (Entry<String, String[]> entry : map.entrySet()) {
String[] values = entry.getValue();
String paramName = entry.getKey();
if (values != null && values.length > 0) {
String[] cloneValues = new String[values.length];
for (int idx = 0; idx < values.length; idx++) {
cloneValues[idx] = cleanXSS(values[idx]);
currentParameter.set(paramName);
try {
for (int idx = 0; idx < values.length; idx++) {
cloneValues[idx] = cleanXSS(values[idx]);
}
} finally {
currentParameter.remove();
}
clonedMap.put(entry.getKey(), cloneValues);
clonedMap.put(paramName, cloneValues);
}
}
@@ -95,7 +119,12 @@ class RequestWrapper extends HttpServletRequestWrapper {
return value;
}
return cleanXSS(value);
currentParameter.set(parameter);
try {
return cleanXSS(value);
} finally {
currentParameter.remove();
}
}
@Override
@@ -123,9 +152,15 @@ class RequestWrapper extends HttpServletRequestWrapper {
// script 문자열을 완전히 제거
value = value.replaceAll("(?i)\\bscript\\b", "");
StringBuilder sb = new StringBuilder();
value = convertChars(value, sb);
// src 속성 화이트리스트 필터링 - 허용된 프로토콜만 통과
value = filterSrcAttribute(value);
// 리치 텍스트 파라미터는 문자 변환을 건너뛰고 XSS 패턴 필터링만 적용
if (!shouldSkipCharConvert()) {
StringBuilder sb = new StringBuilder();
value = convertChars(value, sb);
}
// eval, javascript 등 스크립트 관련 문자열 제거
value = value.replaceAll("(?i)eval\\((.*?)\\)", "");
@@ -133,6 +168,54 @@ class RequestWrapper extends HttpServletRequestWrapper {
return value;
}
/**
* 현재 파라미터가 문자 변환을 건너뛸지 여부 확인
* 리치 텍스트 에디터 콘텐츠 등은 HTML 태그가 필요하므로 &lt; &gt; 변환을 하지 않음
*/
private boolean shouldSkipCharConvert() {
String param = currentParameter.get();
if (param == null) {
return false;
}
for (String skipParam : SKIP_CHAR_CONVERT_PARAMS) {
if (StringUtils.equalsIgnoreCase(param, skipParam)) {
return true;
}
}
return false;
}
/**
* src 속성을 화이트리스트 방식으로 필터링
* 허용: data:image/ (Base64 이미지)
* 비허용: 그 외 모든 프로토콜
*/
private String filterSrcAttribute(String value) {
if (value == null || !value.toLowerCase().contains("src")) {
return value;
}
Matcher matcher = SRC_ATTR_PATTERN.matcher(value);
StringBuffer result = new StringBuffer();
while (matcher.find()) {
String srcPrefix = matcher.group(1); // src=
String quote = matcher.group(2); // " 또는 '
String srcValue = matcher.group(3); // src 값
// 빈 값이거나 화이트리스트에 매칭되면 유지
if (srcValue.isEmpty() || ALLOWED_SRC_PATTERN.matcher(srcValue).matches()) {
matcher.appendReplacement(result, Matcher.quoteReplacement(srcPrefix + quote + srcValue + quote));
} else {
// 허용되지 않는 프로토콜은 src="" 로 대체
matcher.appendReplacement(result, Matcher.quoteReplacement(srcPrefix + quote + quote));
}
}
matcher.appendTail(result);
return result.toString();
}
// '(', ')', '"' 문자는 getMethod()가 "get"일 때만 변환됨.
// 이는 gridData에서 사용되는 큰따옴표(")와 변환 함수에서 사용하는 괄호('(', ')')의 처리를 위함.
private String convertChars(String value, StringBuilder sb) {
@@ -7,6 +7,7 @@ import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.ClassUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
@@ -32,6 +33,14 @@ public class AuthorizeInterceptor implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// InterceptorSkipController 구현 컨트롤러는 권한 체크 스킵
if (handler instanceof HandlerMethod) {
Class<?> clazz = ((HandlerMethod) handler).getBeanType();
if (ClassUtils.isAssignable(clazz, InterceptorSkipController.class)) {
return true;
}
}
// 요청 URI, 사용자 ID, 서비스 타입, cmd 추출
String uri = request.getRequestURI();
String userId = SessionManager.getUserId(request);
@@ -67,9 +67,9 @@ public class SessionCheckInterceptor extends HandlerInterceptorAdapter {
} else {
//request.getRequestDispatcher("/monitoring/loginForm.do").forward(request, response);
//request.getSession().setAttribute("redirectInProgress", true);
response.sendRedirect("/monitoring/rms/logout.do");
response.sendRedirect(request.getContextPath() + "/rms/logout.do");
//response.sendRedirect("/monitoring/loginForm.do");
}
}
@@ -0,0 +1,46 @@
package com.eactive.eai.rms.common.login;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import org.apache.log4j.Logger;
@WebListener
public class SessionDestructionListener implements HttpSessionListener {
private static final Logger logger = Logger.getLogger(SessionDestructionListener.class);
@Override
public void sessionCreated(HttpSessionEvent se) {
}
/**
* 세션 타임아웃 등으로 소멸 시 세션정보 삭제
*/
@Override
public void sessionDestroyed(HttpSessionEvent se) {
try {
HttpSession session = se.getSession();
String userId = (String) session.getAttribute("userId");
// 로그인 한 사용자의 세션정보 정리
if (userId != null) {
if (logger.isDebugEnabled()) {
logger.debug("[SessionListener] 세션만료 감지. 사용자 제거: " + userId);
}
SessionManager.removeUserSession(userId);
}
} catch (Exception e) {
logger.error("[SessionListener] 세션 정리 중 오류 발생", e);
}
}
}
@@ -1,21 +1,31 @@
package com.eactive.eai.rms.data.entity.onl.authserver;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import com.eactive.eai.data.entity.onl.authserver.QScopeEntity;
import com.eactive.eai.data.entity.onl.authserver.ScopeEntity;
import com.eactive.eai.data.entity.onl.authserver.ScopeEntityId;
import com.eactive.eai.data.jpa.AbstractDataService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
@Transactional
public class ScopeEntityService extends AbstractDataService<ScopeEntity, ScopeEntityId, ScopeEntityEMSRepository> {
@PersistenceContext
private EntityManager entityManager; // AbstractDataService 의 entityManager가 private이라 접근 불가하여 별도 주입
public void deleteByIdScopeId(String scopeId) {
getJPAQueryFactory().delete(QScopeEntity.scopeEntity)
.where(QScopeEntity.scopeEntity.id.scopeid.eq(scopeId))
.execute();
// 동일 트랜잭션 내에서 같은 ID로 재저장 시 충돌(EntityExistsException)을 방지
entityManager.flush();
entityManager.clear();
}
}
@@ -310,8 +310,6 @@ public class EAIMessageService extends AbstractDataService<EAIMessageEntity, Str
.on(qScopeEntity.id.scopeid.eq(qScopeInfo.scopeId))
.where(predicate)
.orderBy(qScopeEntity.id.bzwksvckeyname.asc())
.offset(pageable.getOffset())
.limit(pageable.getPageSize())
.fetch();
return new PageImpl<>(result, pageable, result.size());
@@ -320,7 +318,7 @@ public class EAIMessageService extends AbstractDataService<EAIMessageEntity, Str
private BooleanExpression booleanPredicate(QEAIMessageEntity qEaiMessageEntity, QScopeEntity qScopeEntity,
QScopeInfo qScopeInfo, ApiScopeSearch apiScopeSearch) {
BooleanExpression predicate = qScopeEntity.id.scopeid.containsIgnoreCase(apiScopeSearch.getSearchScopeId());
BooleanExpression predicate = qScopeEntity.id.scopeid.equalsIgnoreCase(apiScopeSearch.getSearchScopeId());
// BooleanExpression predicate = qEaiMessageEntity.eaisvcdesc.containsIgnoreCase(apiScopeSearch.getSearchEaiSvcDesc());
// if(StringUtils.isNotBlank(apiScopeSearch.getSearchBzwkSvcKeyName())) {
@@ -1,19 +1,33 @@
package com.eactive.eai.rms.data.entity.onl.inflow;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import com.eactive.eai.data.entity.onl.inflow.InflowControlLog;
import com.eactive.eai.data.entity.onl.inflow.InflowControlLogId;
import com.eactive.eai.data.entity.onl.inflow.QInflowControlGroup;
import com.eactive.eai.data.entity.onl.inflow.QInflowControlLog;
import com.eactive.eai.data.jpa.AbstractDataService;
import com.eactive.eai.rms.onl.manage.inflow.history.InflowControlHistoryManMapper;
import com.eactive.eai.rms.onl.manage.inflow.history.InflowControlHistoryManUI;
import com.eactive.eai.rms.onl.manage.inflow.history.InflowControlHistoryManUISearch;
import com.querydsl.core.BooleanBuilder;
import com.querydsl.core.Tuple;
@Service
public class InflowControlLogService
extends AbstractDataService<InflowControlLog, InflowControlLogId, InflowControlLogRepository> {
private final InflowControlService inflowControlService;
private final InflowControlHistoryManMapper inflowControlHistoryManMapper;
@Autowired
public InflowControlLogService(InflowControlService inflowControlService, InflowControlHistoryManMapper inflowControlHistoryManMapper) {
this.inflowControlService = inflowControlService;
this.inflowControlHistoryManMapper = inflowControlHistoryManMapper;
}
public Page<InflowControlLog> findAll(Pageable pageable, InflowControlHistoryManUISearch uiSearch) {
QInflowControlLog qInflowConfrolLog = QInflowControlLog.inflowControlLog;
@@ -25,6 +39,28 @@ public class InflowControlLogService
return super.repository.findAll(booleanBuilder, pageable);
}
public Page<InflowControlHistoryManUI> selectList(Pageable pageable, InflowControlHistoryManUISearch uiSearch) {
Page<Tuple> tuples = inflowControlService.selectLogList(pageable, uiSearch);
return tuples.map(tuple -> {
InflowControlLog inflowControlLog = tuple.get(QInflowControlLog.inflowControlLog);
String groupName = tuple.get(QInflowControlGroup.inflowControlGroup.groupName);
InflowControlHistoryManUI inflowControlHistoryManUI;
inflowControlHistoryManUI = inflowControlHistoryManMapper.toVo(inflowControlLog);
inflowControlHistoryManUI.setGroupname(groupName);
return inflowControlHistoryManUI;
});
}
public Iterable<InflowControlLog> findAll(InflowControlHistoryManUISearch uiSearch) {
QInflowControlLog qInflowConfrolLog = QInflowControlLog.inflowControlLog;
BooleanBuilder booleanBuilder = new BooleanBuilder();
@@ -17,11 +17,16 @@ import com.eactive.eai.data.entity.onl.adapter.QAdapterGroup;
import com.eactive.eai.data.entity.onl.inflow.InflowControl;
import com.eactive.eai.data.entity.onl.inflow.InflowControlId;
import com.eactive.eai.data.entity.onl.inflow.QInflowControl;
import com.eactive.eai.data.entity.onl.inflow.QInflowControlGroup;
import com.eactive.eai.data.entity.onl.inflow.QInflowControlLog;
import com.eactive.eai.data.entity.onl.message.QEAIMessageEntity;
import com.eactive.eai.data.jpa.AbstractDataService;
import com.eactive.eai.rms.onl.manage.inflow.history.InflowControlHistoryManUISearch;
import com.eactive.eai.rms.onl.manage.inflow.inflow.InflowControlManMapper;
import com.querydsl.core.BooleanBuilder;
import com.querydsl.core.Tuple;
import com.querydsl.core.types.OrderSpecifier;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory;
@Service
@@ -168,5 +173,45 @@ public class InflowControlService extends AbstractDataService<InflowControl, Inf
return toDto(qEAIMessageEntity, qInflowControl, tuple);
}
public Page<Tuple> selectLogList(Pageable pageable, InflowControlHistoryManUISearch uiSearch) {
QInflowControlLog qlog = QInflowControlLog.inflowControlLog;
QInflowControlGroup qgroup = QInflowControlGroup.inflowControlGroup;
JPAQuery<Tuple> jpaQuery = createBaseQuery(uiSearch);
long totalCount = jpaQuery.select(QInflowControlLog.inflowControlLog.count()).fetchOne();
List<Tuple> inflowControlLog = jpaQuery
.select(qlog, qgroup.groupName)
.limit(pageable.getPageSize())
.offset(pageable.getOffset())
.orderBy(qlog.id.msgdpstyms.desc())
.fetch();
return new PageImpl<>(inflowControlLog, pageable, totalCount);
}
private JPAQuery<Tuple> createBaseQuery(InflowControlHistoryManUISearch uiSearch) {
QInflowControlLog qInflowConfrolLog = QInflowControlLog.inflowControlLog;
QInflowControlGroup qinflowControlGroup = QInflowControlGroup.inflowControlGroup;
BooleanBuilder predicate = new BooleanBuilder();
predicate
.and(qInflowConfrolLog.id.msgdpstyms
.between(uiSearch.getSearchStartDate() + "000000000",
uiSearch.getSearchEndDate() + "235959999"));
return getJPAQueryFactory()
.select(
qInflowConfrolLog,
qinflowControlGroup.groupName
)
.from(qInflowConfrolLog)
.leftJoin(qinflowControlGroup)
.on(qInflowConfrolLog.adptrbzwkgroupname.eq(qinflowControlGroup.groupId))
.where(predicate);
}
}
@@ -0,0 +1,17 @@
package com.eactive.eai.rms.data.entity.onl.logger;
import java.util.List;
import lombok.Data;
@Data
public class ApiLogDTO {
private String apiServiceNumber;
private String txDate;
private List<ApiMessageLogDTO> logs;
private Long totalProcessingTime;
}
@@ -0,0 +1,36 @@
package com.eactive.eai.rms.data.entity.onl.logger;
import java.util.List;
import java.util.Map;
import lombok.Data;
@Data
public class ApiMessageLogDTO {
private String apiServiceNumber;
private int processNumber;
private String txDate;
private String url;
private String queryString;
private String clientId;
private String method;
private Integer HttpStatus;
private String header;
private String body;
private String exdata;
private Long processingTime;
private String keymgtmsgctnt;
}
@@ -6,6 +6,7 @@ import org.springframework.data.domain.Pageable;
import com.eactive.eai.data.entity.onl.logger.EAILog;
import com.eactive.eai.data.entity.onl.logger.EAILogId;
import java.util.List;
import java.util.Map;
public interface EAILogRepository {
@@ -16,4 +17,6 @@ public interface EAILogRepository {
Map<String, Long> countDetailedTransactions(Class<? extends EAILog> clazz, EAILogSearch eaiLogSearch);
List<EAILog> getApiLog(Class<? extends EAILog> class1, String apiServiceNumber);
}
@@ -1,5 +1,19 @@
package com.eactive.eai.rms.data.entity.onl.logger;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Repository;
import com.eactive.eai.data.entity.onl.logger.EAILog;
import com.eactive.eai.data.entity.onl.logger.EAILogId;
import com.eactive.eai.data.entity.onl.logger.QEAILog;
@@ -11,18 +25,6 @@ import com.querydsl.core.types.dsl.BooleanExpression;
import com.querydsl.core.types.dsl.EntityPathBase;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Repository;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Repository
public class EAILogRepositoryImpl implements EAILogRepository {
@@ -217,4 +219,14 @@ public class EAILogRepositoryImpl implements EAILogRepository {
.fetchOne();
}
@Override
public List<EAILog> getApiLog(Class<? extends EAILog> clazz, String apiServiceNumber) {
QEAILog qeaiLog = QEAILog.eAILog;
EntityPathBase<?> entityPathBase = new EntityPathBase<>(clazz, qeaiLog.getMetadata().getName());
return new JPAQueryFactory(em).select(qeaiLog).from(entityPathBase)
.where(qeaiLog.id.eaisvcserno.trim().eq(apiServiceNumber)).orderBy(qeaiLog.id.logprcssserno.asc())
.fetch();
}
}
@@ -19,4 +19,6 @@ public interface EAILogService {
List<PortalStatisticsVO> selectLogList(HashMap<String, Object> paramMap);
Map<String, Long> getTransactionCounts(EAILogSearch eaiLogSearch);
ApiLogDTO getApiLog(String txDate, String apiServiceNumber);
}
@@ -1,55 +1,132 @@
package com.eactive.eai.rms.data.entity.onl.logger;
import com.eactive.eai.data.RollingTable;
import com.eactive.eai.data.entity.onl.logger.EAILog;
import com.eactive.eai.data.entity.onl.logger.EAILogId;
import com.eactive.eai.rms.common.util.CommonUtil;
import com.eactive.eai.rms.data.entity.onl.apim.portalstatistics.PortalStatisticsVO;
import lombok.RequiredArgsConstructor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.eactive.eai.data.RollingTable;
import com.eactive.eai.data.entity.onl.logger.EAILog;
import com.eactive.eai.data.entity.onl.logger.EAILogId;
import com.eactive.eai.data.entity.onl.logger.HttpAdapterExtraLog;
import com.eactive.eai.rms.common.util.CommonUtil;
import com.eactive.eai.rms.data.entity.onl.apim.portalstatistics.PortalStatisticsVO;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Service
@Transactional
@RequiredArgsConstructor
public class EAILogServiceImpl implements EAILogService {
private final EAILogRepository eaiLogRepository;
private final ApplicationContext applicationContext;
private final EAILogDAOForEMS eaiLogDAOForEMS;
private final EAILogRepository eaiLogRepository;
private final ApplicationContext applicationContext;
private final EAILogDAOForEMS eaiLogDAOForEMS;
private final HttpAdapterExtraLogService httpAdapterExtraLogService;
@Override
public Page<EAILogDto> findAll(Pageable pageable, EAILogSearch eaiLogSearch) {
long time = CommonUtil.getCalendar(eaiLogSearch.getSearchStartTime()).getTimeInMillis();
EAILog eaiLog = (EAILog) applicationContext.getBean(RollingTable.class, EAILog.class, time);
Page<EAILogDto> eaiLogDtos = eaiLogRepository.findAll(eaiLog.getClass(), pageable, eaiLogSearch);
return eaiLogDtos;
}
@Override
public Page<EAILogDto> findAll(Pageable pageable, EAILogSearch eaiLogSearch) {
long time = CommonUtil.getCalendar(eaiLogSearch.getSearchStartTime()).getTimeInMillis();
EAILog eaiLog = (EAILog) applicationContext.getBean(RollingTable.class, EAILog.class, time);
Page<EAILogDto> eaiLogDtos = eaiLogRepository.findAll(eaiLog.getClass(), pageable, eaiLogSearch);
return eaiLogDtos;
}
public Map<String, Long> getTransactionCounts(EAILogSearch eaiLogSearch){
long time = CommonUtil.getCalendar(eaiLogSearch.getSearchStartTime()).getTimeInMillis();
EAILog eaiLog = (EAILog) applicationContext.getBean(RollingTable.class, EAILog.class, time);
Map<String, Long> detailedCounts = eaiLogRepository.countDetailedTransactions(eaiLog.getClass(), eaiLogSearch);
return detailedCounts;
}
public Map<String, Long> getTransactionCounts(EAILogSearch eaiLogSearch) {
long time = CommonUtil.getCalendar(eaiLogSearch.getSearchStartTime()).getTimeInMillis();
EAILog eaiLog = (EAILog) applicationContext.getBean(RollingTable.class, EAILog.class, time);
Map<String, Long> detailedCounts = eaiLogRepository.countDetailedTransactions(eaiLog.getClass(), eaiLogSearch);
return detailedCounts;
}
@Override
public EAILogDto getById(EAILogId eaiLogId) {
long time = CommonUtil.getCalendar(eaiLogId.getMsgdpstyms()).getTimeInMillis();
EAILog eaiLog = (EAILog) applicationContext.getBean(RollingTable.class, EAILog.class, time);
return eaiLogRepository.getById(eaiLog.getClass(), eaiLogId);
}
@Override
public EAILogDto getById(EAILogId eaiLogId) {
long time = CommonUtil.getCalendar(eaiLogId.getMsgdpstyms()).getTimeInMillis();
EAILog eaiLog = (EAILog) applicationContext.getBean(RollingTable.class, EAILog.class, time);
return eaiLogRepository.getById(eaiLog.getClass(), eaiLogId);
}
public List<PortalStatisticsVO> selectLogList(HashMap<String, Object> paramMap) {
return eaiLogDAOForEMS.selectLogList(paramMap);
}
public List<PortalStatisticsVO> selectLogList(HashMap<String, Object> paramMap) {
return eaiLogDAOForEMS.selectLogList(paramMap);
}
@Override
public ApiLogDTO getApiLog(String txDate, String apiServiceNumber) {
long time = CommonUtil.getCalendar(txDate).getTimeInMillis();
EAILog eaiLogTargetObject = (EAILog) applicationContext.getBean(RollingTable.class, EAILog.class, time);
List<EAILog> eaiLogs = eaiLogRepository.getApiLog(eaiLogTargetObject.getClass(), apiServiceNumber);
eaiLogs.sort((l1, l2) -> l1.getId().getEaisvcserno().compareTo(l2.getId().getEaisvcserno()));
ApiLogDTO apiLogDTO = new ApiLogDTO();
apiLogDTO.setApiServiceNumber(apiServiceNumber);
eaiLogs.stream().findFirst().ifPresent(log -> apiLogDTO.setTxDate(log.getId().getMsgdpstyms()));
List<ApiMessageLogDTO> apiMessageLogDTOs = new LinkedList<>();
for (EAILog eaiLog : eaiLogs) {
ApiMessageLogDTO apiMessageLogDTO = new ApiMessageLogDTO();
apiMessageLogDTO.setApiServiceNumber(apiServiceNumber);
apiMessageLogDTO.setTxDate(eaiLog.getMsgprcssyms());
apiMessageLogDTO.setProcessNumber(Integer.parseInt(eaiLog.getId().getLogprcssserno()));
apiMessageLogDTO.setQueryString("");
apiMessageLogDTO.setClientId(eaiLog.getClientid());
apiMessageLogDTO.setKeymgtmsgctnt(eaiLog.getKeymgtmsgctnt());
String body = StringUtils.substringAfter(eaiLog.getBzwkdatactnt(), '|');
body = StringUtils.substringBeforeLast(body, "|");
apiMessageLogDTO.setBody(body);
apiMessageLogDTOs.add(apiMessageLogDTO);
}
Map<Integer, HttpAdapterExtraLog> extraLogs = httpAdapterExtraLogService.findByGuid(apiServiceNumber);
for (ApiMessageLogDTO apiMessageLogDTO : apiMessageLogDTOs) {
HttpAdapterExtraLog httpAdapterExtraLog = extraLogs.get(apiMessageLogDTO.getProcessNumber());
if (httpAdapterExtraLog != null) {
apiMessageLogDTO.setHeader(httpAdapterExtraLog.getHeaderContent());
apiMessageLogDTO.setMethod(httpAdapterExtraLog.getHttpMethod());
apiMessageLogDTO.setHttpStatus(httpAdapterExtraLog.getHttpStatus());
apiMessageLogDTO.setUrl(httpAdapterExtraLog.getUrl());
}
}
// 처리 시간 계산
for (int i = 0; i < apiMessageLogDTOs.size(); i++) {
ApiMessageLogDTO dto = apiMessageLogDTOs.get(i);
EAILog eaiLog = eaiLogs.get(i);
// msgprcssyms - msgdpstyms
long receivedTime = CommonUtil.getCalendar(eaiLog.getId().getMsgdpstyms()).getTimeInMillis();
long processedTime = CommonUtil.getCalendar(eaiLog.getMsgprcssyms()).getTimeInMillis();
long processingTime = processedTime - receivedTime;
dto.setProcessingTime(processingTime);
}
// 전체 처리 시간 계산 (첫 수신 시각 ~ 마지막 처리 시각)
if (!eaiLogs.isEmpty()) {
long firstReceivedTime = CommonUtil.getCalendar(eaiLogs.get(0).getId().getMsgdpstyms()).getTimeInMillis();
long lastProcessedTime = CommonUtil.getCalendar(eaiLogs.get(eaiLogs.size() - 1).getMsgprcssyms()).getTimeInMillis();
long totalProcessingTime = lastProcessedTime - firstReceivedTime;
apiLogDTO.setTotalProcessingTime(totalProcessingTime);
}
apiLogDTO.setLogs(apiMessageLogDTOs);
return apiLogDTO;
}
}
@@ -1,16 +1,28 @@
package com.eactive.eai.rms.data.entity.onl.logger;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import javax.transaction.Transactional;
import org.springframework.stereotype.Service;
import com.eactive.eai.data.entity.onl.logger.HttpAdapterExtraLog;
import com.eactive.eai.data.entity.onl.logger.HttpAdapterExtraLogId;
import com.eactive.eai.data.entity.onl.logger.QHttpAdapterExtraLog;
import com.eactive.eai.data.jpa.AbstractDataService;
import com.querydsl.core.types.dsl.BooleanExpression;
@Service
@Transactional
public class HttpAdapterExtraLogService
extends AbstractDataService<HttpAdapterExtraLog, HttpAdapterExtraLogId, HttpAdapterExtraLogRepository> {
public Map<Integer, HttpAdapterExtraLog> findByGuid(String guid) {
BooleanExpression predicate = QHttpAdapterExtraLog.httpAdapterExtraLog.id.guid.eq(guid);
return StreamSupport.stream(repository.findAll(predicate).spliterator(), false)
.collect(Collectors.toMap(log -> log.getId().getServiceProcessNumber(), log -> log));
}
}
@@ -7,4 +7,5 @@ public class ApiGroupUISearch {
private String searchGroupName;
private String searchGroupDesc;
private String searchDisplayYn;
private String searchApiFullPath;
}
@@ -0,0 +1,155 @@
package com.eactive.eai.rms.onl.apim.portalterms;
import com.eactive.eai.rms.common.base.BaseAnnotationController;
import com.eactive.eai.rms.common.interceptor.InterceptorSkipController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.HashMap;
import java.util.Map;
/**
* 에디터 이미지 컨트롤러
* - summernote 에디터에서 사용하는 이미지 업로드/서빙 API
* - InterceptorSkipController: 인터셉터의 상세 검증 우회 (필터에서 기본 로그인 체크는 수행됨)
*/
@Controller
@RequestMapping("/onl/apim/editor/image")
public class EditorImageController extends BaseAnnotationController implements InterceptorSkipController {
private final EditorImageService editorImageService;
@Autowired
public EditorImageController(EditorImageService editorImageService) {
this.editorImageService = editorImageService;
}
/**
* 이미지 업로드 API
* - summernote에서 이미지 선택/붙여넣기 시 호출
* - 즉시 DB에 저장하고 플레이스홀더 정보 반환
*
* @param file MultipartFile 이미지 파일
* @return { success: true, fileId: "uuid", fileSn: 1, placeholder: "{{IMG:uuid:1}}" }
*/
@PostMapping("/upload.json")
@ResponseBody
public ResponseEntity<Map<String, Object>> uploadImage(@RequestParam("file") MultipartFile file) {
Map<String, Object> result = new HashMap<>();
try {
// 파일 검증
if (file.isEmpty()) {
result.put("success", false);
result.put("error", "파일이 비어있습니다.");
return ResponseEntity.badRequest().body(result);
}
// 이미지 타입 검증
String contentType = file.getContentType();
if (contentType == null || !contentType.startsWith("image/")) {
result.put("success", false);
result.put("error", "이미지 파일만 업로드 가능합니다.");
return ResponseEntity.badRequest().body(result);
}
// 파일 크기 검증 (10MB)
long maxSize = 10 * 1024 * 1024;
if (file.getSize() > maxSize) {
result.put("success", false);
result.put("error", "파일 크기는 10MB를 초과할 수 없습니다.");
return ResponseEntity.badRequest().body(result);
}
// 이미지 저장
EditorImageDTO saved = editorImageService.saveImage(file);
// 성공 응답
result.put("success", true);
result.put("fileId", saved.getFileId());
result.put("fileSn", saved.getFileSn());
result.put("placeholder", "{{IMG:" + saved.getFileId() + ":" + saved.getFileSn() + "}}");
return ResponseEntity.ok(result);
} catch (Exception e) {
logger.error("이미지 업로드 중 오류 발생", e);
result.put("success", false);
result.put("error", "이미지 업로드 중 오류가 발생했습니다: " + e.getMessage());
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
}
}
/**
* 이미지 서빙 API
* - 브라우저에서 이미지 표시용 (관리자포탈)
* - 캐시 설정으로 성능 최적화
*
* @param fileId 파일 ID (PTL_FILE.FILE_ID)
* @param fileSn 파일 순번 (PTL_FILE_DETAIL.FILE_SN)
* @return 이미지 바이너리 데이터
*/
@GetMapping("/view.do")
public ResponseEntity<byte[]> viewImage(
@RequestParam String fileId,
@RequestParam(defaultValue = "1") int fileSn) {
try {
EditorImageDTO image = editorImageService.getImage(fileId, fileSn);
if (image == null || image.getImageData() == null) {
return ResponseEntity.notFound().build();
}
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.parseMediaType(image.getContentType()));
headers.setContentLength(image.getFileSize());
headers.setCacheControl("public, max-age=86400"); // 1일 캐시
headers.set("Content-Disposition", "inline");
return new ResponseEntity<>(image.getImageData(), headers, HttpStatus.OK);
} catch (Exception e) {
logger.error("이미지 조회 중 오류 발생: fileId=" + fileId + ", fileSn=" + fileSn, e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
/**
* 이미지 삭제 API
* - 에디터에서 이미지 삭제 시 호출
* - DB에서 파일 삭제
*
* @param fileId 파일 ID (PTL_FILE.FILE_ID)
* @return { success: true }
*/
@PostMapping("/delete.json")
@ResponseBody
public ResponseEntity<Map<String, Object>> deleteImage(@RequestParam String fileId) {
Map<String, Object> result = new HashMap<>();
try {
if (fileId == null || fileId.isEmpty()) {
result.put("success", false);
result.put("error", "파일 ID가 필요합니다.");
return ResponseEntity.badRequest().body(result);
}
editorImageService.deleteImage(fileId);
result.put("success", true);
return ResponseEntity.ok(result);
} catch (Exception e) {
logger.error("이미지 삭제 중 오류 발생: fileId=" + fileId, e);
result.put("success", false);
result.put("error", "이미지 삭제 중 오류가 발생했습니다: " + e.getMessage());
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
}
}
}
@@ -0,0 +1,46 @@
package com.eactive.eai.rms.onl.apim.portalterms;
import lombok.Data;
/**
* 에디터 이미지 DTO
* - summernote 에디터에서 업로드된 이미지 정보를 담는 DTO
*/
@Data
public class EditorImageDTO {
/**
* 파일 ID (PTL_FILE.FILE_ID)
*/
private String fileId;
/**
* 파일 순번 (PTL_FILE_DETAIL.FILE_SN)
*/
private int fileSn;
/**
* 원본 파일명
*/
private String originalFileName;
/**
* 파일 확장자
*/
private String fileExtension;
/**
* 파일 크기 (bytes)
*/
private int fileSize;
/**
* Content-Type (MIME 타입)
*/
private String contentType;
/**
* 이미지 바이너리 데이터 (조회 시에만 사용)
*/
private byte[] imageData;
}
@@ -0,0 +1,231 @@
package com.eactive.eai.rms.onl.apim.portalterms;
import com.eactive.apim.portal.file.entity.FileDetail;
import com.eactive.apim.portal.file.entity.FileInfo;
import com.eactive.apim.portal.file.service.FileService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 에디터 이미지 서비스
* - summernote 에디터에서 사용하는 이미지 업로드/조회/삭제 서비스
* - FileService를 래핑하여 이미지 전용 기능 제공
*/
@Service
@Transactional(transactionManager = "transactionManagerForEMS")
@Slf4j
public class EditorImageService {
/**
* 플레이스홀더 패턴: {{IMG:fileId:fileSn}} 또는 {{IMG:fileId:fileSn|속성}}
* - fileId: UUID 형식 (예: 550e8400-e29b-41d4-a716-446655440000)
* - fileSn: 정수 (예: 1)
* - 속성: 선택적 (예: |width=300|height=200|style=max-width:100%)
*/
private static final Pattern PLACEHOLDER_PATTERN =
Pattern.compile("\\{\\{IMG:([a-f0-9\\-]+):(\\d+)(\\|[^}]+)?\\}\\}");
private final FileService fileService;
@Autowired
public EditorImageService(FileService fileService) {
this.fileService = fileService;
}
/**
* 이미지 저장
*
* @param file MultipartFile 이미지 파일
* @return EditorImageDTO (fileId, fileSn 포함)
* @throws IOException 파일 처리 중 오류 발생 시
*/
public EditorImageDTO saveImage(MultipartFile file) throws IOException {
String fileName = file.getOriginalFilename();
String contentType = file.getContentType();
byte[] data = file.getBytes();
// FileService를 통해 저장
FileInfo fileInfo = fileService.createSingleFileFromBytes(fileName, contentType, data);
FileDetail detail = fileInfo.getFileDetails().get(0);
// DTO로 변환하여 반환
EditorImageDTO dto = new EditorImageDTO();
dto.setFileId(fileInfo.getFileId());
dto.setFileSn(detail.getFileSn());
dto.setOriginalFileName(detail.getOriginalFileName());
dto.setFileExtension(detail.getFileExtension());
dto.setFileSize(detail.getFileSize());
return dto;
}
/**
* 이미지 조회
*
* @param fileId 파일 ID
* @param fileSn 파일 순번
* @return EditorImageDTO (imageData 포함)
* @throws IOException 파일 조회 중 오류 발생 시
*/
@Transactional(readOnly = true)
public EditorImageDTO getImage(String fileId, int fileSn) throws IOException {
FileDetail detail = fileService.getFileDetailByIds(fileId, fileSn);
byte[] data = fileService.retrieveFileContent(detail);
EditorImageDTO dto = new EditorImageDTO();
dto.setFileId(fileId);
dto.setFileSn(fileSn);
dto.setOriginalFileName(detail.getOriginalFileName());
dto.setFileExtension(detail.getFileExtension());
dto.setFileSize(detail.getFileSize());
dto.setContentType(getContentType(detail.getFileExtension()));
dto.setImageData(data);
return dto;
}
/**
* 본문에서 사용 중인 파일 ID 추출
*
* @param contents 본문 내용 (플레이스홀더 포함)
* @return 사용 중인 파일 ID Set
*/
public Set<String> extractFileIds(String contents) {
Set<String> fileIds = new HashSet<>();
if (contents == null || contents.isEmpty()) {
return fileIds;
}
Matcher matcher = PLACEHOLDER_PATTERN.matcher(contents);
while (matcher.find()) {
fileIds.add(matcher.group(1)); // fileId
}
return fileIds;
}
/**
* 이미지 삭제
*
* @param fileId 삭제할 파일 ID
*/
public void deleteImage(String fileId) {
try {
fileService.deleteFile(fileId);
log.info("Deleted image: {}", fileId);
} catch (Exception e) {
log.warn("Failed to delete image: {}", fileId, e);
throw e;
}
}
/**
* 미사용 이미지 정리
* - 원래 저장된 이미지 중 현재 본문에서 사용되지 않는 이미지 삭제
*
* @param usedFileIds 본문에서 사용 중인 파일 ID 목록
* @param originalFileIds 원래 저장된 모든 파일 ID 목록
*/
public void cleanupUnusedImages(Set<String> usedFileIds, Set<String> originalFileIds) {
if (originalFileIds == null || originalFileIds.isEmpty()) {
return;
}
for (String fileId : originalFileIds) {
if (!usedFileIds.contains(fileId)) {
try {
fileService.deleteFile(fileId);
log.info("Deleted unused image: {}", fileId);
} catch (Exception e) {
// 삭제 실패 시 로그만 남기고 계속 진행
log.warn("Failed to delete unused image: {}", fileId, e);
}
}
}
}
/**
* 플레이스홀더를 실제 이미지 태그로 변환
*
* @param contents 본문 내용 (플레이스홀더 포함)
* @param baseUrl 이미지 서빙 베이스 URL (예: /onl/apim/editor/image/view/)
* @return 이미지 태그가 포함된 HTML
*/
public String convertPlaceholdersToHtml(String contents, String baseUrl) {
if (contents == null || contents.isEmpty()) {
return contents;
}
StringBuffer result = new StringBuffer();
Matcher matcher = PLACEHOLDER_PATTERN.matcher(contents);
while (matcher.find()) {
String fileId = matcher.group(1);
String fileSn = matcher.group(2);
String attrs = matcher.group(3); // |width=300|height=200 형태
StringBuilder img = new StringBuilder();
img.append("<img src=\"").append(baseUrl).append(fileId).append("/").append(fileSn).append("\"");
// 속성 파싱 및 추가
if (attrs != null && !attrs.isEmpty()) {
String[] parts = attrs.substring(1).split("\\|"); // 앞의 | 제거 후 분리
for (String part : parts) {
String[] kv = part.split("=", 2);
if (kv.length == 2) {
img.append(" ").append(kv[0]).append("=\"").append(kv[1]).append("\"");
}
}
}
// 기본 스타일 (style 속성이 없으면 추가)
if (attrs == null || !attrs.contains("style=")) {
img.append(" style=\"max-width:100%;height:auto;\"");
}
img.append(" />");
matcher.appendReplacement(result, Matcher.quoteReplacement(img.toString()));
}
matcher.appendTail(result);
return result.toString();
}
/**
* 파일 확장자를 Content-Type으로 변환
*
* @param extension 파일 확장자
* @return MIME 타입
*/
private String getContentType(String extension) {
if (extension == null) {
return "application/octet-stream";
}
switch (extension.toLowerCase()) {
case "jpg":
case "jpeg":
return "image/jpeg";
case "png":
return "image/png";
case "gif":
return "image/gif";
case "bmp":
return "image/bmp";
case "webp":
return "image/webp";
case "svg":
return "image/svg+xml";
default:
return "application/octet-stream";
}
}
}
@@ -13,12 +13,16 @@ import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
@Controller
@@ -72,14 +76,22 @@ public class PortalTermsManController extends BaseAnnotationController {
}
@PostMapping(value = "/onl/apim/portalterms/portalTermsMan.json", params = "cmd=INSERT")
public ResponseEntity<String> insert(PortalTermsUI portalTermsUI) throws IOException {
portalTermsManService.insert(portalTermsUI);
public ResponseEntity<String> insert(PortalTermsUI portalTermsUI,
@RequestParam(value = "attachedFile", required = false) MultipartFile attachedFile) throws IOException {
portalTermsManService.insert(portalTermsUI, attachedFile);
return ResponseEntity.ok().build();
}
@PostMapping(value = "/onl/apim/portalterms/portalTermsMan.json", params = "cmd=UPDATE")
public ResponseEntity<String> update(PortalTermsUI portalTermsUI) throws IOException {
portalTermsManService.update(portalTermsUI);
public ResponseEntity<String> update(PortalTermsUI portalTermsUI, String usedFileIds,
@RequestParam(value = "attachedFile", required = false) MultipartFile attachedFile,
@RequestParam(value = "deleteAttachment", defaultValue = "false") boolean deleteAttachment) throws IOException {
// 사용 중인 파일 ID 목록 파싱
Set<String> usedFileIdSet = new HashSet<>();
if (usedFileIds != null && !usedFileIds.isEmpty()) {
usedFileIdSet.addAll(Arrays.asList(usedFileIds.split(",")));
}
portalTermsManService.update(portalTermsUI, usedFileIdSet, attachedFile, deleteAttachment);
return ResponseEntity.ok().build();
}
@@ -4,15 +4,24 @@ import com.eactive.apim.portal.agreements.entity.AgreementType;
import com.eactive.apim.portal.agreements.entity.Agreements;
import com.eactive.apim.portal.agreements.entity.AgreementsId;
import com.eactive.apim.portal.agreements.service.AgreementsService;
import com.eactive.apim.portal.file.entity.FileDetail;
import com.eactive.apim.portal.file.entity.FileInfo;
import com.eactive.apim.portal.file.service.FileService;
import com.eactive.eai.rms.common.base.BaseService;
import com.eactive.eai.rms.data.entity.man.user.UserInfoService;
import com.eactive.eai.rms.data.entity.onl.apim.portalterms.PortalTermsService;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
@Service
@Transactional(transactionManager = "transactionManagerForEMS")
@@ -21,16 +30,22 @@ public class PortalTermsManService extends BaseService {
private final PortalTermsUIMapper portalTermsUIMapper;
private final AgreementsService agreementsService;
private final UserInfoService userInfoService;
private final EditorImageService editorImageService;
private final FileService fileService;
@Autowired
public PortalTermsManService(PortalTermsService portalTermsService,
PortalTermsUIMapper portalTermsUIMapper,
AgreementsService agreementsService,
UserInfoService userInfoService){
UserInfoService userInfoService,
EditorImageService editorImageService,
FileService fileService){
this.portalTermsService = portalTermsService;
this.portalTermsUIMapper = portalTermsUIMapper;
this.agreementsService = agreementsService;
this.userInfoService = userInfoService;
this.editorImageService = editorImageService;
this.fileService = fileService;
}
private String findName(String userId) {
@@ -55,25 +70,90 @@ public class PortalTermsManService extends BaseService {
portalTermsUI.setCreatedByName(findName(agreements.getCreatedBy()));
portalTermsUI.setLastModifiedByName(findName(agreements.getLastModifiedBy()));
portalTermsUI.setName(agreements.getAgreementsType().getDescription());
// 첨부파일 정보 조회
if (StringUtils.isNotBlank(agreements.getAttachedFileId())) {
try {
FileInfo fileInfo = fileService.findById(agreements.getAttachedFileId());
if (fileInfo != null && !fileInfo.getFileDetails().isEmpty()) {
FileDetail fileDetail = fileInfo.getFileDetails().get(0);
portalTermsUI.setAttachedFileName(fileDetail.getOriginalFileName() + "." + fileDetail.getFileExtension());
portalTermsUI.setAttachedFileSize((long) fileDetail.getFileSize());
}
} catch (Exception e) {
// 파일 조회 실패 시 무시
logger.warn("첨부파일 조회 실패: {}", agreements.getAttachedFileId(), e);
}
}
return portalTermsUI;
}
public void insert(PortalTermsUI portalTermsUI) {
public void insert(PortalTermsUI portalTermsUI, MultipartFile attachedFile) throws IOException {
portalTermsUI.setName(AgreementType.fromCode(portalTermsUI.getAgreementsType()).getDescription());
portalTermsUI.setContents(StringEscapeUtils.unescapeHtml(portalTermsUI.getContents()));
Agreements agreements = portalTermsUIMapper.toEntity(portalTermsUI);
// 첨부파일 저장
if (attachedFile != null && !attachedFile.isEmpty()) {
FileInfo fileInfo = fileService.createOrUpdateSingleFile(null, attachedFile, attachedFile.getOriginalFilename());
agreements.setAttachedFileId(fileInfo.getFileId());
}
agreementsService.save(agreements);
}
public void update(PortalTermsUI portalTermsUI) {
public void update(PortalTermsUI portalTermsUI, Set<String> usedFileIds,
MultipartFile attachedFile, boolean deleteAttachment) throws IOException {
Agreements agreements = agreementsService.findById(portalTermsUI.getAgreementsType(), portalTermsUI.getRevision());
// 원래 내용에서 사용 중이던 파일 ID 추출
Set<String> originalFileIds = editorImageService.extractFileIds(agreements.getContents());
// 내용 업데이트
agreements.setName(AgreementType.fromCode(portalTermsUI.getAgreementsType()).getDescription());
agreements.setContents(StringEscapeUtils.unescapeHtml(portalTermsUI.getContents()));
agreements.setPublishedOn(portalTermsUI.getPublishedOn());
// 첨부파일 처리
String oldAttachedFileId = agreements.getAttachedFileId();
if (deleteAttachment && StringUtils.isNotBlank(oldAttachedFileId)) {
// 첨부파일 삭제 요청
fileService.deleteFile(oldAttachedFileId);
agreements.setAttachedFileId(null);
} else if (attachedFile != null && !attachedFile.isEmpty()) {
// 새 첨부파일 업로드
FileInfo fileInfo = fileService.createOrUpdateSingleFile(
oldAttachedFileId, attachedFile, attachedFile.getOriginalFilename());
agreements.setAttachedFileId(fileInfo.getFileId());
}
agreementsService.save(agreements);
// 미사용 이미지 정리 (저장 후 비동기적으로 처리)
editorImageService.cleanupUnusedImages(usedFileIds, originalFileIds);
}
public void delete(String agreementsType, Integer revision) {
// 삭제 전 사용 중인 파일 ID 추출
Agreements agreements = agreementsService.findById(agreementsType, revision);
Set<String> fileIdsToDelete = editorImageService.extractFileIds(agreements.getContents());
String attachedFileId = agreements.getAttachedFileId();
// 약관 삭제
agreementsService.delete(agreementsType, revision);
// 관련 이미지 모두 삭제
editorImageService.cleanupUnusedImages(new HashSet<>(), fileIdsToDelete);
// 첨부파일 삭제
if (StringUtils.isNotBlank(attachedFileId)) {
try {
fileService.deleteFile(attachedFileId);
} catch (Exception e) {
logger.warn("첨부파일 삭제 실패: {}", attachedFileId, e);
}
}
}
}
@@ -52,4 +52,13 @@ public class PortalTermsUI {
private String searchAgreementsType;
/* 첨부파일 ID */
private String attachedFileId;
/* 첨부파일명 (조회용) */
private String attachedFileName;
/* 첨부파일 크기 (조회용) */
private Long attachedFileSize;
}
@@ -7,6 +7,14 @@ import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.eactive.eai.agent.command.CommonCommand;
import com.eactive.eai.rms.common.base.OnlBaseAnnotationController;
import com.eactive.eai.rms.common.combo.ComboService;
import com.eactive.eai.rms.common.combo.ComboVo;
import com.eactive.eai.rms.common.vo.GridResponse;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
@@ -16,14 +24,6 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;
import com.eactive.eai.agent.command.CommonCommand;
import com.eactive.eai.rms.common.base.OnlBaseAnnotationController;
import com.eactive.eai.rms.common.combo.ComboService;
import com.eactive.eai.rms.common.combo.ComboVo;
import com.eactive.eai.rms.common.vo.GridResponse;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
@Controller
public class InflowGroupControlManController extends OnlBaseAnnotationController {
@@ -78,7 +78,7 @@ public class InflowGroupControlManController extends OnlBaseAnnotationController
* 그룹 저장 (INSERT)
*/
@RequestMapping(value = "/onl/admin/inflow/inflowGroupControlMan.json", params = "cmd=INSERT")
public String insert(HttpServletRequest request, HttpServletResponse response, InflowGroupControlManUI ui,
public ResponseEntity<Void> insert(HttpServletRequest request, HttpServletResponse response, InflowGroupControlManUI ui,
@RequestParam(value = "interfaceListJson", required = false) String interfaceListJson) throws Exception {
parseInterfaceList(ui, interfaceListJson);
String modifiedBy = getSessionUserId(request);
@@ -88,14 +88,14 @@ public class InflowGroupControlManController extends OnlBaseAnnotationController
CommonCommand command = new CommonCommand("com.eactive.eai.agent.inflow.ReloadInflowGroupControlCommand",
ui.getGroupId());
agentUtilService.broadcast(command);
return null;
return ResponseEntity.ok().build();
}
/**
* 그룹 저장 (UPDATE)
*/
@RequestMapping(value = "/onl/admin/inflow/inflowGroupControlMan.json", params = "cmd=UPDATE")
public String update(HttpServletRequest request, HttpServletResponse response, InflowGroupControlManUI ui,
public ResponseEntity<Void> update(HttpServletRequest request, HttpServletResponse response, InflowGroupControlManUI ui,
@RequestParam(value = "interfaceListJson", required = false) String interfaceListJson) throws Exception {
parseInterfaceList(ui, interfaceListJson);
String modifiedBy = getSessionUserId(request);
@@ -105,21 +105,21 @@ public class InflowGroupControlManController extends OnlBaseAnnotationController
CommonCommand command = new CommonCommand("com.eactive.eai.agent.inflow.ReloadInflowGroupControlCommand",
ui.getGroupId());
agentUtilService.broadcast(command);
return null;
return ResponseEntity.ok().build();
}
/**
* 그룹 삭제
*/
@RequestMapping(value = "/onl/admin/inflow/inflowGroupControlMan.json", params = "cmd=DELETE")
public String delete(HttpServletRequest request, HttpServletResponse response, String groupId) throws Exception {
public ResponseEntity<Void> delete(HttpServletRequest request, HttpServletResponse response, String groupId) throws Exception {
service.deleteGroup(groupId);
// Agent Command 전송
CommonCommand command = new CommonCommand("com.eactive.eai.agent.inflow.RemoveInflowGroupControlCommand",
groupId);
agentUtilService.broadcast(command);
return null;
return ResponseEntity.ok().build();
}
/**
@@ -31,6 +31,13 @@ public class InflowControlHistoryManController extends OnlBaseAnnotationControll
return "/onl/admin/inflow/inflowControlHistoryMan";
}
// @RequestMapping(value = "/onl/admin/inflow/inflowControlHistoryMan.json", params = "cmd=LIST")
// public ResponseEntity<GridResponse<InflowControlHistoryManUI>> selectList(HttpServletRequest request,
// Pageable pageable, InflowControlHistoryManUISearch uiSearch) {
// Page<InflowControlHistoryManUI> uiPage = service.selectList(pageable, uiSearch);
// return ResponseEntity.ok(new GridResponse<>(uiPage));
// }
@RequestMapping(value = "/onl/admin/inflow/inflowControlHistoryMan.json", params = "cmd=LIST")
public ResponseEntity<GridResponse<InflowControlHistoryManUI>> selectList(HttpServletRequest request,
Pageable pageable, InflowControlHistoryManUISearch uiSearch) {
@@ -23,8 +23,13 @@ public class InflowControlHistoryManService extends BaseService {
@Autowired
InflowControlHistoryManMapper mapper;
// public Page<InflowControlHistoryManUI> selectList(Pageable pageable, InflowControlHistoryManUISearch uiSearch) {
// return service.findAll(pageable, uiSearch).map(mapper::toVo);
// }
public Page<InflowControlHistoryManUI> selectList(Pageable pageable, InflowControlHistoryManUISearch uiSearch) {
return service.findAll(pageable, uiSearch).map(mapper::toVo);
return service.selectList(pageable, uiSearch);
}
public List<HashMap<String, Object>> selectListToExcel(InflowControlHistoryManUISearch uiSearch) {
@@ -66,6 +66,12 @@ public class InflowControlHistoryManUI {
*/
@JsonProperty("THRESHOLDTIMEUNIT")
private String thresholdtimeunit;
/**
* 그룹명
*/
@JsonProperty("GROUPNAME")
private String groupname;
}
@@ -171,7 +171,8 @@ public class Transform2Service extends BaseService {
private String genConversionSourceItems(String srcLayoutName, String cnvsncmdname) {
Pattern pattern = Pattern.compile(srcLayoutName + "(\\w|\\[|\\]|\\*|\\.|-|:)*");
// \uAC00-\uD7A3 : 한글 전체 ('가' ~ '힣')
Pattern pattern = Pattern.compile(srcLayoutName + "[\\w\\.\\[\\]\\*\\-:\\uAC00-\\uD7A3]*");
Matcher matcher = pattern.matcher(cnvsncmdname);
StringBuilder result = new StringBuilder();
@@ -9,6 +9,7 @@ import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
@@ -52,7 +53,7 @@ public class StdMessageManController extends BaseController {
@PostMapping(value = "/onl/admin/service/stdMessageMan.json", params = "cmd=LIST")
public ResponseEntity<GridResponse<StdMessageUI>> selectList(Pageable pageable, String searchBzwkSvcKeyName,
String searchEaiSvcCode, String searchEaiSendRecv, String searchEaiDirection) {
List<StdMessageUI> map = service
Page<StdMessageUI> map = service
.selectList(pageable, searchBzwkSvcKeyName, searchEaiSvcCode, searchEaiSendRecv, searchEaiDirection);
return ResponseEntity.ok(new GridResponse<>(map));
@@ -16,6 +16,7 @@ import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -59,14 +60,13 @@ public class StdMessageManService {
@Autowired
private ExtendedColumnDefinitionUIMapper extendedColumnDefinitionUIMapper;
public List<StdMessageUI> selectList(Pageable pageable, String searchBzwkSvcKeyName, String searchEaiSvcCode,
public Page<StdMessageUI> selectList(Pageable pageable, String searchBzwkSvcKeyName, String searchEaiSvcCode,
String searchEaiSendRecv, String searchEaiDirection) {
return standardMessageInfoService
.findAll(pageable, searchBzwkSvcKeyName, searchEaiSvcCode, searchEaiSendRecv, searchEaiDirection)
.stream()
.map(stdMessageUIMapper::toVo)
.collect(Collectors.toList());
Page<StandardMessageInfo> pageResult = standardMessageInfoService
.findAll(pageable, searchBzwkSvcKeyName, searchEaiSvcCode, searchEaiSendRecv, searchEaiDirection);
return pageResult.map(stdMessageUIMapper::toVo);
}
@@ -553,7 +553,7 @@ public class ApiInterfaceService extends OnlBaseService {
restOption.setMethod(outboundHttpMethod);
restOption.setExtraPath(outboundRestPath);
String pathType = outboundRestPath.matches(".*\\{[a-zA-Z]+\\}.*") ? "variableUrlRequest" : "simpleRequest";
String pathType = outboundRestPath.matches(".*\\{[_a-zA-Z]+\\}.*") ? "variableUrlRequest" : "simpleRequest";
restOption.setType(pathType);
if (StringUtils.isNotBlank(contentType)) {
@@ -1180,17 +1180,54 @@ public class ApiInterfaceService extends OnlBaseService {
apiInterfaceUI.setInboundRestPath(newInboundRestPath);
if ("Y".equals(apiInterfaceUI.getTransformYn())) {
apiInterfaceUI.setInboundRequestLayout(changeToTargetLayoutUI(layoutManService.getLayoutUiToExport(apiInterfaceUI.getInboundRequestLayout()), newBizCd, newApiInterfaceId));
apiInterfaceUI.setOutboundRequestLayout(changeToTargetLayoutUI(layoutManService.getLayoutUiToExport(apiInterfaceUI.getOutboundRequestLayout()), newBizCd, newApiInterfaceId));
apiInterfaceUI.setOutboundResponseLayout(changeToTargetLayoutUI(layoutManService.getLayoutUiToExport(apiInterfaceUI.getOutboundResponseLayout()), newBizCd, newApiInterfaceId));
apiInterfaceUI.setInboundResponseLayout(changeToTargetLayoutUI(layoutManService.getLayoutUiToExport(apiInterfaceUI.getInboundResponseLayout()), newBizCd, newApiInterfaceId));
apiInterfaceUI.setRequestTransform(changeToTargetTransformUI(transform2Service.getTransformUiToExport(apiInterfaceUI.getRequestTransform()), newBizCd, newApiInterfaceId, apiInterfaceUI.getInboundRequestLayout(), apiInterfaceUI.getOutboundRequestLayout()));
apiInterfaceUI.setResponseTransform(changeToTargetTransformUI(transform2Service.getTransformUiToExport(apiInterfaceUI.getResponseTransform()), newBizCd, newApiInterfaceId, apiInterfaceUI.getOutboundResponseLayout(), apiInterfaceUI.getInboundResponseLayout()));
String newInReq = processLayoutIfExist(apiInterfaceUI.getInboundRequestLayout(), newBizCd, newApiInterfaceId);
String newOutReq = processLayoutIfExist(apiInterfaceUI.getOutboundRequestLayout(), newBizCd, newApiInterfaceId);
String newOutRes = processLayoutIfExist(apiInterfaceUI.getOutboundResponseLayout(), newBizCd, newApiInterfaceId);
String newInRes = processLayoutIfExist(apiInterfaceUI.getInboundResponseLayout(), newBizCd, newApiInterfaceId);
apiInterfaceUI.setInboundRequestLayout(newInReq);
apiInterfaceUI.setOutboundRequestLayout(newOutReq);
apiInterfaceUI.setOutboundResponseLayout(newOutRes);
apiInterfaceUI.setInboundResponseLayout(newInRes);
if (newInReq != null && newOutReq != null) {
apiInterfaceUI.setRequestTransform(
changeToTargetTransformUI(
transform2Service.getTransformUiToExport(apiInterfaceUI.getRequestTransform()),
newBizCd, newApiInterfaceId, newInReq, newOutReq
)
);
}
if (newOutRes != null && newInRes != null) {
apiInterfaceUI.setResponseTransform(
changeToTargetTransformUI(
transform2Service.getTransformUiToExport(apiInterfaceUI.getResponseTransform()),
newBizCd, newApiInterfaceId, newOutRes, newInRes
)
);
}
}
importApiInterfaceUi(apiInterfaceUI, importDupliCheck);
return apiInterfaceUI;
}
/*
* 복제시 레이아웃 정보가 있는 경우에만 변환 로직을 수행
*/
private String processLayoutIfExist(String layoutId, String newBizCd, String newApiInterfaceId) {
if (layoutId == null || layoutId.isEmpty()) {
return null;
}
LayoutUI layoutEntity = layoutManService.getLayoutUiToExport(layoutId);
return changeToTargetLayoutUI(layoutEntity, newBizCd, newApiInterfaceId);
}
}
@@ -0,0 +1,83 @@
# API Gateway 통계 테이블 설계
## 요구사항 정리
### 수집 차원
- **시간 단위**: 분 단위
- **분류 차원**: API명, API Gateway Instance, ClientId, Scope, 업무구분코드 (값이 없을 경우 'NONE' 으로 대체)
### 메트릭
- **처리 건수**:
- 총 건수
- 성공 건수
- 오류 건수 (Timeout / System Error / Business Error)
- **응답시간 통계**:
- 평균 응답시간
- 최소 응답시간
- 최대 응답시간
- **추가 검토사항**:
- P50, P95 백분위 응답시간
### 집계 방식
- **집계 주기**: 매분 배치 집계
- **백분위 계산**: HdrHistogram 라이브러리 사용 (근사값, 메모리 효율적)
---
## 테이블 DDL
```sql
-- API Gateway 분단위 통계 테이블
CREATE TABLE API_STATS_MINUTE (
STAT_TIME TIMESTAMP(0) NOT NULL, -- 통계 시간 (분 단위, 초는 00)
API_NAME VARCHAR2(100) NOT NULL, -- API명
GW_INSTANCE_ID VARCHAR2(50) NOT NULL, -- API Gateway 인스턴스 ID
CLIENT_ID VARCHAR2(100) NOT NULL, -- 클라이언트 ID
SCOPE VARCHAR2(100) DEFAULT 'NONE' NOT NULL, -- 스코프
BIZ_DIV_CODE VARCHAR2(50) DEFAULT 'NONE' NOT NULL, -- 업무구분코드
-- 건수 메트릭
TOTAL_CNT NUMBER(12) DEFAULT 0 NOT NULL,
SUCCESS_CNT NUMBER(12) DEFAULT 0 NOT NULL,
TIMEOUT_CNT NUMBER(12) DEFAULT 0 NOT NULL,
SYSTEM_ERR_CNT NUMBER(12) DEFAULT 0 NOT NULL,
BIZ_ERR_CNT NUMBER(12) DEFAULT 0 NOT NULL,
-- 응답시간 메트릭 (ms, 소수점 3자리)
AVG_RESP_TIME NUMBER(10,3) DEFAULT 0,
MIN_RESP_TIME NUMBER(10,3) DEFAULT 0,
MAX_RESP_TIME NUMBER(10,3) DEFAULT 0,
P50_RESP_TIME NUMBER(10,3) DEFAULT 0,
P95_RESP_TIME NUMBER(10,3) DEFAULT 0,
-- 관리 정보
REG_DTIME TIMESTAMP DEFAULT SYSTIMESTAMP NOT NULL,
UPD_DTIME TIMESTAMP DEFAULT SYSTIMESTAMP,
CONSTRAINT PK_API_STATS_MINUTE PRIMARY KEY (
STAT_TIME, API_NAME, GW_INSTANCE_ID, CLIENT_ID, SCOPE, BIZ_DIV_CODE
)
);
-- 코멘트
COMMENT ON TABLE API_STATS_MINUTE IS 'API Gateway 분단위 처리 통계';
COMMENT ON COLUMN API_STATS_MINUTE.STAT_TIME IS '통계시간(분단위, 초는 00초로 절사)';
COMMENT ON COLUMN API_STATS_MINUTE.API_NAME IS 'API 명칭';
COMMENT ON COLUMN API_STATS_MINUTE.GW_INSTANCE_ID IS 'API Gateway 인스턴스 ID';
COMMENT ON COLUMN API_STATS_MINUTE.CLIENT_ID IS '클라이언트 ID';
COMMENT ON COLUMN API_STATS_MINUTE.SCOPE IS '스코프 (없으면 NONE)';
COMMENT ON COLUMN API_STATS_MINUTE.BIZ_DIV_CODE IS '업무구분코드 (없으면 NONE)';
COMMENT ON COLUMN API_STATS_MINUTE.TOTAL_CNT IS '총 처리 건수';
COMMENT ON COLUMN API_STATS_MINUTE.SUCCESS_CNT IS '성공 건수';
COMMENT ON COLUMN API_STATS_MINUTE.TIMEOUT_CNT IS 'Timeout 오류 건수';
COMMENT ON COLUMN API_STATS_MINUTE.SYSTEM_ERR_CNT IS '시스템 오류 건수';
COMMENT ON COLUMN API_STATS_MINUTE.BIZ_ERR_CNT IS '업무 오류 건수';
COMMENT ON COLUMN API_STATS_MINUTE.AVG_RESP_TIME IS '평균 응답시간(ms)';
COMMENT ON COLUMN API_STATS_MINUTE.MIN_RESP_TIME IS '최소 응답시간(ms)';
COMMENT ON COLUMN API_STATS_MINUTE.MAX_RESP_TIME IS '최대 응답시간(ms)';
COMMENT ON COLUMN API_STATS_MINUTE.P50_RESP_TIME IS '50 백분위 응답시간(ms)';
COMMENT ON COLUMN API_STATS_MINUTE.P95_RESP_TIME IS '95 백분위 응답시간(ms)';
```
---
@@ -0,0 +1,17 @@
package com.eactive.ext.kjb.web;
import java.util.List;
import lombok.Data;
@Data
public class ApiLogUI {
private String apiServiceNumber;
private String txDate;
private List<ApiMessageLogUI> logs;
private Long totalProcessingTime;
}
@@ -0,0 +1,35 @@
package com.eactive.ext.kjb.web;
import java.util.Map;
import lombok.Data;
@Data
public class ApiMessageLogUI {
private String apiServiceNumber;
private int processNumber;
private String txDate;
private String url;
private String queryString;
private String clientId;
private String method;
private Integer HttpStatus;
private Map<String, String> header;
private Object body;
private String exdata;
private Long processingTime;
private String guid;
}
@@ -0,0 +1,142 @@
package com.eactive.ext.kjb.web;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import com.eactive.eai.rms.common.datasource.DataSourceContextHolder;
import com.eactive.eai.rms.common.datasource.DataSourceTypeManager;
import com.eactive.eai.rms.common.interceptor.InterceptorSkipController;
import com.eactive.eai.rms.data.entity.onl.logger.ApiLogDTO;
import com.eactive.eai.rms.data.entity.onl.logger.ApiMessageLogDTO;
import com.eactive.eai.rms.data.entity.onl.logger.EAILogService;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Controller
@RequiredArgsConstructor
public class ApiTransactionLogController implements InterceptorSkipController {
private final EAILogService eaiLogService;
private final ObjectMapper objectMapper = new ObjectMapper();
@GetMapping("/api/transaction/log.do")
@PostMapping("/api/transaction/log.do")
public ResponseEntity<ApiLogUI> getApiLog(String txDate, String apiServiceNumber) {
DataSourceContextHolder.setDataSourceType(DataSourceTypeManager.getDataSourceType(DataSourceTypeManager.APIGW));
// txDate가 없으면 오늘 날짜 설정
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
LocalDate searchDate;
if (StringUtils.hasText(txDate)) {
searchDate = LocalDate.parse(txDate, formatter);
} else {
searchDate = LocalDate.now();
}
// 최대 10일 전까지 조회 시도
ApiLogDTO dto = null;
for (int i = 0; i < 10; i++) {
String searchDateStr = searchDate.format(formatter);
dto = eaiLogService.getApiLog(searchDateStr, apiServiceNumber);
// 결과가 있으면 종료
if (dto != null && dto.getLogs() != null && !dto.getLogs().isEmpty()) {
break;
}
// 하루 전으로 이동
searchDate = searchDate.minusDays(1);
}
return ResponseEntity.ok(convertToUI(dto));
}
private ApiLogUI convertToUI(ApiLogDTO dto) {
ApiLogUI ui = new ApiLogUI();
ui.setApiServiceNumber(dto.getApiServiceNumber());
ui.setTxDate(dto.getTxDate());
ui.setTotalProcessingTime(dto.getTotalProcessingTime());
if (dto.getLogs() != null) {
List<ApiMessageLogUI> uiLogs = dto.getLogs().stream().map(this::convertMessageToUI)
.collect(Collectors.toList());
ui.setLogs(uiLogs);
}
return ui;
}
private ApiMessageLogUI convertMessageToUI(ApiMessageLogDTO dto) {
ApiMessageLogUI ui = new ApiMessageLogUI();
ui.setApiServiceNumber(dto.getApiServiceNumber());
ui.setProcessNumber(dto.getProcessNumber());
ui.setTxDate(dto.getTxDate());
ui.setUrl(dto.getUrl());
ui.setQueryString(dto.getQueryString());
ui.setClientId(dto.getClientId());
ui.setMethod(dto.getMethod());
ui.setHttpStatus(dto.getHttpStatus());
ui.setExdata(dto.getExdata());
ui.setProcessingTime(dto.getProcessingTime());
ui.setGuid(dto.getKeymgtmsgctnt());
// header: JSON 문자열 → Map<String, String>
if (dto.getHeader() != null) {
try {
List<Map<String, String>> headerList = objectMapper.readValue(dto.getHeader(),
new TypeReference<List<Map<String, String>>>() {
});
Map<String, String> headerMap = new HashMap<>();
for (Map<String, String> headerItem : headerList) {
String name = headerItem.get("name");
String value = headerItem.get("value");
if (name != null) {
headerMap.put(name, value);
}
}
// header에서 client*id 패턴 추출 (정규식, ignoreCase)
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
if (entry.getKey() != null && entry.getKey().matches("(?i)client.*id")) {
ui.setClientId(entry.getValue());
break;
}
}
ui.setHeader(headerMap);
} catch (Exception e) {
log.error("Failed to parse header JSON: {}", dto.getHeader(), e);
}
}
// body: JSON 문자열 → Object
if (dto.getBody() != null) {
try {
Object bodyObject = objectMapper.readValue(dto.getBody(), Object.class);
ui.setBody(bodyObject);
} catch (Exception e) {
// JSON 파싱 실패 시 원본 문자열 사용
ui.setBody(dto.getBody());
}
}
return ui;
}
}
@@ -0,0 +1 @@
package com.eactive.ext.kjb.web;
@@ -32,7 +32,7 @@
FROM (
SELECT
CLIENTID AS CLIENT_ID,
RAND() AS REQUEST_URI,
DBMS_RANDOM.VALUE AS REQUEST_URI,
'$startTime$' AS STATISTICS_TIME,
EAISVCNAME AS API_ID,
NULL AS API_NAME,
@@ -49,7 +49,7 @@
UNION ALL
SELECT
CLIENTID AS CLIENT_ID,
RAND() AS REQUEST_URI,
DBMS_RANDOM.VALUE AS REQUEST_URI,
'$startTime$' AS STATISTICS_TIME,
EAISVCNAME AS API_ID,
NULL AS API_NAME,
@@ -59,8 +59,8 @@
ORGID AS ORG_ID,
ORGNAME AS ORG_NAME,
CASE
WHEN SUBSTRING(RSPNSERRCDNAME, 1, 2) = 'RE' THEN 0
WHEN SUBSTRING(RSPNSERRCDNAME, 1, 2) = 'FE' THEN 0
WHEN SUBSTR(RSPNSERRCDNAME, 1, 2) = 'RE' THEN 0
WHEN SUBSTR(RSPNSERRCDNAME, 1, 2) = 'FE' THEN 0
ELSE 1
END AS END_COUNT,
0 AS START_COUNT