init

src/main/java/com/eactive/eai/rms/onl/transaction/apim/ApiInterfaceController.java

@@ -0,0 +1,288 @@
+package com.eactive.eai.rms.onl.transaction.apim;
+
+import com.eactive.eai.agent.command.Command;
+import com.eactive.eai.agent.command.CommonCommand;
+import com.eactive.eai.rms.common.base.OnlBaseAnnotationController;
+import com.eactive.eai.rms.common.login.SessionManager;
+import com.eactive.eai.rms.common.vo.GridResponse;
+import com.eactive.eai.rms.data.entity.onl.authserver.ClientEntityService;
+import com.eactive.eai.rms.data.entity.onl.eaimsg.EAIMessageUISearch;
+import com.eactive.eai.rms.onl.common.exception.BizException;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.ui.AdapterGroupUI;
+import com.eactive.eai.rms.onl.transaction.apim.ui.ApiInterfaceExportData;
+import com.eactive.eai.rms.onl.transaction.apim.ui.ApiInterfaceReloadSyncSet;
+import com.eactive.eai.rms.onl.transaction.apim.ui.ApiInterfaceUI;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpHeaders;
+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 javax.servlet.http.HttpServletRequest;
+import java.net.URLEncoder;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+@Controller
+public class ApiInterfaceController extends OnlBaseAnnotationController {
+
+	public static final Log logger = LogFactory.getLog(ApiInterfaceController.class);
+
+	private final ApiInterfaceService service;
+	private final ClientEntityService clientEntityService;
+
+	@Autowired
+	public ApiInterfaceController(ApiInterfaceService service, ClientEntityService clientEntityService) {
+		this.service = service;
+		this.clientEntityService = clientEntityService;
+	}
+
+	@GetMapping(value = "/onl/transaction/apim/apiInterfaceMan.view")
+	public void view() {
+	}
+
+	@GetMapping(value = "/onl/transaction/apim/apiInterfaceMan.view", params = "cmd=DETAIL")
+	public String viewDetail() {
+		return "/onl/transaction/apim/apiInterfaceManDetail";
+	}
+
+	@PostMapping(value= "/onl/transaction/apim/apiInterfaceMan.json", params = "cmd=LIST")
+	public ResponseEntity<GridResponse<ApiInterfaceUI>> selectList(EAIMessageUISearch eaiMessageUISearch,
+			@RequestParam(value = "sortName", required = false, defaultValue = "lastModifiedDate") String sortname,
+	        @RequestParam(value = "sortOrder", required = false, defaultValue = "desc") String sortorder,
+																   Pageable pageable) {
+		Page<ApiInterfaceUI> page = service.selectList(eaiMessageUISearch, pageable, sortname, sortorder);
+		return ResponseEntity.ok(new GridResponse<>(page));
+	}
+
+	@PostMapping(value= "/onl/transaction/apim/apiInterfaceMan.json",params = "cmd=DETAIL")
+	public ResponseEntity<ApiInterfaceUI> selectDetail(String eaiSvcName) throws Exception {
+		ApiInterfaceUI apiInterfaceUI = service.selectDetail(eaiSvcName);
+		return ResponseEntity.ok(apiInterfaceUI);
+	}
+
+	@PostMapping(value= "/onl/transaction/apim/apiInterfaceMan.json",params = "cmd=LIST_COMBO")
+	public ResponseEntity<Map<String, Object>> selectCombo(HttpServletRequest request) throws Exception {
+		String userId = SessionManager.getUserId(request);
+		Map<String, Object> map = service.selectCombo(userId);
+		return ResponseEntity.ok(map);
+	}
+
+	@PostMapping(value= "/onl/transaction/apim/apiInterfaceMan.json",params = "cmd=LIST_DETAIL_COMBO")
+	public ResponseEntity<Map<String, Object>> selectDetailCombo(HttpServletRequest request) throws Exception {
+		String userId = SessionManager.getUserId(request);
+		Map<String, Object> map = service.selectDetailCombo(userId);
+		return ResponseEntity.ok(map);
+	}
+
+	@PostMapping(value= "/onl/transaction/apim/apiInterfaceMan.json",params = "cmd=DETAIL_ADAPTER_INFO")
+	public ResponseEntity<Map<String, Object>> getHttpAdapterInfo(String adapterGroupName) throws Exception {
+		Map<String, Object> map = service.getHttpAdapterInfo(adapterGroupName);
+		return ResponseEntity.ok(map);
+	}
+
+	@PostMapping(value= "/onl/transaction/apim/apiInterfaceMan.json",params = "cmd=DETAIL_ADAPTER_GROUP")
+	public ResponseEntity<AdapterGroupUI> selectAdapterGroupDetail(String adapterGroupName) throws Exception {
+		return ResponseEntity.ok(service.selectAdapterGroupDetail(adapterGroupName));
+	}
+
+	@PostMapping(value= "/onl/transaction/apim/apiInterfaceMan.json",params = "cmd=INSERT")
+	public ResponseEntity<Map<String, Object>> insert(ApiInterfaceUI apiInterfaceUI) throws Exception {
+		try {
+			service.insert(apiInterfaceUI);
+			Map<String, Object> resultMap = null;
+			resultMap = reloadSync(apiInterfaceUI);
+			return ResponseEntity.ok(resultMap);
+		}catch(Exception e) {
+			logger.error(e);
+			if(e instanceof BizException) {
+				throw e;
+			}
+			throw new BizException("오류가 발생했습니다. 확인바랍니다. error:"+e.getMessage(), e);
+		}
+	}
+	@PostMapping(value= "/onl/transaction/apim/apiInterfaceMan.json", params = "cmd=UPDATE")
+	public ResponseEntity<Map<String, Object>> update(ApiInterfaceUI apiInterfaceUI) throws Exception {
+		try {
+			service.update(apiInterfaceUI);
+			Map<String, Object> resultMap = null;
+			resultMap = reloadSync(apiInterfaceUI);
+			return ResponseEntity.ok(resultMap);
+		}catch(Exception e) {
+			if(e instanceof BizException) {
+				throw e;
+			}
+			if(e instanceof DuplicateKeyException) {
+				DuplicateKeyException dupEx = (DuplicateKeyException) e;
+				Throwable cause = dupEx.getMostSpecificCause();
+				throw new BizException("중복 오류가 발생했습니다. 확인바랍니다. 오류메시지: "+cause.getMessage());
+			}
+			logger.error(e);
+			throw new BizException("오류가 발생했습니다. 확인바랍니다. 오류메시지: "+e.getMessage());
+		}
+
+	}
+	@PostMapping(value= "/onl/transaction/apim/apiInterfaceMan.json",params = "cmd=DELETE")
+	public ResponseEntity<Map<String, Object>> delete(ApiInterfaceUI apiInterfaceUI) throws Exception {
+		try {
+
+			// Get affected client IDs before deleting the API
+			List<String> affectedClientIds = clientEntityService.deleteApiByEaiSvcName(apiInterfaceUI.getEaiSvcName());
+
+			// Reload affected clients
+			for (String clientId : affectedClientIds) {
+				logger.info("- Reloading client [" + clientId + "]");
+				agentUtilService.broadcast(new CommonCommand("com.eactive.eai.agent.authserver.ReloadClientCommand", clientId));
+			}
+
+			String standardMessageKey = service.delete(apiInterfaceUI);
+			Map<String, Object> resultMap = deleteSync(standardMessageKey, apiInterfaceUI);
+
+			return ResponseEntity.ok(resultMap);
+		}catch(Exception e) {
+			if(e instanceof BizException) {
+				throw e;
+			}
+			throw new BizException("오류가 발생했습니다. 확인바랍니다. error:"+e.getMessage(), e);
+		}
+	}
+
+	public Map<String, Object> reloadSync(ApiInterfaceUI apiInterfaceUI) throws Exception {
+		logger.info("- 수정 동기화 시작 [" + apiInterfaceUI.getEaiSvcName() + "]");
+
+		Command command = new CommonCommand("com.ext.eai.agent.stdmessage.ReloadSTDMessageCommand", "ALL");
+		agentUtilService.broadcast(command);
+
+		//HE01 EAI 메시지 공통부
+		CommonCommand cmdHE01 = new CommonCommand("com.eactive.eai.agent.eaimessage.ReloadEAIMessageCommand", apiInterfaceUI.getEaiSvcName());
+		HashMap<String, Object> resultMap = agentUtilService.broadcast(cmdHE01);
+		logger.info("- 수정 동기화 완료 [" + apiInterfaceUI.getEaiSvcName() + "]");
+
+		callCommandIfExists(apiInterfaceUI.getRequestTransform(), "com.eactive.eai.agent.transformer.ReloadTransformCommand");
+		callCommandIfExists(apiInterfaceUI.getResponseTransform(), "com.eactive.eai.agent.transformer.ReloadTransformCommand");
+		callCommandIfExists(apiInterfaceUI.getInboundRequestLayout(), "com.eactive.eai.agent.transformer.ReloadLayoutCommand");
+		callCommandIfExists(apiInterfaceUI.getOutboundRequestLayout(), "com.eactive.eai.agent.transformer.ReloadLayoutCommand");
+		callCommandIfExists(apiInterfaceUI.getInboundResponseLayout(), "com.eactive.eai.agent.transformer.ReloadLayoutCommand");
+		callCommandIfExists(apiInterfaceUI.getOutboundResponseLayout(), "com.eactive.eai.agent.transformer.ReloadLayoutCommand");
+		callCommandIfExists(apiInterfaceUI.getInboundErrResponseLayout(), "com.eactive.eai.agent.transformer.ReloadLayoutCommand");
+		callCommandIfExists(apiInterfaceUI.getOutboundErrResponseLayout(), "com.eactive.eai.agent.transformer.ReloadLayoutCommand");
+		return resultMap;
+	}
+
+	public Map<String, Object> deleteSync(String standardMessageKey, ApiInterfaceUI apiInterfaceUI) throws Exception {
+		logger.info("- 삭제 동기화 시작 [" + apiInterfaceUI.getEaiSvcName() + "]");
+		//HS04,HS05 내부표준전문
+		callCommandIfExists(standardMessageKey, "com.eactive.eai.agent.stdmessage.RemoveSTDMessageCommand");
+
+		//HE01 EAI 메시지 공통부
+		CommonCommand cmdHE01 = new CommonCommand("com.eactive.eai.agent.eaimessage.RemoveEAIMessageCommand", apiInterfaceUI.getEaiSvcName());
+		HashMap<String, Object> resultMap = agentUtilService.broadcast(cmdHE01);
+
+		// Transform 및 Layout 삭제
+		callCommandIfExists(apiInterfaceUI.getRequestTransform(), "com.eactive.eai.agent.transformer.RemoveTransformCommand");
+		callCommandIfExists(apiInterfaceUI.getResponseTransform(), "com.eactive.eai.agent.transformer.RemoveTransformCommand");
+		callCommandIfExists(apiInterfaceUI.getInboundRequestLayout(), "com.eactive.eai.agent.transformer.RemoveLayoutCommand");
+		callCommandIfExists(apiInterfaceUI.getOutboundRequestLayout(), "com.eactive.eai.agent.transformer.RemoveLayoutCommand");
+		callCommandIfExists(apiInterfaceUI.getInboundResponseLayout(), "com.eactive.eai.agent.transformer.RemoveLayoutCommand");
+		callCommandIfExists(apiInterfaceUI.getOutboundResponseLayout(), "com.eactive.eai.agent.transformer.RemoveLayoutCommand");
+
+		logger.info("- 삭제 동기화 완료 [" + apiInterfaceUI.getEaiSvcName() + "]");
+		return resultMap;
+	}
+
+	public void callCommandIfExists(String value, String commandName) throws Exception {
+		if (StringUtils.isNotBlank(value)) {
+			agentUtilService.broadcast(new CommonCommand(commandName, value));
+		}
+	}
+
+
+	@PostMapping(value = "/onl/transaction/apim/apiInterfaceMan.excel", params = "cmd=DETAIL_EXPORT_TO_EXCEL")
+	public ResponseEntity<byte[]> detailExportToExcel(@RequestParam(name = "eaiSvcName") String eaiSvcName) throws Exception {
+		// 단일 파일 처리
+		ApiInterfaceExportData exportData = service.exportInterfaceToExcel(eaiSvcName); // Excel 파일 내용 생성 함수(가정)
+		ApiInterfaceUI selectedUI = exportData.getApiInterfaceUI();
+		String fileName = eaiSvcName + "(" + selectedUI.getEaiSvcDesc() + ").xlsx";
+		fileName = FilenameUtils.normalize(fileName);
+		fileName = URLEncoder.encode(fileName, "UTF-8");
+
+		HttpHeaders headers = new HttpHeaders();
+		headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileName + "\"");
+		headers.add(HttpHeaders.CONTENT_TYPE, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+
+		return ResponseEntity.ok()
+				.headers(headers)
+				.body(exportData.getExportFileContent());
+	}
+
+	@PostMapping(value = "/onl/transaction/apim/apiInterfaceMan.file", params = "cmd=LIST_IMPORT_FILE")
+	public ResponseEntity<?>  listImportFromExcel(@RequestParam("file") MultipartFile file) {
+		try {
+			if (file != null) {
+				String extension = FilenameUtils.getExtension(file.getOriginalFilename()).toLowerCase();
+				if("xls".equals(extension) || "xlsx".equals(extension)){
+					ApiInterfaceReloadSyncSet apiInterfaceExportSetUI = service.importInterfaceFromExcel(file);
+					reloadSync(apiInterfaceExportSetUI.getApiInterfaceUI());
+					return ResponseEntity.ok().body("File successfully imported");
+				} else if("json".equals(extension)) {
+					ApiInterfaceReloadSyncSet apiInterfaceExportSetUI = service.importInterfaceFromJson(file);
+					reloadSync(apiInterfaceExportSetUI.getApiInterfaceUI());
+					return ResponseEntity.ok().body("File successfully imported");
+				}
+			}
+		} catch (Exception e) {
+			logger.error("Error processing file", e);
+			return ResponseEntity.internalServerError().body("Error processing file - "+e.getMessage() );
+		}
+		return ResponseEntity.internalServerError().body("empty file or unmatched extension");
+	}
+
+	@PostMapping(value = "/onl/transaction/apim/apiInterfaceMan.json", params = "cmd=DETAIL_EXPORT_TO_JSON")
+	public ResponseEntity<byte[]> detailExportToJson(@RequestParam(name = "eaiSvcName") String eaiSvcName) throws Exception {
+		// 단일 파일 처리
+		ApiInterfaceExportData exportData = service.exportInterfaceToJson(eaiSvcName);
+
+		ApiInterfaceUI selectedUI = exportData.getApiInterfaceUI();
+		String fileName = eaiSvcName + "(" + selectedUI.getEaiSvcDesc() + ").json";
+		fileName = FilenameUtils.normalize(fileName);
+		fileName = URLEncoder.encode(fileName, "UTF-8");
+
+		HttpHeaders headers = new HttpHeaders();
+		headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileName + "\"");
+		headers.add(HttpHeaders.CONTENT_TYPE, "application/json");
+
+		return ResponseEntity.ok()
+				.headers(headers)
+				.body(exportData.getExportFileContent());
+	}
+
+	@PostMapping(value = "/onl/transaction/apim/apiInterfaceMan.json", params = "cmd=INSERT_CLONE")
+	public ResponseEntity<?>  cloneApiInterface(String orgApiInterfaceId, String newBizCode, String newApiInterfaceId, String newInboundHttpMethod, String newInboundRestPath) throws BizException {
+		try {
+			ApiInterfaceUI orgApiInterfaceUI = service.selectDetail(orgApiInterfaceId);
+			ApiInterfaceUI apiInterfaceUI = service.cloneApiInterface(orgApiInterfaceUI, newBizCode, newApiInterfaceId, newInboundHttpMethod, newInboundRestPath);
+			Map<String, Object> resultMap = reloadSync(apiInterfaceUI);
+			return ResponseEntity.ok(resultMap);
+		} catch(Exception e) {
+			if(e instanceof DuplicateKeyException) {
+				DuplicateKeyException dupEx = (DuplicateKeyException) e;
+				Throwable cause = dupEx.getMostSpecificCause();
+				throw new BizException("중복 오류가 발생했습니다. 확인바랍니다. 오류메시지: "+cause.getMessage());
+			}
+			logger.error(e);
+			throw new BizException("오류가 발생했습니다. 확인바랍니다. 오류메시지: "+e.getMessage());
+		}
+	}
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/ApiInterfaceDao.java

@@ -0,0 +1,27 @@
+package com.eactive.eai.rms.onl.transaction.apim;
+
+import java.util.HashMap;
+import java.util.List;
+
+import org.springframework.stereotype.Repository;
+
+import com.eactive.eai.rms.common.base.SqlMapClientTemplateDao;
+import com.eactive.eai.transformer.util.Logger;
+
+@Repository("apiInterfaceDao")
+public class ApiInterfaceDao extends SqlMapClientTemplateDao {
+
+	private static final Logger logger = Logger.getLogger(ApiInterfaceDao.class);
+
+	public int selectListCount(HashMap<?, ?> paramMap) throws Exception {
+		return (Integer) template.queryForObject("Interface.selectListCount", paramMap);
+	}
+
+	public List<?> selectList(HashMap<?, ?> paramMap) throws Exception {
+		return template.queryForList("Interface.selectList", paramMap);
+	}
+
+	public HashMap selectDetail(HashMap paramMap) throws Exception {
+		return (HashMap) template.queryForObject("Interface.selectDetail", paramMap);
+	}
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/ApiSpecController.java

@@ -0,0 +1,156 @@
+package com.eactive.eai.rms.onl.transaction.apim;
+
+import com.eactive.apim.portal.portalorg.entity.PortalOrg;
+import com.eactive.apim.portal.portalorg.entity.PortalOrgEnums;
+import com.eactive.eai.data.entity.onl.transformer.layout.LayoutEntity;
+import com.eactive.eai.rms.common.base.OnlBaseAnnotationController;
+import com.eactive.eai.rms.common.datasource.DataSourceContextHolder;
+import com.eactive.eai.rms.common.vo.GridResponse;
+import com.eactive.eai.rms.data.entity.onl.apim.portalorg.PortalOrgUISearch;
+import com.eactive.eai.rms.data.entity.onl.layout.LayoutService;
+import com.eactive.eai.rms.onl.apim.portalorg.PortalOrgManService;
+import com.eactive.eai.rms.onl.apim.portalorg.PortalOrgUI;
+import com.eactive.eai.rms.onl.common.exception.BizException;
+import com.eactive.eai.rms.onl.manage.rule.layout.mapper.LayoutUIMapper;
+import com.eactive.eai.rms.onl.manage.rule.layout.ui.LayoutUI;
+import com.eactive.eai.rms.onl.transaction.apim.ui.ApiInterfaceUI;
+import com.eactive.eai.rms.onl.transaction.apim.ui.ApiSpecInfoUI;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+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.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.web.SortDefault;
+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;
+
+@Controller
+public class ApiSpecController extends OnlBaseAnnotationController {
+
+    @Autowired
+    ApiSpecManService apiSpecManService;
+
+    @Autowired
+    PortalOrgManService portalOrgManService;
+
+    @Autowired
+    ApiInterfaceService apiInterfaceService;
+
+    @GetMapping(value = "/onl/transaction/apim/apiSpecMan.view", params = "cmd=DETAIL")
+    public String viewDetail() {
+        return "/onl/transaction/apim/apiSpecManPopup";
+    }
+
+    @GetMapping(value = "/onl/transaction/apim/apiSpecManPopup.view", params = "cmd=POPUP_LIST")
+    public String detailOrgPopupView() {
+        return "/onl/transaction/apim/apiSpecManDisplayOrgPopup";
+    }
+
+    @PostMapping(value = "/onl/transaction/apim/apiSpecMan.json", params = "cmd=DETAIL")
+    public ResponseEntity<ApiSpecInfoUI> selectDetail(String eaiSvcName) {
+        ApiSpecInfoUI specInfo = apiSpecManService.selectDetail(eaiSvcName);
+
+        if (StringUtils.isNotBlank(specInfo.getDisplayOrg())) {
+            String orgNames = Arrays.stream(specInfo.getDisplayOrg().split(","))
+                    .map(orgId -> portalOrgManService.findById(orgId))
+                    .filter(Optional::isPresent)
+                    .map(Optional::get)
+                    .map(PortalOrg::getOrgName)
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.joining(", "));
+
+            specInfo.setOrgName(orgNames);
+        }
+
+        return ResponseEntity.ok(specInfo);
+    }
+
+    @PostMapping(value = "/onl/transaction/apim/apiSpecMan.json", params = "cmd=INSERT")
+    public ResponseEntity<Map<String, Object>> save(ApiSpecInfoUI apiSpecInfoUI) throws Exception {
+        try {
+            apiSpecInfoUI.setApiRequestSpec(StringEscapeUtils.unescapeHtml(apiSpecInfoUI.getApiRequestSpec()));
+            apiSpecInfoUI.setApiResponseSpec(StringEscapeUtils.unescapeHtml(apiSpecInfoUI.getApiResponseSpec()));
+            apiSpecInfoUI.setDescription(StringEscapeUtils.unescapeHtml(apiSpecInfoUI.getDescription()));
+            apiSpecInfoUI.setTestbedSpec(StringEscapeUtils.unescapeHtml(apiSpecInfoUI.getTestbedSpec()));
+
+            apiSpecManService.save(apiSpecInfoUI);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            logger.error(e);
+            if (e instanceof BizException) {
+                throw e;
+            }
+            throw new BizException("오류가 발생했습니다. 확인바랍니다. error:" + e.getMessage(), e);
+        }
+    }
+
+    @PostMapping(value = "/onl/transaction/apim/apiSpecMan.json", params = "cmd=DELETE")
+    public ResponseEntity<Map<String, Object>> delete(ApiSpecInfoUI apiSpecInfoUI) throws Exception {
+        try {
+            apiSpecManService.delete(apiSpecInfoUI);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            if (e instanceof BizException) {
+                throw e;
+            }
+            throw new BizException("오류가 발생했습니다. 확인바랍니다. error:" + e.getMessage(), e);
+        }
+    }
+    @PostMapping(value = "/onl/transaction/apim/apiSpecMan.json", params = "cmd=GENERATE_SPEC")
+    public ResponseEntity<Map<String, String>> generateSpec(ApiSpecInfoUI apiSpecInfoUI) {
+        try {
+            if (apiSpecInfoUI == null || StringUtils.isEmpty(apiSpecInfoUI.getApiId())) {
+                throw new BizException("API ID가 존재하지 않습니다.");
+            }
+
+            ApiInterfaceUI apiInterfaceUI = apiInterfaceService.selectDetail(apiSpecInfoUI.getApiId());
+            if (apiInterfaceUI == null) {
+                throw new BizException("API 인터페이스 정보를 찾을 수 없습니다.");
+            }
+
+            Map<String, String> inboundAdapterSpec = apiInterfaceService.getHttpAdapterInfo(apiInterfaceUI.getFromAdapter());
+            if (inboundAdapterSpec == null) {
+                inboundAdapterSpec = new HashMap<>();
+            }
+
+            String requestLayoutName = apiInterfaceUI.getInboundRequestLayout();
+            String responseLayoutName = apiInterfaceUI.getInboundResponseLayout();
+
+            // Layout 정보 조회. 없으면 null.
+            LayoutUI requestLayoutUI = StringUtils.isNotEmpty(requestLayoutName) ?
+                    apiSpecManService.selectLayoutUI(requestLayoutName) : null;
+            LayoutUI responseLayoutUI = StringUtils.isNotEmpty(responseLayoutName) ?
+                    apiSpecManService.selectLayoutUI(responseLayoutName) : null;
+
+            Map<String, String> result = new HashMap<>();
+
+            // Layout이 없어도 generateSpecTableFromLayout과 generateSampleDataFromLayout 메서드를 호출
+            // 각 메서드 내부에서 샘플 레이아웃을 생성하여 처리
+            result.put("requestSpec", apiSpecManService.generateSpecTableFromLayout(requestLayoutUI));
+            result.put("responseSpec", apiSpecManService.generateSpecTableFromLayout(responseLayoutUI));
+            result.put("sampleRequest", apiSpecManService.generateSampleDataFromLayout(requestLayoutUI));
+            result.put("sampleResponse", apiSpecManService.generateSampleDataFromLayout(responseLayoutUI));
+
+            // Swagger/OpenAPI 스펙 생성
+            String swaggerSpec = apiSpecManService.generateSwaggerSpec(requestLayoutUI, responseLayoutUI,
+                    inboundAdapterSpec, apiInterfaceUI);
+            result.put("testbedSpec", swaggerSpec);
+
+            return ResponseEntity.ok(result);
+        } catch (BizException e) {
+            throw e;
+        } catch (Exception e) {
+            logger.error("API 스펙 생성 중 오류 발생", e);
+            throw new BizException("API 스펙 생성 중 오류가 발생했습니다: " + e.getMessage(), e);
+        }
+    }
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/ApiSpecManService.java

@@ -0,0 +1,657 @@
+package com.eactive.eai.rms.onl.transaction.apim;
+
+import com.eactive.apim.portal.apispec.entity.ApiSpecInfo;
+import com.eactive.apim.portal.apispec.service.ApiSpecInfoService;
+import com.eactive.eai.data.entity.onl.transformer.layout.LayoutEntity;
+import com.eactive.eai.rms.data.entity.onl.layout.LayoutService;
+import com.eactive.eai.rms.onl.common.exception.BizException;
+import com.eactive.eai.rms.onl.manage.rule.layout.mapper.LayoutUIMapper;
+import com.eactive.eai.rms.onl.manage.rule.layout.ui.LayoutItemUI;
+import com.eactive.eai.rms.onl.manage.rule.layout.ui.LayoutUI;
+import com.eactive.eai.rms.onl.transaction.apim.mapping.ApiSpecUIMapper;
+import com.eactive.eai.rms.onl.transaction.apim.ui.ApiInterfaceUI;
+import com.eactive.eai.rms.onl.transaction.apim.ui.ApiSpecInfoUI;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Service
+@Transactional
+public class ApiSpecManService {
+
+    @Autowired
+    private ApiSpecInfoService apiSpecInfoService;
+
+    @Autowired
+    private ApiSpecUIMapper apiSpecUIMapper;
+
+    @Autowired
+    private LayoutService layoutService;
+
+    @Autowired
+    private LayoutUIMapper layoutUIMapper;
+
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    public ApiSpecInfoUI selectDetail(String eaiSvcName) {
+        Optional<ApiSpecInfo> apiSpecInfo = apiSpecInfoService.findById(eaiSvcName);
+        return apiSpecUIMapper.map(apiSpecInfo);
+    }
+
+    public void delete(ApiSpecInfoUI apiSpecInfoUI) {
+        if (apiSpecInfoUI.getApiId() == null) {
+            throw new BizException("API specification ID is required for deletion");
+        }
+
+        apiSpecInfoService.deleteById(apiSpecInfoUI.getApiId());
+    }
+
+    public void save(ApiSpecInfoUI apiSpecInfoUI) {
+        if (StringUtils.isEmpty(apiSpecInfoUI.getApiId())) {
+            throw new BizException("Failed to insert API specification");
+        }
+
+        ApiSpecInfo apiSpecInfo = apiSpecUIMapper.mapToEntity(apiSpecInfoUI);
+
+        Optional<ApiSpecInfo> optSpec = apiSpecInfoService.findById(apiSpecInfo.getApiId());
+        if (optSpec.isPresent()) {
+            ApiSpecInfo updatedApiSpec = apiSpecInfoService.updateById(apiSpecInfo.getApiId(), apiSpecInfo);
+            if (updatedApiSpec == null) {
+                throw new BizException("Failed to update API specification. Specification not found.");
+            }
+        } else {
+            apiSpecInfoService.create(apiSpecInfo);
+        }
+    }
+
+    public LayoutUI selectLayoutUI(String layoutName){
+        // Layout 서비스를 통해 Layout 정보 조회
+        LayoutEntity layoutEntity = layoutService.getById(layoutName);
+        // layout detail 조회
+        LayoutUI layoutUI = layoutUIMapper.toVo(layoutEntity);
+        return layoutUI;
+    }
+
+    private LayoutUI createSampleLayout() {
+        LayoutUI sampleLayout = new LayoutUI();
+        sampleLayout.setLoutName("SAMPLE_LAYOUT");
+
+        List<LayoutItemUI> layoutItems = new ArrayList<>();
+
+        // 루트 아이템 (항상 있어야 함)
+        LayoutItemUI rootItem = new LayoutItemUI();
+        rootItem.setLoutItemSerno(0);
+        rootItem.setLoutItemDepth(0);
+        rootItem.setLoutItemType("GROUP");
+        rootItem.setLoutitempath("SAMPLE_LAYOUT");
+        layoutItems.add(rootItem);
+
+        // 샘플 필드
+        LayoutItemUI sampleField = new LayoutItemUI();
+        sampleField.setLoutItemSerno(1);
+        sampleField.setLoutItemDepth(1);
+        sampleField.setLoutItemName("sampleField");
+        sampleField.setLoutItemDesc("샘플 필드입니다. 실제 레이아웃을 정의해주세요.");
+        sampleField.setLoutItemType("FIELD");
+        sampleField.setLoutItemDataType("STRING");
+        sampleField.setLoutItemLength(100);
+        sampleField.setLoutitempath("SAMPLE_LAYOUT.sampleField");
+        layoutItems.add(sampleField);
+
+        sampleLayout.setLayoutItems(layoutItems);
+        return sampleLayout;
+    }
+
+    public String generateSpecTableFromLayout(LayoutUI layout) {
+        if (layout == null || layout.getLayoutItems() == null || layout.getLayoutItems().isEmpty()) {
+            layout = createSampleLayout();
+        }
+
+        // 기존 메서드 로직 그대로 사용
+        StringBuilder html = new StringBuilder();
+        html.append("<table class='api_table tb_col' cellspacing='0' cellpadding='0' width='100%'>")
+                .append("<colgroup>\n")
+                //.append("<col width='5%'>\n")   // No
+                .append("<col width='8%'>\n")   // 구분 (Header/Body)
+                .append("<col width='23%'>\n")  // 이름
+                .append("<col width='29%'>\n")  // 설명
+                .append("<col width='7%'>\n")   // 필수여부
+                .append("<col width='10%'>\n")  // 항목유형
+                .append("<col width='15%'>\n")  // 데이터유형
+                .append("<col width='8%'>\n")   // 길이
+                .append("</colgroup>\n")
+                .append("<thead>\n")
+                .append("<tr>\n")
+                //.append("<th style='text-align: center;'>No</th>\n")
+                .append("<th style='text-align: center;'>구분</th>\n")
+                .append("<th style='text-align: center;'>이름</th>\n")
+                .append("<th style='text-align: center;'>설명</th>\n")
+                .append("<th style='text-align: center;'>필수여부</th>\n")
+                .append("<th style='text-align: center;'>항목유형</th>\n")
+                .append("<th style='text-align: center;'>데이터유형</th>\n")
+                .append("<th style='text-align: center;'>길이</th>\n")
+                .append("</tr>\n")
+                .append("</thead>\n")
+                .append("<tbody>\n");
+
+        generateSpecTableRows(layout.getLayoutItems(), html);
+        html.append("</tbody></table>");
+
+        return html.toString();
+    }
+
+    private void generateSpecTableRows(List<LayoutItemUI> items, StringBuilder html) {
+        if (items == null || items.isEmpty()) {
+            return;
+        }
+
+        // serno=0인 root 항목 건너뛰기
+        int startIndex = 0;
+        while (startIndex < items.size() && items.get(startIndex).getLoutItemSerno() == 0) {
+            startIndex++;
+        }
+
+        // HTTP 헤더 그룹 찾기
+        Optional<LayoutItemUI> headerGroup = items.stream()
+                .filter(item -> "http_header_part".equals(item.getLoutItemName()) && "GROUP".equalsIgnoreCase(item.getLoutItemType()))
+                .findFirst();
+
+        Set<String> headerItemPaths = new HashSet<>();
+        if (headerGroup.isPresent()) {
+            // 헤더 그룹의 모든 하위 항목의 경로를 저장
+            String headerPath = headerGroup.get().getLoutitempath();
+            headerItemPaths = items.stream()
+                    .filter(item -> item.getLoutitempath() != null && item.getLoutitempath().startsWith(headerPath))
+                    .map(LayoutItemUI::getLoutitempath)
+                    .collect(Collectors.toSet());
+        }
+
+        int currentDepth = 1;
+        Stack<Integer> depthStack = new Stack<>();
+        depthStack.push(currentDepth);
+        int seqNo = 1;
+
+        for (int i = startIndex; i < items.size(); i++) {
+            LayoutItemUI item = items.get(i);
+
+            // http_header_part GROUP 항목은 테이블에서 제외
+            if ("http_header_part".equals(item.getLoutItemName()) && "GROUP".equalsIgnoreCase(item.getLoutItemType())) {
+                continue;
+            }
+
+            int itemDepth = item.getLoutItemDepth();
+
+            // depth 변화에 따른 처리
+            if (itemDepth > currentDepth) {
+                depthStack.push(itemDepth);
+            } else if (itemDepth < currentDepth) {
+                while (!depthStack.isEmpty() && depthStack.peek() >= itemDepth) {
+                    depthStack.pop();
+                }
+                depthStack.push(itemDepth);
+            }
+            currentDepth = itemDepth;
+
+            // 해당 항목이 헤더에 속하는지 확인
+            boolean isHeader = headerItemPaths.contains(item.getLoutitempath());
+            String fieldName = item.getLoutItemName();
+            if(!isHeader) {
+                String indentation = getIndentation(depthStack.size() - 1);
+                fieldName = indentation + fieldName;
+            }
+
+            String dataType = "FIELD".equalsIgnoreCase(item.getLoutItemType()) ?
+                    mapDataType(item.getLoutItemDataType()) : "";
+
+            html.append("<tr>")
+                    //.append("<td style='text-align: center;'>").append(seqNo++).append("</td>")
+                    .append("<td style='text-align: center;'>").append(isHeader ? "Header" : "Body").append("</td>")
+                    // 두 번째 열(fieldName)에 대해 왼쪽 정렬과 공백 처리를 위한 스타일 적용
+                    .append("<td style='text-align: left; padding-left: calc(2% + 4px); white-space: nowrap; overflow: hidden; text-overflow: ellipsis;'>")
+                    .append(fieldName)
+                    .append("</td>")
+                    .append("<td style='text-align: left; padding-left: calc(2% + 4px); white-space: nowrap; overflow: hidden; text-overflow: ellipsis;'>")
+                    .append(item.getLoutItemDesc())
+                    .append("</td>")
+                    .append("<td style='text-align: center;'></td>")
+                    .append("<td style='text-align: center;'>").append(getItemTypeDisplay(item)).append("</td>")
+                    .append("<td style='text-align: center;'>").append(dataType).append("</td>")
+                    .append("<td style='text-align: right;'>").append(item.getLoutItemLength()).append("</td>")
+                    .append("</tr>\n");
+        }
+    }
+
+    public String generateSampleDataFromLayout(LayoutUI layout) {
+        if (layout == null || layout.getLayoutItems() == null || layout.getLayoutItems().isEmpty()) {
+            layout = createSampleLayout();
+        }
+
+        // 빈 root node 생성
+        ObjectNode rootNode = objectMapper.createObjectNode();
+        Map<String, ObjectNode> nodeMap = new HashMap<>();
+        nodeMap.put(layout.getLoutName(), rootNode);  // root는 LoutName을 key로 저장
+
+        // http_header_part GROUP을 찾아서 처리 제외
+        Optional<LayoutItemUI> headerGroup = layout.getLayoutItems().stream()
+                .filter(item -> "http_header_part".equals(item.getLoutItemName()) && "GROUP".equalsIgnoreCase(item.getLoutItemType()))
+                .findFirst();
+
+        Set<String> headerItemPaths = new HashSet<>();
+        if (headerGroup.isPresent()) {
+            String headerPath = headerGroup.get().getLoutitempath();
+            headerItemPaths = layout.getLayoutItems().stream()
+                    .filter(item -> item.getLoutitempath() != null && item.getLoutitempath().startsWith(headerPath))
+                    .map(LayoutItemUI::getLoutitempath)
+                    .collect(Collectors.toSet());
+        }
+
+        // List를 1번 인덱스부터 순차적으로 파싱
+        List<LayoutItemUI> items = layout.getLayoutItems();
+        for (int i = 1; i < items.size(); i++) {
+            LayoutItemUI item = items.get(i);
+
+            // 헤더 항목은 건너뛰기
+            if (headerItemPaths.contains(item.getLoutitempath())) {
+                continue;
+            }
+
+            String parentPath = getParentPath(item.getLoutitempath());
+            ObjectNode parentNode = nodeMap.get(parentPath);
+
+            switch (item.getLoutItemType().toUpperCase()) {
+                case "FIELD":
+                    addFieldValue(parentNode, item);
+                    break;
+
+                case "GROUP":
+                    ObjectNode groupNode = parentNode.putObject(item.getLoutItemName());
+                    nodeMap.put(item.getLoutitempath(), groupNode);
+                    break;
+
+                case "GRID":
+                    ArrayNode arrayNode = parentNode.putArray(item.getLoutItemName());
+                    ObjectNode arrayItem = arrayNode.addObject();
+                    nodeMap.put(item.getLoutitempath(), arrayItem);
+                    break;
+            }
+        }
+
+        try {
+            return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(rootNode);
+        } catch (Exception e) {
+            throw new BizException("Failed to generate sample data", e);
+        }
+    }
+
+
+    private String getItemTypeDisplay(LayoutItemUI item) {
+        switch (item.getLoutItemType().toUpperCase()) {
+            case "FIELD":
+                return "Field";
+            case "GROUP":
+                return "Object";
+            case "GRID":
+                return "Array<Obj>";
+            default:
+                return item.getLoutItemType();
+        }
+    }
+
+    private String mapDataType(String dataType) {
+        if (dataType == null) return "string";  // JSON 스펙에 맞춰 소문자로
+        switch (dataType.toUpperCase()) {
+            case "INTEGER":
+            case "INT":
+            case "LONG":
+            case "DECIMAL":
+            case "DOUBLE":
+            case "BIGDECIMAL":
+                return "Number";    // 동일하게 number
+            case "BOOLEAN":
+                return "Bool";
+            default:
+                return "String";    // 기본값은 string
+        }
+    }
+
+
+    private String getParentPath(String path) {
+        int lastDotIndex = path.lastIndexOf('.');
+        return lastDotIndex > 0 ? path.substring(0, lastDotIndex) : "";  // root의 경우 LoutName 반환
+    }
+
+    private void addFieldValue(ObjectNode node, LayoutItemUI item) {
+        String dataType = item.getLoutItemDataType();
+        String defaultValue = item.getLoutItemDefault();
+        String fieldName = item.getLoutItemName();
+
+        boolean isInteger = isIntegerType(dataType);
+
+        if (isNumericType(dataType)) {
+            if (StringUtils.isNotEmpty(defaultValue)) {
+                try {
+                    if (isInteger) {
+                        node.put(fieldName, Integer.parseInt(defaultValue));
+                    } else {
+                        node.put(fieldName, Double.parseDouble(defaultValue));
+                    }
+                } catch (NumberFormatException e) {
+                    node.put(fieldName, isInteger ? 0 : 0.0);
+                }
+            } else {
+                node.put(fieldName, isInteger ? 0 : 0.0);
+            }
+        } else if ("BOOLEAN".equalsIgnoreCase(dataType)) {
+            node.put(fieldName, StringUtils.isNotEmpty(defaultValue) ?
+                    Boolean.parseBoolean(defaultValue) : false);
+        } else {
+            node.put(fieldName, StringUtils.isNotEmpty(defaultValue) ?
+                    defaultValue : "sample_" + fieldName);
+        }
+    }
+
+    private boolean isIntegerType(String dataType) {
+        if (dataType == null) return false;
+        switch (dataType.toUpperCase()) {
+            case "INTEGER":
+            case "INT":
+            case "LONG":
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private boolean isNumericType(String dataType) {
+        if (isIntegerType(dataType)) return true;
+        if (dataType == null) return false;
+
+        switch (dataType.toUpperCase()) {
+            case "DECIMAL":
+            case "DOUBLE":
+            case "BIGDECIMAL":
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private String getIndentation(int depth) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < depth; i++) {
+            sb.append("&nbsp;&nbsp;&nbsp;&nbsp;");
+        }
+        return sb.toString();
+    }
+
+
+    /**
+     * Generates OpenAPI 3.0 specification for the given layout and API information
+     */
+    public String generateSwaggerSpec(LayoutUI requestLayout, LayoutUI responseLayout,
+                                      Map<String, String> inboundAdapterSpec, ApiInterfaceUI apiInterface) {
+        if (apiInterface == null) {
+            throw new BizException("API 인터페이스 정보가 존재하지 않습니다.");
+        }
+
+        if (StringUtils.isEmpty(apiInterface.getInboundRestPath())) {
+            throw new BizException("REST API 경로 정보가 존재하지 않습니다.");
+        }
+
+        if (StringUtils.isEmpty(apiInterface.getInboundHttpMethod())) {
+            throw new BizException("HTTP 메소드 정보가 존재하지 않습니다.");
+        }
+
+        try {
+            ObjectMapper objectMapper = new ObjectMapper();
+            ObjectNode swaggerSpec = objectMapper.createObjectNode();
+
+            // OpenAPI version
+            swaggerSpec.put("openapi", "3.0.0");
+
+            // Info section
+            ObjectNode info = swaggerSpec.putObject("info");
+            info.put("title", StringUtils.defaultString(apiInterface.getEaiSvcName(), "API Specification"));
+            info.put("version", "1.0.0");
+
+            // Servers section
+            ArrayNode servers = swaggerSpec.putArray("servers");
+            ObjectNode server = servers.addObject();
+            String baseUrl = StringUtils.defaultString(inboundAdapterSpec.get("urlPath"), "/");
+            server.put("url", baseUrl);
+
+            // Paths section
+            ObjectNode paths = swaggerSpec.putObject("paths");
+            String pathUrl = apiInterface.getInboundRestPath();
+            if (!pathUrl.startsWith("/")) {
+                pathUrl = "/" + pathUrl;
+            }
+
+            ObjectNode pathItem = paths.putObject(pathUrl);
+            String httpMethod = apiInterface.getInboundHttpMethod().toLowerCase();
+            ObjectNode operation = pathItem.putObject(httpMethod);
+
+            // Operation details
+            operation.put("summary", StringUtils.defaultString(apiInterface.getEaiSvcName(), "API Operation"));
+            ArrayNode tags = operation.putArray("tags");
+            tags.add("KBANK API");
+
+            // Request 처리
+            if (requestLayout != null && requestLayout.getLayoutItems() != null) {
+                // 헤더/바디 분리
+                RequestComponents components = separateHeaderAndBody(requestLayout.getLayoutItems());
+
+                // 헤더 파라미터 처리
+                if (!components.headerItems.isEmpty()) {
+                    ArrayNode parameters = operation.putArray("parameters");
+                    generateHeaderParameters(parameters, components.headerItems);
+                }
+
+                // Body 처리 (POST, PUT 메소드인 경우)
+                if (isRequestBodyRequired(httpMethod)) {
+                    ObjectNode requestBody = operation.putObject("requestBody");
+                    requestBody.put("required", true);
+                    ObjectNode content = requestBody.putObject("content");
+                    ObjectNode mediaType = content.putObject(getContentType(apiInterface));
+                    ObjectNode schema = mediaType.putObject("schema");
+                    generateSchemaFromLayoutItems(schema, components.bodyItems);
+                }
+            }
+
+            // Response 처리
+            ObjectNode responses = operation.putObject("responses");
+            ObjectNode successResponse = responses.putObject("200");
+            successResponse.put("description", "Successful response");
+
+            if (responseLayout != null && responseLayout.getLayoutItems() != null) {
+                // 응답 헤더/바디 분리
+                RequestComponents responseComponents = separateHeaderAndBody(responseLayout.getLayoutItems());
+
+                // 응답 헤더 처리
+                if (!responseComponents.headerItems.isEmpty()) {
+                    ObjectNode headers = successResponse.putObject("headers");
+                    generateResponseHeaders(headers, responseComponents.headerItems);
+                }
+
+                // 응답 바디 처리
+                ObjectNode responseContent = successResponse.putObject("content");
+                ObjectNode responseMediaType = responseContent.putObject(getContentType(apiInterface));
+                ObjectNode responseSchema = responseMediaType.putObject("schema");
+                generateSchemaFromLayoutItems(responseSchema, responseComponents.bodyItems);
+            } else {
+                // 응답 레이아웃이 없는 경우 기본 응답 스키마
+                ObjectNode responseContent = successResponse.putObject("content");
+                ObjectNode responseMediaType = responseContent.putObject(getContentType(apiInterface));
+                ObjectNode responseSchema = responseMediaType.putObject("schema");
+                responseSchema.put("type", "object");
+                responseSchema.put("description", "응답 레이아웃이 정의되지 않았습니다.");
+            }
+
+            return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(swaggerSpec);
+        } catch (Exception e) {
+            throw new BizException("Swagger 스펙 생성 중 오류가 발생했습니다: " + e.getMessage(), e);
+        }
+    }
+
+    private static class RequestComponents {
+        List<LayoutItemUI> headerItems = new ArrayList<>();
+        List<LayoutItemUI> bodyItems = new ArrayList<>();
+    }
+
+    private RequestComponents separateHeaderAndBody(List<LayoutItemUI> items) {
+        RequestComponents components = new RequestComponents();
+        if (items == null || items.isEmpty()) {
+            return components;
+        }
+
+        // HTTP 헤더 그룹 찾기
+        Optional<LayoutItemUI> headerGroup = items.stream()
+                .filter(item -> "http_header_part".equals(item.getLoutItemName()) && "GROUP".equalsIgnoreCase(item.getLoutItemType()))
+                .findFirst();
+
+        Set<String> headerItemPaths = new HashSet<>();
+        if (headerGroup.isPresent()) {
+            String headerPath = headerGroup.get().getLoutitempath();
+            headerItemPaths = items.stream()
+                    .filter(item -> item.getLoutitempath() != null && item.getLoutitempath().startsWith(headerPath))
+                    .map(LayoutItemUI::getLoutitempath)
+                    .collect(Collectors.toSet());
+        }
+
+        // 아이템 분류
+        for (LayoutItemUI item : items) {
+            // http_header_part GROUP 항목 자체는 제외
+            if ("http_header_part".equals(item.getLoutItemName()) && "GROUP".equalsIgnoreCase(item.getLoutItemType())) {
+                continue;
+            }
+
+            if (headerItemPaths.contains(item.getLoutitempath())) {
+                components.headerItems.add(item);
+            } else {
+                components.bodyItems.add(item);
+            }
+        }
+
+        return components;
+    }
+
+    private void generateHeaderParameters(ArrayNode parameters, List<LayoutItemUI> headerItems) {
+        for (LayoutItemUI item : headerItems) {
+            if ("FIELD".equalsIgnoreCase(item.getLoutItemType())) {
+                ObjectNode parameter = parameters.addObject();
+                parameter.put("name", item.getLoutItemName());
+                parameter.put("in", "header");
+                parameter.put("description", item.getLoutItemDesc());
+                parameter.put("required", false); // 기본값으로 false 설정, 필요시 true로 변경 가능
+
+                ObjectNode schema = parameter.putObject("schema");
+                schema.put("type", mapSwaggerType(item.getLoutItemDataType()));
+                int length = item.getLoutItemLength();
+                if (length > 0) {
+                    schema.put("maxLength", item.getLoutItemLength());
+                }
+            }
+        }
+    }
+
+    private void generateResponseHeaders(ObjectNode headers, List<LayoutItemUI> headerItems) {
+        for (LayoutItemUI item : headerItems) {
+            if ("FIELD".equalsIgnoreCase(item.getLoutItemType())) {
+                ObjectNode header = headers.putObject(item.getLoutItemName());
+                header.put("description", item.getLoutItemDesc());
+                ObjectNode schema = header.putObject("schema");
+                schema.put("type", mapSwaggerType(item.getLoutItemDataType()));
+                int length = item.getLoutItemLength();
+                if (length > 0) {
+                    schema.put("maxLength", item.getLoutItemLength());
+                }
+            }
+        }
+    }
+
+    private void generateSchemaFromLayoutItems(ObjectNode schemaNode, List<LayoutItemUI> layoutItems) {
+        if (layoutItems == null || layoutItems.isEmpty()) {
+            schemaNode.put("type", "object");
+            return;
+        }
+
+        schemaNode.put("type", "object");
+        ObjectNode properties = schemaNode.putObject("properties");
+
+        Map<Integer, ObjectNode> depthMap = new HashMap<>();
+        depthMap.put(0, properties);
+
+        for (LayoutItemUI item : layoutItems) {
+            if (item.getLoutItemSerno() == 0) continue;
+
+            ObjectNode parentNode = depthMap.get(item.getLoutItemDepth() - 1);
+            if (parentNode == null) continue;
+
+            switch (item.getLoutItemType().toUpperCase()) {
+                case "FIELD":
+                    ObjectNode fieldSchema = parentNode.putObject(item.getLoutItemName());
+                    fieldSchema.put("type", mapSwaggerType(item.getLoutItemDataType()));
+                    if (StringUtils.isNotEmpty(item.getLoutItemDesc())) {
+                        fieldSchema.put("description", item.getLoutItemDesc());
+                    }
+                    int length = item.getLoutItemLength();
+                    if (length > 0) {
+                        fieldSchema.put("maxLength", item.getLoutItemLength());
+                    }
+                    break;
+
+                case "GROUP":
+                    ObjectNode groupSchema = parentNode.putObject(item.getLoutItemName());
+                    groupSchema.put("type", "object");
+                    ObjectNode groupProps = groupSchema.putObject("properties");
+                    depthMap.put(item.getLoutItemDepth(), groupProps);
+                    break;
+
+                case "GRID":
+                    ObjectNode arraySchema = parentNode.putObject(item.getLoutItemName());
+                    arraySchema.put("type", "array");
+                    ObjectNode arrayItemSchema = arraySchema.putObject("items");
+                    arrayItemSchema.put("type", "object");
+                    ObjectNode arrayItemProps = arrayItemSchema.putObject("properties");
+                    depthMap.put(item.getLoutItemDepth(), arrayItemProps);
+                    break;
+            }
+        }
+    }
+
+    private String mapSwaggerType(String dataType) {
+        if (dataType == null) return "string";
+
+        switch (dataType.toUpperCase()) {
+            case "INTEGER":
+            case "INT":
+                return "integer";
+            case "LONG":
+                return "integer";
+            case "DECIMAL":
+            case "DOUBLE":
+                return "number";
+            case "BOOLEAN":
+                return "boolean";
+            default:
+                return "string";
+        }
+    }
+
+    private boolean isRequestBodyRequired(String method) {
+        if (method == null) return false;
+        return "POST".equalsIgnoreCase(method) || "PUT".equalsIgnoreCase(method);
+    }
+
+    private String getContentType(ApiInterfaceUI apiInterface) {
+        String contentType = apiInterface.getRestContentType();
+        return StringUtils.defaultIfEmpty(contentType, "application/json");
+    }
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/BizCodeQueryServiceForApi.java

@@ -0,0 +1,23 @@
+package com.eactive.eai.rms.onl.transaction.apim;
+
+import java.util.List;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.eactive.eai.data.entity.onl.unifbwk.UnifBwkTp;
+import com.eactive.eai.rms.data.entity.onl.unifbwk.UnifBwkTpService;
+
+@Repository
+@Transactional
+public class BizCodeQueryServiceForApi {
+
+	@Autowired
+	private UnifBwkTpService unifBwkTpService;
+
+	public List<UnifBwkTp> selectUserBizCodes(String userId) {
+		return unifBwkTpService.findUserBizCodesByUserId(userId);
+	}
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/StandardMessageInfoQueryServiceForApi.java

@@ -0,0 +1,26 @@
+package com.eactive.eai.rms.onl.transaction.apim;
+
+import java.util.Optional;
+
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.eactive.eai.data.entity.onl.stdmessage.StandardMessageInfo;
+import com.eactive.eai.data.jpa.AbstractDataService;
+import com.eactive.eai.rms.onl.transaction.apim.repository.StandardMessageInfoRepositoryForApi;
+
+//현재 ems에 내부표준메시지가 작성되지 않아 임시로 사용
+@Repository
+@Transactional
+public class StandardMessageInfoQueryServiceForApi extends AbstractDataService<StandardMessageInfo, String, StandardMessageInfoRepositoryForApi> {
+
+    public Optional<StandardMessageInfo> findByEaiSvcName(String eaiSvcName){
+        return repository.findByEaisvcname(eaiSvcName);
+    }
+
+    public void deleteByEaiSvcName(String eaiSvcName){
+        repository.deleteByEaisvcname(eaiSvcName);
+    }
+}
+
+

src/main/java/com/eactive/eai/rms/onl/transaction/apim/mapping/ApiInterfaceUIMapper.java

@@ -0,0 +1,196 @@
+package com.eactive.eai.rms.onl.transaction.apim.mapping;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.eactive.eai.data.entity.onl.stdmessage.StandardMessageItem;
+import com.eactive.eai.data.entity.onl.stdmessage.StandardMessageItemId;
+import com.eactive.eai.rms.onl.manage.serviceinfo.stdmessage.StdMessageItemUI;
+import com.eactive.eai.rms.onl.manage.serviceinfo.stdmessage.StdMessageItemUIMapper;
+import com.eactive.eai.rms.onl.transaction.simpleinterface.ui.SimpleInterfaceUI;
+import org.apache.commons.lang.StringUtils;
+import org.mapstruct.AfterMapping;
+import org.mapstruct.InheritConfiguration;
+import org.mapstruct.InheritInverseConfiguration;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.MappingTarget;
+import org.mapstruct.Named;
+
+import com.eactive.eai.data.entity.onl.message.EAIMessageEntity;
+import com.eactive.eai.data.entity.onl.message.ServiceMessageEntity;
+import com.eactive.eai.data.entity.onl.stdmessage.StandardMessageInfo;
+import com.eactive.eai.data.mapper.BaseMapperConfig;
+import com.eactive.eai.rms.onl.transaction.apim.ApiInterfaceService;
+import com.eactive.eai.rms.onl.transaction.apim.ui.ApiInterfaceUI;
+
+@Mapper(config = BaseMapperConfig.class, uses = { StdMessageItemUIMapper.class })
+public interface ApiInterfaceUIMapper {
+
+    @Mapping(source = "eaiSvcName", target = "eaisvcname")
+    @Mapping(source = "eaiBzwkDstcd", target = "eaibzwkdstcd")
+    @Mapping(source = "sevrLogLvelNo", target = "sevrloglvelno", defaultValue = "3")
+    @Mapping(source = "svcLogLvelNo", target = "svcloglvelno", defaultValue = "3")
+    @Mapping(source = "eaiSvcDesc", target = "eaisvcdesc")
+    @Mapping(source = "fromAdapter", target = "gstatsysadptrbzwkgroupname")
+    @Mapping(source = "lastModifiedDate", target = "eailastamndyms")
+    @Mapping(source = "apiEnabledYn", target = "apienabledyn")
+    @Mapping(source = "authType", target = "authtype")
+    @Mapping(target = "svchmseonot", constant = "0")
+    @Mapping(target = "svcmotivusedstcd", constant = "SYNC")
+    @Mapping(target = "svcprcesdsticname", constant = "SINGLE")
+    @Mapping(target = "flowctrlroutname", constant = "BASEFC")
+    @Mapping(target = "intgradsticname", constant = "ONLINE")
+    @Mapping(target = "svcbfclmnlogyn", constant = "0")
+    @Mapping(target = "useyn", constant = "1")
+    EAIMessageEntity toEaiMessageEntity(ApiInterfaceUI vo);
+
+    @InheritInverseConfiguration(name = "toEaiMessageEntity")
+    ApiInterfaceUI toVo(EAIMessageEntity eaiMessageEntity);
+
+    @Mapping(target = "eaiSvcName", source = "eaiMessageEntity.eaisvcname")
+    @Mapping(target = "eaiBzwkDstcd", source = "eaiMessageEntity.eaibzwkdstcd")
+    @Mapping(target = "eaiSvcDesc", source = "eaiMessageEntity.eaisvcdesc")
+    @Mapping(target = "fromAdapter", source = "eaiMessageEntity.gstatsysadptrbzwkgroupname")
+    @Mapping(target = "author", source = "eaiMessageEntity.author")
+    @Mapping(source = "eaiMessageEntity.apienabledyn", target = "apiEnabledYn")
+    @Mapping(source = "eaiMessageEntity.authtype", target = "authType")
+    @Mapping(target = "lastModifiedDate", source = "eaiMessageEntity.eailastamndyms")
+    @Mapping(target = "svcLogLvelNo", source = "eaiMessageEntity.svcloglvelno")
+    ApiInterfaceUI toVo(EAIMessageEntity eaiMessageEntity, List<ServiceMessageEntity> serviceMessageEntities);
+
+    @InheritConfiguration(name="toEaiMessageEntity")
+    void updateEaiMessageEntity(ApiInterfaceUI vo, @MappingTarget EAIMessageEntity entity);
+
+    @AfterMapping
+    default void setServiceMessageEntity(ApiInterfaceUI vo, @MappingTarget ServiceMessageEntity entity) {
+        String requestTransfrom = StringUtils.defaultString(vo.getRequestTransform());
+        String requestTransformYn = StringUtils.isBlank(requestTransfrom) ? "0" : "1";
+
+        String responseTransfrom = StringUtils.defaultString(vo.getResponseTransform());
+        String responseTransfromYn = StringUtils.isBlank(responseTransfrom) ? "0" : "1";
+
+        String errResponseTransform = StringUtils.defaultString(vo.getErrResponseTransform());
+        String errResponseTransformYn = StringUtils.isBlank(errResponseTransform) ? "0" : "1";
+
+        if("N".equals(vo.getTransformYn())) {
+            requestTransformYn = "0";
+            responseTransfromYn = "0";
+        }
+
+        if(!"Y".equals(vo.getErrTransformYn())) {
+            errResponseTransformYn = "0";
+        }
+
+        entity.setChngeonot(requestTransformYn);
+        entity.setBascrspnschngeonot(responseTransfromYn);
+        entity.setErrrspnschngeonot(errResponseTransformYn);
+        entity.setErrrspnschngmsgidname(errResponseTransform);
+    }
+
+    @AfterMapping
+    default void setServiceMessageEntities(EAIMessageEntity eaiMessageEntity, List<ServiceMessageEntity> serviceMessageEntities, @MappingTarget ApiInterfaceUI vo) {
+        if (serviceMessageEntities == null || serviceMessageEntities.isEmpty()) {
+            return;
+        }
+
+        // 요청 처리 (항상 첫 번째 ServiceMessageEntity 사용)
+        ServiceMessageEntity requestEntity = serviceMessageEntities.get(0);
+
+        // Sync/Async 타입 결정
+        String inboundSyncAsyncType = eaiMessageEntity.getSvcmotivusedstcd();
+        String outboundSyncAsyncType = requestEntity.getPsvintfacdsticname();
+        String syncAsyncType = "sync";
+
+        if(inboundSyncAsyncType.equals("ASYN") && outboundSyncAsyncType.equals("ASYN")){
+            syncAsyncType = "async";
+        }else if(inboundSyncAsyncType.equals("SYNC") && outboundSyncAsyncType.equals("ASYN")){
+            syncAsyncType = "syncAsync";
+        }else if(inboundSyncAsyncType.equals("ASYN") && outboundSyncAsyncType.equals("SYNC")){
+            syncAsyncType = "asyncSync";
+        }
+        vo.setSyncAsyncType(syncAsyncType);
+
+        vo.setToAdapter(requestEntity.getPsvsysadptrbzwkgroupname());
+        vo.setToutVal(requestEntity.getToutval());
+        vo.setRequestTransform(requestEntity.getChngmsgidname());
+    }
+
+    @Mapping(target = "psvsysbzwkdstcd", source = "eaiBzwkDstcd")
+    @Mapping(target = "psvsysadptrbzwkgroupname", source = "toAdapter")
+    @Mapping(target = "chngmsgidname", source = "requestTransform")
+    @Mapping(target = "bascrspnschngmsgidname", source = "responseTransform")
+    @Mapping(target = "errrspnschngmsgidname", source = "errResponseTransform")
+    @Mapping(target = "toutval", source = "toutVal", defaultValue = "0L")
+    @Mapping(target = "psvsysidname", constant = "EAIDOM")
+    @Mapping(target = "psvintfacdsticname", constant = "SYNC")
+    @Mapping(target = "psvsyssvcdsticname", constant = " ")
+    @Mapping(target = "flovryn", constant = "0")
+    @Mapping(target = "bascrspnsmsgcmprctnt", constant = " ")
+    @Mapping(target = "errrspnsmsgcmprctnt", constant = " ")
+    @Mapping(target = "nextsvcprcssno", constant = "1")
+    @Mapping(target = "cmpensvcprcssdsticname", constant = " ")
+    @Mapping(target = "suppldelyn", constant = "0")
+    @Mapping(target = "hdrctrldstcd", constant = "01")
+    @Mapping(target = "hdrrefclsname", constant = " ")
+    void updateServiceMessageEntity(ApiInterfaceUI vo, @MappingTarget ServiceMessageEntity entity);
+
+    @InheritConfiguration(name="updateServiceMessageEntity")
+    @Mapping(target = "id.eaisvcname", source = "eaiSvcName")
+    @Mapping(target = "id.svcprcssno", constant = "1")
+    ServiceMessageEntity toServiceMessageEntity(ApiInterfaceUI vo);
+
+    @Mapping(target = "eaisvcname", source = "eaiSvcName")
+    @Mapping(target = "eaisendrecv", source = "sendRecvType")
+    @Mapping(target = "eaidirection", source = "inOutType")
+    @Mapping(target = "standardMessageItems", source = "standardMessageItems")
+    StandardMessageInfo toStandardMessageInfo(ApiInterfaceUI vo);
+
+    @AfterMapping
+    default void setStandardMessageInfo(ApiInterfaceUI vo, @MappingTarget StandardMessageInfo entity) throws RuntimeException {
+        String eaiSvcName = entity.getEaisvcname();
+        String inboundAdapterGroupName = vo.getFromAdapter();
+        String inboundRestPath = vo.getInboundRestPath();
+        String inboundHttpMethod = vo.getInboundHttpMethod();
+
+        String inboundMethod = StringUtils.defaultString(inboundHttpMethod, "POST").toUpperCase();
+
+        List<String> headerValues = vo.getHeaderValues();
+
+        String stdMessageKey = inboundAdapterGroupName + ApiInterfaceService.STEMSG_METHOD_DELIMITER + inboundMethod;
+
+        if(vo.getIsHeaderRouting() != null && vo.getIsHeaderRouting() && headerValues != null && headerValues.size() > 0){
+            stdMessageKey += ApiInterfaceService.STEMSG_SERVICE_HEADER_DELIMITER + String.join(ApiInterfaceService.STEMSG_HEADER_SEPARATOR, headerValues);
+        }else{
+            if(StringUtils.isBlank(inboundRestPath)) {
+                throw new RuntimeException("inbound 서비스 URL이 정의되어 있지 않습니다.");
+            }
+            stdMessageKey += ApiInterfaceService.STEMSG_SERVICE_URL_DELIMITER + inboundRestPath;
+        }
+
+        entity.setBzwksvckeyname(stdMessageKey);
+
+        List<StandardMessageItem> standardMessageItems = entity.getStandardMessageItems();
+        if(standardMessageItems != null){
+            for (StandardMessageItem standardMessageItem : standardMessageItems){
+                standardMessageItem.getId().setBzwksvckeyname(stdMessageKey);
+            }
+        }
+
+        String eaiTranName = eaiSvcName.substring(0, eaiSvcName.length() - 2);
+        entity.setEaitranname(eaiTranName);
+    }
+
+    @AfterMapping
+    default void setEaiMessageEntity(ApiInterfaceUI vo, @MappingTarget EAIMessageEntity entity) {
+        if(vo == null || vo.getSyncAsyncType() == null){
+            return;
+        }
+        switch(vo.getSyncAsyncType()){
+            case "async":
+            case "asyncSync":
+                entity.setSvcmotivusedstcd("ASYN");
+                break;
+        }
+    }
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/mapping/ApiSpecUIMapper.java

@@ -0,0 +1,69 @@
+package com.eactive.eai.rms.onl.transaction.apim.mapping;
+
+
+import com.eactive.apim.portal.apispec.entity.ApiSpecInfo;
+import com.eactive.apim.portal.apispec.repository.ApiSpecInfoRepository;
+import com.eactive.eai.data.mapper.BaseMapperConfig;
+import com.eactive.eai.rms.onl.manage.serviceinfo.stdmessage.StdMessageItemUIMapper;
+import com.eactive.eai.rms.onl.transaction.apim.ui.ApiSpecInfoUI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.mapstruct.Mapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Mapper(config = BaseMapperConfig.class, uses = {StdMessageItemUIMapper.class})
+@Component
+public abstract class ApiSpecUIMapper {
+
+    @Autowired
+    private ApiSpecInfoRepository apiSpecInfoRepository;
+
+    public abstract ApiSpecInfoUI mapToUI(ApiSpecInfo apiSpecInfo);
+
+    public abstract ApiSpecInfo mapToEntity(ApiSpecInfoUI apiSpecInfoUI);
+
+    public ApiSpecInfoUI map(Optional<ApiSpecInfo> optionalApiSpecInfo) {
+        return optionalApiSpecInfo.map(this::mapToUI).orElse(new ApiSpecInfoUI());
+    }
+
+    public ApiSpecInfo getById(String id) {
+        return apiSpecInfoRepository.findById(id).orElse(null);
+    }
+
+    public ApiSpecInfoUI getUIById(String id) {
+        return mapToUI(apiSpecInfoRepository.findById(id).orElse(null));
+    }
+
+    public List<ApiSpecInfo> mapList(List<ApiSpecInfoUI> apiSpecInfoUIList) {
+        if (apiSpecInfoUIList == null || apiSpecInfoUIList.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        // Extract all API IDs
+        List<String> apiIds = apiSpecInfoUIList.stream()
+            .map(ApiSpecInfoUI::getApiId)
+            .filter(Objects::nonNull)
+            .collect(Collectors.toList());
+
+        // Batch fetch all API specs at once
+        Map<String, ApiSpecInfo> apiSpecMap = apiSpecInfoRepository.findAllById(apiIds)
+            .stream()
+            .collect(Collectors.toMap(
+                ApiSpecInfo::getApiId,
+                Function.identity(),
+                (existing, replacement) -> existing // Keep first in case of duplicates
+            ));
+
+        // Map UI objects to domain objects, preserving order and handling missing entries
+        return apiSpecInfoUIList.stream()
+            .map(ui -> ui.getApiId() != null ? apiSpecMap.get(ui.getApiId()) : null)
+            .filter(Objects::nonNull)
+            .collect(Collectors.toList());
+    }
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/mapping/BizCodeMapper.java

@@ -0,0 +1,20 @@
+package com.eactive.eai.rms.onl.transaction.apim.mapping;
+
+import java.util.List;
+
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+
+import com.eactive.eai.data.entity.onl.unifbwk.UnifBwkTp;
+import com.eactive.eai.data.mapper.BaseMapperConfig;
+import com.eactive.eai.rms.onl.transaction.apim.vo.BizCodeVo;
+
+@Mapper(config = BaseMapperConfig.class)
+public interface BizCodeMapper {
+    @Mapping(source = "eaibzwkdstcd", target = "bizCode")
+    @Mapping(source = "bzwkdsticname", target = "bizName")
+    @Mapping(source = "bzwkdsticdesc", target = "bizDesc")
+    BizCodeVo toVo(UnifBwkTp unifBwkTp);
+
+    List<BizCodeVo> toVoList(List<UnifBwkTp> unifBwkTps);
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/repository/StandardMessageInfoRepositoryForApi.java

@@ -0,0 +1,13 @@
+package com.eactive.eai.rms.onl.transaction.apim.repository;
+
+import java.util.Optional;
+
+import com.eactive.eai.data.entity.onl.stdmessage.StandardMessageInfo;
+import com.eactive.eai.data.jpa.BaseRepository;
+
+
+public interface StandardMessageInfoRepositoryForApi extends BaseRepository<StandardMessageInfo, String> {
+    Optional<StandardMessageInfo> findByEaisvcname(String eaiSvcName);
+
+    void deleteByEaisvcname(String eaiSvcName);
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/ui/ApiInterfaceExportData.java

@@ -0,0 +1,13 @@
+package com.eactive.eai.rms.onl.transaction.apim.ui;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ApiInterfaceExportData {
+    private ApiInterfaceUI apiInterfaceUI;
+    private byte[] exportFileContent;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/ui/ApiInterfaceExportSetUI.java

@@ -0,0 +1,16 @@
+package com.eactive.eai.rms.onl.transaction.apim.ui;
+
+import com.eactive.eai.rms.onl.manage.rule.layout.ui.LayoutUI;
+import com.eactive.eai.rms.onl.manage.rule.transform2.ui.TransformUI;
+import lombok.Data;
+
+@Data
+public class ApiInterfaceExportSetUI {
+    private ApiInterfaceUI apiInterfaceUI;
+    private LayoutUI inboundRequestLayout;
+    private LayoutUI outboundRequestLayout;
+    private LayoutUI outboundResponseLayout;
+    private LayoutUI inboundResponseLayout;
+    private TransformUI requestTransform;
+    private TransformUI responseTransform;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/ui/ApiInterfaceReloadSyncSet.java

@@ -0,0 +1,14 @@
+package com.eactive.eai.rms.onl.transaction.apim.ui;
+
+import com.eactive.eai.rms.onl.manage.rule.layout.ui.LayoutUI;
+import com.eactive.eai.rms.onl.manage.rule.transform2.ui.TransformUI;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class ApiInterfaceReloadSyncSet {
+    private ApiInterfaceUI apiInterfaceUI;
+    private List<LayoutUI> layoutUIList;
+    private List<TransformUI> transformUIList;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/ui/ApiInterfaceUI.java

@@ -0,0 +1,62 @@
+package com.eactive.eai.rms.onl.transaction.apim.ui;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import com.eactive.eai.rms.onl.manage.serviceinfo.stdmessage.StdMessageItemUI;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+import org.hibernate.annotations.Comment;
+
+import javax.persistence.Column;
+
+@Data
+public class ApiInterfaceUI {
+    private Integer sevrLogLvelNo;
+    private String eaiBzwkDstcd;
+    private String sendRecvType;
+    private Integer inOutType;
+    private String eaiSvcDesc;
+    private String fromAdapter;
+    private String toAdapter;
+    private String headerEaiIfId;
+    private String commonInputGramId;
+    private String commonInputGramLwrId;
+    private String inboundHttpMethod;
+    private String inboundRestPath;
+    private String outboundHttpMethod;
+    private String outboundRestPath;
+    private String inboundRequestLayout;
+    private String requestTransform;
+    private String outboundRequestLayout;
+    private String inboundResponseLayout;
+    private String responseTransform;
+    private String outboundResponseLayout;
+    private String interfaceId;
+    private String eaiSvcName;
+    private String transformYn;
+    private Long toutVal;
+    private String simYn;
+    private String author;
+    private String syncAsyncType;
+    private String restContentType;
+    private Integer svcLogLvelNo;
+    private String apiEnabledYn;
+    private String authType;
+    private Boolean isHeaderRouting;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime lastModifiedDate;
+    private List<String> headerValues;
+    private List<StdMessageItemUI> standardMessageItems;
+    private List<StdMessageItemUI> inboundResponseStandardMessageItems ;
+
+    //ASYNC-SYNC 용
+    private String inboundResponseHttpMethod;
+    private String inboundResponseRestPath;
+    private String fromResponseAdapter;
+
+    private String inboundErrResponseLayout;
+    private String errResponseTransform;
+    private String outboundErrResponseLayout;
+    private String errTransformYn;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/ui/ApiSpecInfoUI.java

@@ -0,0 +1,57 @@
+package com.eactive.eai.rms.onl.transaction.apim.ui;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+public class ApiSpecInfoUI {
+
+    private String apiId;
+
+    private String apiName;
+
+    private String apiSimpleDescription;
+
+    private String apiUrl;
+
+    private String apiMethod;
+
+    private String apiContentType;
+
+    private String apiRequestSpec;
+
+    private String apiResponseSpec;
+
+    private String sampleRequest;
+
+    private String sampleResponse;
+
+    private String responseType;  //sample, mock
+
+    private String mockUrl;
+
+    private String fileId;
+
+    private String description;
+
+    private String testbedSpec;
+
+    private String displayYn;
+
+    private String displayOrg;
+
+    private String orgName;
+
+    private String displayRoleCode;
+
+    private LocalDateTime createdDate;
+
+    private LocalDateTime lastModifiedDate;
+
+    private String createdBy;
+
+    private String lastModifiedBy;
+
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/vo/BizCodeVo.java

@@ -0,0 +1,15 @@
+package com.eactive.eai.rms.onl.transaction.apim.vo;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.Data;
+
+@Data
+public class BizCodeVo {
+    @JsonProperty("BIZCODE")
+    String bizCode;
+    @JsonProperty("BIZNAME")
+    String bizName;
+    @JsonProperty("BIZDESC")
+    String bizDesc;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/apim/vo/RestOption.java

@@ -0,0 +1,14 @@
+package com.eactive.eai.rms.onl.transaction.apim.vo;
+
+import lombok.Data;
+
+import java.util.Map;
+
+@Data
+public class RestOption {
+    String extraPath;
+    String method;
+    String contentType;
+    String type;
+    Map<String, String> standardCommonFields;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/extnl/InterfaceDao.java

@@ -0,0 +1,237 @@
+package com.eactive.eai.rms.onl.transaction.extnl;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.stereotype.Repository;
+
+import com.eactive.eai.rms.common.base.SqlMapClientTemplateDao;
+
+
+@Repository("interfaceDao")
+public class InterfaceDao extends SqlMapClientTemplateDao {
+	
+    public int selectListCount(HashMap paramMap) throws Exception {
+    	return (Integer)template.queryForObject("Interface.selectListCount", paramMap);
+    }	
+    public List selectList(HashMap paramMap) throws Exception {
+    	return template.queryForList("Interface.selectList", paramMap);
+    }	
+	
+    public HashMap selectDetail(HashMap paramMap) throws Exception {
+    	return (HashMap)template.queryForObject("Interface.selectDetail", paramMap);
+    }	
+
+    public void insert(HashMap paramMap) throws Exception{
+        this.template.insert("Interface.insert", paramMap);
+    }      
+     
+    public void delete(HashMap paramMap) throws Exception{
+        this.template.delete("Interface.delete", paramMap);
+    }	
+    
+    /**		Detail 추가 정보  **/
+    public HashMap selectDetailHE10(HashMap paramMap) throws Exception {
+    	return (HashMap)template.queryForObject("Interface.selectDetailHE10", paramMap);
+    }	
+
+    public void mergeHE10(HashMap paramMap) throws Exception{
+        this.template.insert("Interface.mergeHE10", paramMap);
+    }      
+     
+    public void deleteHE10(HashMap paramMap) throws Exception{
+        this.template.delete("Interface.deleteHE10", paramMap);
+    }    
+    
+
+	/** 내부 표준 전문 */
+	public void mergeToHS04(HashMap<String,Object> vo) {
+		
+		HashMap<String,Object> std = new HashMap<String,Object>();
+    	std.put("bzwkSvcKeyName"      ,vo.get("bzwkSvcKeyName"));// 시스템인터페이스코드
+    	std.put("COMMON_IFID"         ,vo.get("eaiTranName"));
+    	std.put("HEADER_MESGDMANDVCD" ,vo.get("splizDmndDstcd"));// 전문요청 구분
+    	std.put("COMMON_HMABDVCD"     ,vo.get("stndTelgmWtinExtnlDstcd"));
+    	template.insert("Interface.mergeToHS04", std);
+	}
+    public void mergeToHS05(HashMap<String,Object> vo) {
+    	HashMap<String,HashMap<String,Object>> map = new HashMap<String,HashMap<String,Object>>();
+    	String bzwkSvcKeyName = (String)vo.get("bzwkSvcKeyName");
+    	
+    	List<HashMap<String,String>> list = template.queryForList("Interface.selectListHS03", vo);//의미 없는 vo
+    	
+    	//default 값 셋팅
+    	for(HashMap<String,String> h : list ){
+    		String columnName    = h.get("COLUMNNAME"); 
+    		String columnDefault = h.get("COLUMNDEFAULT");
+    		if (columnDefault == null || "".equals(columnDefault.trim())){
+    			map.put(columnName,setHashMap(bzwkSvcKeyName,columnName,""));// DEFAULT값
+    		}else{
+    			map.put(columnName,setHashMap(bzwkSvcKeyName,columnName,columnDefault));// DEFAULT값
+    		}
+    	}
+    	List<HashMap<String,String>> list2 = template.queryForList("Interface.detailToHS05", vo);
+    	for(HashMap<String,String> h : list2 ){
+    		String columnName  = h.get("COLUMNNAME"); 
+    		String columnValue = h.get("COLUMNVALUE");
+    		if (columnValue != null && !"".equals(columnValue.trim())){
+    			map.put(columnName,setHashMap(bzwkSvcKeyName,columnName,columnValue));// DEFAULT값
+    		}
+    	}    	
+		
+    	map.put("COMMON_IFID"         , setHashMap(bzwkSvcKeyName,"COMMON_IFID"           ,(String)vo.get("eaiTranName")));// 전문요청 구분
+    	map.put("HEADER_MESGDMANDVCD" , setHashMap(bzwkSvcKeyName,"HEADER_MESGDMANDVCD"   ,(String)vo.get("splizDmndDstcd")));// 전문요청 구분
+    	map.put("COMMON_HMABDVCD"     , setHashMap(bzwkSvcKeyName,"COMMON_HMABDVCD"       ,(String)vo.get("stndTelgmWtinExtnlDstcd")));// 전문요청 구분
+    	map.put("COMMON_SRVCID"       , setHashMap(bzwkSvcKeyName,"COMMON_SRVCID"         ,(String)vo.get("serviceId")));// 서비스ID
+    	map.put("COMMON_ORTRRESTRYN"  , setHashMap(bzwkSvcKeyName,"COMMON_ORTRRESTRYN"    ,"O".equals(vo.get("io")) && "R".equals(vo.get("splizDmndDstcd")) ? "Y" : "N"));// 당발에 응답인 경우 Y
+    	
+    	
+    	for(String key : map.keySet()){
+    		HashMap<String,Object> std = map.get(key);
+    		template.insert("Interface.mergeToHS05", std);
+    	}
+	}
+    private HashMap<String,Object> setHashMap(String bzwkSvcKeyName , String columnName ,String columnValue){
+    	HashMap<String,Object> std = new HashMap<String,Object>();
+    	std.put("bzwkSvcKeyName", bzwkSvcKeyName);
+    	std.put("columnName", columnName);
+    	std.put("columnValue",columnValue);
+    	return std; 
+    }
+	
+	
+	public void mergeToHE01(HashMap<String,Object> vo) {
+	// 기동 어뎁터
+	// Async 인 경우 As, Sync인 경우 Sy
+	// SOCKET 인 경우 처리 후 개별 수정 하는 것으로 !
+	String type ="";
+	if ("ASYN".equals(vo.get("svcMotivUseDstcd")) || "SYNC".equals(vo.get("svcMotivUseDstcd"))){
+		type = (String) vo.get("svcMotivUseDstcd");
+	}else if ("ASYN_SYNC".equals(vo.get("svcMotivUseDstcd"))){
+		type = "ASYN";
+	}else if ("SYNC_ASYN".equals(vo.get("svcMotivUseDstcd"))){
+		type = "SYNC";
+	}
+
+	HashMap<String,Object> eai = new HashMap<String,Object>(); 
+	
+	eai.put("eaiSvcName"         , vo.get("eaiSvcName")      ); // EAI서비스명            
+	eai.put("eaiBzwkDstcd"       , vo.get("eaiBzwkDstcd")    ); // EAI업무구분코드        
+	eai.put("svcHMSEonot"        , "0"                       ); // 서비스시각유무         
+	eai.put("svcMotivUseDstcd"   , type                      ); // 서비스동기사용구분코드                      
+	eai.put("svcPrcesDsticName"  , "SINGLE"                ); // 서비스프로세스구분명
+	eai.put("flowCtrlRoutName"   , vo.get("flowCtrlRoutName")); // 흐름통제라우팅명
+	eai.put("intgraDsticName"    , "ONLINE"                ); // 통합구분명                                 
+	eai.put("svcBfClmnLogYn"     , "0"                     ); // 서비스전컬럼로그여부
+	eai.put("gstatSysAdptrBzwkGroupName", vo.get("fromAdapter")); // 기동시스템어댑터업무그룹명
+	eai.put("sevrLogLvelNo"      , 0                       ); // 서버로그레벨번호  
+	eai.put("svcLogLvelNo"       , 3                       ); // 서비스로그레벨번호
+	eai.put("errEaiSvcName"			 , vo.get("errEaiSvcName")		); //오류EAI서비스명
+	eai.put("dmndErrChngIdName"		, (null==vo.get("dmndErrChngIdName"))?"":vo.get("dmndErrChngIdName"));	// 요청오류변환ID명
+	eai.put("dmndErrFldName"		, (null==vo.get("dmndErrFldName"))?"":vo.get("dmndErrFldName"));  // 요청에러필드명
+	eai.put("RspnsErrChngIdName"	, (null==vo.get("RspnsErrChngIdName"))?"":vo.get("RspnsErrChngIdName")); //응답오류변환ID명
+	eai.put("RspnsErrFldName"		, (null==vo.get("RspnsErrFldName"))?"":vo.get("RspnsErrFldName")); // 응답에러필드명
+	eai.put("eaiSvcDesc"         , vo.get("eaiSvcDesc")      ); //  EAI서비스 설명
+	eai.put("eaiSevrDstcd", vo.get("eaiSevrDstcd")        ); //EAI 서버구분코드내용
+	eai.put("modfiMgtStusDstcd",  (null==vo.get("modfiMgtStusDstcd"))?"":vo.get("modfiMgtStusDstcd"));    //변경관리상태구분코드내용
+	eai.put("eaiLastAmndYMS"         , vo.get("eaiLastAmndYMS")      ); //  EAI최종수정일시
+	eai.put("eaiGroupCoCd", 	"KB0"        ); //EAI그룹회사코드내용
+	eai.put("tranType", vo.get("tranType")        ); //거래처리구분코드내용
+	eai.put("useYn", vo.get("useYn") );
+	template.insert("Interface.mergeToHE01", eai);
+}
+
+public void mergeToHE02(HashMap<String,Object> vo) {
+	// 수동 어뎁터
+	// Async 인 경우 As, Sync인 경우 Sy
+	// SOCKET 인 경우 처리 후 개별 수정 하는 것으로 !
+	// 내부 응답인 경우 CBS 에 인스턴스 별로 다름
+	String type ="";
+	if ("ASYN".equals(vo.get("svcMotivUseDstcd")) || "SYNC".equals(vo.get("svcMotivUseDstcd"))){
+		type =(String)vo.get("svcMotivUseDstcd");
+	}else if ("ASYN_SYNC".equals(vo.get("svcMotivUseDstcd"))){
+		type = "SYNC";
+	}else if ("SYNC_ASYN".equals(vo.get("svcMotivUseDstcd"))){
+		type = "ASYN";
+	}
+	HashMap<String,Object> eai = new HashMap<String,Object>();
+	eai.put("eaiSvcName"             , vo.get("eaiSvcName")         ); // EAI서비스명                
+	eai.put("svcPrcssNo"             , 1                          ); // 서비스처리번호
+	eai.put("psvIntfacDsticName"     , type                       ); // 수동인터페이스구분명        
+	eai.put("psvSysBzwkDstcd"        , vo.get("eaiBzwkDstcd")       ); // 수동시스템업무구분코드          
+	eai.put("psvSysIDName"           , "EAIDOM"                   ); // 수동시스템ID명         
+	eai.put("psvSysSvcDsticName"     , " "                        ); // 수동시스템서비스구분명      
+	eai.put("flovrYn"                , (Boolean)vo.get("failOver")? "1" : "0"); // 장애극복여부            
+	eai.put("chngEonot"              , "0"                        ); // 변환유무             
+	eai.put("chngMsgIDName"          , " "                        ); // 변환메시지ID명         
+	eai.put("bascRspnsMsgCmprCtnt"   , " "                        ); // 기본응답메시지비교내용      
+	eai.put("bascRspnsChngEonot"     , "0"                        ); // 기본응답변환유무             
+	eai.put("bascRspnsChngMsgIDName" , " "                        ); // 기본응답변환메시지ID명     
+	eai.put("errRspnsMsgCmprCtnt"    , " "                        ); // 오류응답메시지비교내용      
+	eai.put("errRspnsChngEonot"      , "0"                        ); // 오류응답변환유무         
+	eai.put("errRspnsChngMsgIDName"  , " "                        ); // 오류응답변환메시지ID명     
+	eai.put("nextSvcPrcssNo"         , 1                          ); // 다음서비스처리번호      
+	eai.put("toutVal"                , 60                         ); // 타임아웃값          
+	eai.put("cmpenSvcPrcssDsticName" , " "                        ); // 보상서비스처리구분명                 
+	eai.put("supplDelYn"             , "0"                        ); // 추가삭제여부         
+	eai.put("hdrCtrlDstcd"           , "01"                       ); // 헤더제어구분코드  
+	eai.put("hdrRefClsName"          , " "                        ); // 헤더참조클래스명
+	eai.put("restOption"      	     , " "                        ); // REST추가내용  
+
+	eai.put("psvSysAdptrBzwkGroupName", vo.get("toAdapter")); // 수동시스템어댑터업무그룹명  
+	if( "SYNC_ASYN".equals(vo.get("svcMotivUseDstcd")) && ((String)vo.get("eaiSvcName")).endsWith("R1")){ 	//EAI에 한함	
+		eai.put("psvSysAdptrBzwkGroupName", " ");
+		eai.put("outbndRoutName","HTTPOUT");// 아웃바운드라우팅명 
+	}else{
+		if ("NET".equals(((String)vo.get("toAdapter")).substring(8, 11))){
+			eai.put("outbndRoutName","SOCKETOUT");// 아웃바운드라우팅명 
+		}else if ("HTT".equals(((String)vo.get("toAdapter")).substring(8, 11))){
+			eai.put("outbndRoutName","HTTPOUT");// 아웃바운드라우팅명 
+		}
+	}
+	template.insert("Interface.mergeToHE02", eai);
+	
+	
+    //String intfacPtrnCd = vo.getGstatSysAdptr().substring(12, 13) + vo.getPsvSysAdptr().substring(12, 13);
+    if( "ASYN_SYNC".equals(vo.get("svcMotivUseDstcd")) ) {
+		HashMap<String,Object> eai2 = new HashMap<String,Object>();
+		eai2.put("eaiSvcName"               , vo.get("eaiSvcName")   ); // EAI서비스명                
+		eai2.put("svcPrcssNo"               , 2                      ); // 서비스처리번호
+		eai2.put("psvIntfacDsticName"       , "S".equals(((String)vo.get("extAdapter")).substring(12, 13)) ? "SYNC" : "ASYN" ); // 수동인터페이스구분명        
+		eai2.put("psvSysBzwkDstcd"          , vo.get("eaiBzwkDstcd") ); // 수동시스템업무구분코드          
+		eai2.put("psvSysIDName"             , "EAIDOM"); // 수동시스템ID명         
+		eai2.put("psvSysSvcDsticName"       , " "); // 수동시스템서비스구분명      
+		eai2.put("flovrYn"                  , (Boolean)vo.get("failOver") ? "1" : "0"); // 장애극복여부            
+		eai2.put("chngEonot"                , "0"); // 변환유무             
+		eai2.put("chngMsgIDName"            , " "); // 변환메시지ID명         
+		eai2.put("bascRspnsMsgCmprCtnt"     , " "); // 기본응답메시지비교내용      
+		eai2.put("bascRspnsChngEonot"       , "0"); // 기본응답변환유무             
+		eai2.put("bascRspnsChngMsgIDName"   , " "); // 기본응답변환메시지ID명     
+		eai2.put("errRspnsMsgCmprCtnt"      , " "); // 오류응답메시지비교내용      
+		eai2.put("errRspnsChngEonot"        , "0"); // 오류응답변환유무         
+		eai2.put("errRspnsChngMsgIDName"    , " "); // 오류응답변환메시지ID명     
+		eai2.put("nextSvcPrcssNo"           , 1); // 다음서비스처리번호      
+		eai2.put("toutVal"                  , 60); // 타임아웃값          
+		eai2.put("cmpenSvcPrcssDsticName"   , " "); // 보상서비스처리구분명                 
+		eai2.put("supplDelYn"               , "0"); // 추가삭제여부         
+		eai2.put("hdrCtrlDstcd"             , "01"); // 헤더제어구분코드  
+		eai2.put("hdrRefClsName"            , " "); // 헤더참조클래스명  
+
+		eai2.put("psvSysAdptrBzwkGroupName", vo.get("extAdapter") ); // 수동시스템어댑터업무그룹명  
+		eai2.put("outbndRoutName"          , ((String)vo.get("extAdapter")).indexOf("NET") > -1 ? "SOCKETOUT" : "HTTPOUT" ); // 아웃바운드라우팅명       
+
+		template.insert("Interface.mergeToHE02", eai2);
+    } else {
+		template.delete("Interface.deleteNo2ToHE02", eai);
+    }	
+	
+}
+	
+	public void deleteToHS04(HashMap<String,Object> std) {
+		template.delete("Interface.deleteToHS04", std);
+	}
+	public void deleteToHS05(HashMap<String,Object> std) {
+		template.delete("Interface.deleteToHS05", std);
+	}
+}

src/main/java/com/eactive/eai/rms/onl/transaction/extnl/InterfaceKeys.java

@@ -0,0 +1,11 @@
+package com.eactive.eai.rms.onl.transaction.extnl;
+
+
+
+public class InterfaceKeys {
+
+	public static final String FCR_BAS = "BASEFC";
+	public static final String FCR_C2R = "C2RFC";
+	public static final String FCR_B2B = "B2BFC";
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/extnl/InterfaceManController.java

@@ -0,0 +1,227 @@
+package com.eactive.eai.rms.onl.transaction.extnl;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+
+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.data.web.SortDefault;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.PostMapping;
+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.data.entity.onl.unifbwk.UnifBwkTp;
+import com.eactive.eai.rms.common.combo.ComboService;
+import com.eactive.eai.rms.common.combo.ComboVo;
+import com.eactive.eai.rms.common.datasource.DataSourceContextHolder;
+import com.eactive.eai.rms.common.spring.BaseController;
+import com.eactive.eai.rms.common.util.CamelCaseUtil;
+import com.eactive.eai.rms.common.vo.GridResponse;
+import com.eactive.eai.rms.data.entity.onl.eaimsg.EAIMessageUISearch;
+import com.eactive.eai.rms.data.entity.onl.unifbwk.UnifBwkTpService;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.ui.AdapterGroupUI;
+import com.eactive.eai.rms.onl.transaction.extnl.ui.InterfaceUI;
+
+@Controller
+public class InterfaceManController extends BaseController {
+
+    private static final Logger logger = Logger.getLogger(InterfaceManController.class);    
+
+	@Autowired
+	@Qualifier("interfaceManService")
+	private InterfaceManService interfaceManService;
+
+	@Autowired
+	private ComboService comboService;
+
+	@Autowired
+	private UnifBwkTpService unifBwkTpService;
+    
+	@RequestMapping(value= "/onl/transaction/extnl/interfaceMan.view")
+	private String viewList(HttpServletRequest request, @RequestParam(value = "cmd", required = false ) String cmd ) throws Exception {
+		if (cmd == null || "LIST".equals(cmd.toUpperCase())){
+			cmd = "";
+		}else {
+			cmd = CamelCaseUtil.converCamelCase(cmd);
+		}
+		String path = request.getServletPath();
+		return path.split("[.]")[0]+cmd;
+	}    
+
+	@RequestMapping(value= "/onl/transaction/extnl/interfaceMan.json", params = "cmd=LIST")
+	public ResponseEntity<GridResponse<InterfaceUI>> selectList(EAIMessageUISearch eaiMessageUISearch,
+			Pageable pageable, String sortname,  String sortorder) {
+		Page<InterfaceUI> page = interfaceManService.selectList(eaiMessageUISearch, pageable, sortname, sortorder);
+		return ResponseEntity.ok(new GridResponse<>(page));
+	}
+
+	@RequestMapping(value= "/onl/transaction/extnl/interfaceMan.json",params = "cmd=DETAIL")
+	private ResponseEntity<InterfaceUI> selectDetail(String eaiSvcName) {
+		InterfaceUI interfaceUI = interfaceManService.selectDetail(eaiSvcName);
+		return ResponseEntity.ok(interfaceUI);
+	}
+	@RequestMapping(value= "/onl/transaction/extnl/interfaceMan.json",params = "cmd=INSERT")
+	private String insert(InterfaceUI interfaceUI) throws Exception {
+
+		interfaceManService.insert(interfaceUI);
+		reloadSync(interfaceUI);
+		return null;
+	}	
+	@RequestMapping(value= "/onl/transaction/extnl/interfaceMan.json",params = "cmd=UPDATE")
+	private String update(InterfaceUI interfaceUI) throws Exception {
+
+		interfaceManService.update(interfaceUI);
+		reloadSync(interfaceUI);
+		return null;
+	}
+	@RequestMapping(value= "/onl/transaction/extnl/interfaceMan.json",params = "cmd=DELETE")
+	private String delete(InterfaceUI interfaceUI) throws Exception {
+		interfaceManService.delete(interfaceUI);
+		deleteSync(interfaceUI);
+		return null;
+	}
+	
+	@RequestMapping(value= "/onl/transaction/extnl/interfaceMan.json",params = "cmd=LIST_COMBO")
+	public ResponseEntity<Map<String, Object>> selectCombo() throws Exception {
+
+		List<ComboVo> listBiz = comboService.getFromBusinessType();
+		Map<String, Object> resultMap = new HashMap<>();
+
+		resultMap.put("bizList", listBiz);
+
+		return ResponseEntity.ok(resultMap);
+	}	
+	
+	@RequestMapping(value= "/onl/transaction/extnl/interfaceMan.json",params = "cmd=LIST_DETAIL_COMBO")
+	public ResponseEntity<Map<String, Object>> selectDetailCombo() throws Exception {
+
+		List<ComboVo> listBiz = comboService.getFromBusinessType();
+		List<ComboVo> listIo = comboService.getFromCode("IO_TYPE"); // 내부외부구분
+		List<ComboVo> listReqResList = comboService.getFromCode("REQRES_TYPE"); // 전문요청구분
+		List<ComboVo> listSyncAsyncList = comboService.getFromCode("SYNCASYNC_TYPE"); // 송수신방법
+		Iterable<UnifBwkTp> unifBwkTpIterable = unifBwkTpService.findByInputdstcd("EXT");
+
+		Map<String, Object> resultMap = new HashMap<>();
+
+		resultMap.put("bizList", listBiz);
+		resultMap.put("ioList", listIo);
+		resultMap.put("reqResList", listReqResList);
+		resultMap.put("syncAsyncList", listSyncAsyncList);
+		resultMap.put("extBizList", unifBwkTpIterable);
+
+		return ResponseEntity.ok(resultMap);
+	}		
+	@RequestMapping(value= "/onl/transaction/extnl/interfaceMan.json",params = "cmd=LIST_ADAPTER_COMBO")
+	public ResponseEntity<Map<String, Object>> selectAdapterCombo(String adptrCd, String adptrIoDstcd) {
+
+		List<AdapterGroupUI> resultList = interfaceManService.selectAdapterCombo(adptrIoDstcd);
+
+		Map<String, Object> resultMap = new HashMap<>();
+
+		resultMap.put("adapter", resultList);
+
+		return ResponseEntity.ok(resultMap);
+	}
+
+	@RequestMapping(value = "/onl/transaction/extnl/interfaceMan.json", params = "cmd=INITIALIZE_EAITRANNAME")
+	public ModelAndView generateInterfaceId(@RequestParam HashMap<String, String> paramMap) throws Exception {
+
+		String intfId = interfaceManService.getIncresedInterfaceId(paramMap);
+
+		Map<String, String> resultMap = new HashMap<>();
+		resultMap.put("intfId", intfId);
+
+		ModelAndView modelAndView = new ModelAndView("jsonView", resultMap);
+
+		return modelAndView;
+	}
+		
+	public void reloadSync(InterfaceUI interfaceUI) throws Exception {
+		logger.debug("--------------------------------------------------------------------------");
+		logger.info("- 동기화 처리 -------------------------------------------------------------");
+		StringBuffer result = new StringBuffer();
+
+		// 기존 정보 조회 및 확인
+		logger.debug("eaiSvcName : [" + interfaceUI.getEaiSvcName() + "]");
+
+		result.append("-[내부표준메세지 초기화]-------------------");
+		// HS04,HS05 내부표준전문
+		String key = interfaceUI.getBzwkSvcKeyName();
+		if (key != null && !"".equals(key)) {
+			CommonCommand cmdHS = new CommonCommand("com.ext.eai.agent.stdmessage.ReloadSTDMessageCommand", key);
+			agentUtilService.broadcast(cmdHS);
+		}
+		result.append("---------------------------------------");
+
+		result.append("-[IF메세지 초기화]------------------------");
+		// HE01 EAI 메시지 공통부
+		key = interfaceUI.getEaiSvcName();
+		CommonCommand cmdHE01 = new CommonCommand("com.eactive.eai.agent.eaimessage.ReloadEAIMessageCommand", key);
+		;
+		agentUtilService.broadcast(cmdHE01);
+		result.append("---------------------------------------");
+
+		result.append("-[필드추출정보 초기화]---------------------");
+		// 메모리 정보 Reload
+		key = interfaceUI.getEaiSvcName();
+		CommonCommand cmdFR03 = new CommonCommand("com.eactive.eai.agent.bizkey.ReloadBizKeyCommand", key);
+		;
+		agentUtilService.broadcast(cmdFR03);
+		logger.debug("--------------------------------------------------------------------------");
+		logger.info(result.toString());
+	}
+
+	public void deleteSync(InterfaceUI interfaceUI) throws Exception {
+		logger.debug("--------------------------------------------------------------------------");
+		logger.info("- 동기화 처리 -------------------------------------------------------------");
+		StringBuffer result = new StringBuffer();
+
+		// 기존 정보 조회 및 확인
+		logger.debug("eaiSvcName : [" + interfaceUI.getEaiSvcName() + "]");
+
+		result.append("-[내부표준메세지 초기화]-------------------");
+		// HS04,HS05 내부표준전문
+		String key = interfaceUI.getBzwkSvcKeyName();
+		if (key != null && !"".equals(key)) {
+			CommonCommand cmdHS = new CommonCommand("com.eactive.eai.agent.stdmessage.RemoveSTDMessageCommand", key);
+			agentUtilService.broadcast(cmdHS);
+		}
+		result.append("---------------------------------------");
+
+		result.append("-[IF메세지 초기화]------------------------");
+		// HE01 EAI 메시지 공통부
+		key = interfaceUI.getEaiSvcName();
+		CommonCommand cmdHE01 = new CommonCommand("com.eactive.eai.agent.eaimessage.RemoveEAIMessageCommand", key);
+		;
+		agentUtilService.broadcast(cmdHE01);
+		result.append("---------------------------------------");
+
+		result.append("-[필드추출정보 초기화]---------------------");
+		// 메모리 정보 Reload
+		key = interfaceUI.getEaiSvcName();
+		CommonCommand cmdFR03 = new CommonCommand("com.eactive.eai.agent.bizkey.RemoveBizKeyCommand", key);
+		;
+		agentUtilService.broadcast(cmdFR03);
+		logger.debug("--------------------------------------------------------------------------");
+		logger.info(result.toString());
+	}	
+	
+	@PostMapping(value = "/onl/transaction/extnl/interfaceMan.json", params = "cmd=LIST_POP")
+	public ResponseEntity<GridResponse<InterfaceUI>> selectPopList(@SortDefault("eaisvcname") Pageable pageable, String eaiSvcName) {
+		
+		String serviceType = DataSourceContextHolder.getDataSourceType().getName();
+		Page<InterfaceUI> page = interfaceManService.selectPopList(pageable, eaiSvcName, serviceType);
+		return ResponseEntity.ok(new GridResponse<>(page));
+	}
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/extnl/InterfaceManService.java

@@ -0,0 +1,854 @@
+package com.eactive.eai.rms.onl.transaction.extnl;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+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.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.eactive.eai.adapter.Keys;
+import com.eactive.eai.rms.common.login.SessionManager;
+import com.eactive.eai.data.entity.onl.message.EAIMessageEntity;
+import com.eactive.eai.data.entity.onl.message.QEAIMessageEntity;
+import com.eactive.eai.data.entity.onl.message.QServiceMessageEntity;
+import com.eactive.eai.data.entity.onl.message.ServiceMessageEntity;
+import com.eactive.eai.data.entity.onl.stdmessage.StandardMessageInfo;
+import com.eactive.eai.data.entity.onl.stdmessage.StandardMessageItem;
+import com.eactive.eai.rms.common.base.OnlBaseService;
+import com.eactive.eai.rms.common.context.MonitoringContext;
+import com.eactive.eai.rms.common.datasource.DataSourceContextHolder;
+import com.eactive.eai.rms.common.datasource.DataSourceType;
+import com.eactive.eai.rms.common.datasource.DataSourceTypeManager;
+import com.eactive.eai.rms.common.util.StringUtils;
+import com.eactive.eai.rms.data.entity.onl.eaimsg.EAIMessageService;
+import com.eactive.eai.rms.data.entity.onl.eaimsg.EAIMessageUISearch;
+import com.eactive.eai.rms.data.entity.onl.sequence.SequenceEntity;
+import com.eactive.eai.rms.data.entity.onl.sequence.SequenceService;
+import com.eactive.eai.rms.data.entity.onl.stdmessage.StandardMessageInfoService;
+import com.eactive.eai.rms.onl.common.exception.BizException;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.AdapterDao;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.AdapterManService;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.ui.AdapterGroupUI;
+import com.eactive.eai.rms.onl.manage.rule.transform.TransformMappingManService;
+import com.eactive.eai.rms.onl.manage.serviceinfo.bizkey.FieldExtractInfoService;
+import com.eactive.eai.rms.onl.manage.serviceinfo.bizkey.FieldExtractInfoUI;
+import com.eactive.eai.rms.onl.manage.serviceinfo.eaimsg.EaiMsgManService;
+import com.eactive.eai.rms.onl.manage.serviceinfo.eaimsg.mapping.ServiceMessageUIMapper;
+import com.eactive.eai.rms.onl.manage.serviceinfo.eaimsg.ui.CondPerRtgInfoUI;
+import com.eactive.eai.rms.onl.manage.serviceinfo.eaimsg.ui.EAIReferenceMessageUI;
+import com.eactive.eai.rms.onl.manage.serviceinfo.eaimsg.ui.ServiceMessageUI;
+import com.eactive.eai.rms.onl.manage.serviceinfo.stdmessage.StdMessageItemUI;
+import com.eactive.eai.rms.onl.manage.serviceinfo.stdmessage.StdMessageManService;
+import com.eactive.eai.rms.onl.manage.serviceinfo.stdmessage.StdMessageUI;
+import com.eactive.eai.rms.onl.manage.serviceinfo.stdmessage.StdMessageUIMapper;
+import com.eactive.eai.rms.onl.transaction.apim.StandardMessageInfoQueryServiceForApi;
+import com.eactive.eai.rms.onl.transaction.extnl.mapping.InterfaceManUIMapper;
+import com.eactive.eai.rms.onl.transaction.extnl.ui.InterfaceUI;
+import com.querydsl.core.Tuple;
+
+@Service
+@Transactional
+public class InterfaceManService extends OnlBaseService {
+
+	@Autowired
+	@Qualifier("interfaceDao")
+	private InterfaceDao dao;
+
+	@Autowired
+	@Qualifier("adapterDao")
+	private AdapterDao adapterDao;
+
+	@Autowired
+	@Qualifier("monitoringContext")
+	private MonitoringContext monitoringContext;
+
+	@Autowired
+	@Qualifier("transformMappingManService")
+	private TransformMappingManService transMapping;
+
+	@Autowired
+	@Qualifier("fieldExtractInfoService")
+	private FieldExtractInfoService fieldExtractInfoService;
+
+	@Autowired
+	private InterfaceManUIMapper interfaceManUIMapper;
+
+	@Autowired
+	private AdapterManService adapterManService;
+
+	@Autowired
+	private EAIMessageService eaiMessageService;
+
+	@Autowired
+	@Qualifier("standardMessageInfoQueryServiceForApi")
+	StandardMessageInfoQueryServiceForApi standardMessageInfoQueryServiceForApi;
+
+	@Autowired
+	StdMessageManService stdMessageManService;
+
+	@Autowired
+	StandardMessageInfoService standardMessageInfoService;
+
+	@Autowired
+	StdMessageUIMapper stdMessageUIMapper;
+
+	@Autowired
+	EaiMsgManService eaiMsgManService;
+
+	@Autowired
+	ServiceMessageUIMapper serviceMessageUIMapper;
+
+	@Autowired
+	SequenceService sequenceService;
+
+	@Transactional(readOnly = false, transactionManager = "transactionManager")
+	public Page<InterfaceUI> selectList(EAIMessageUISearch eaiMessageUISearch, Pageable pageable, String sortname,  String sortorder) {
+		Page<Tuple> tuples = eaiMessageService.selectList(eaiMessageUISearch, pageable, sortname, sortorder);
+
+		return tuples.map(tuple -> {
+			EAIMessageEntity eaiMessageEntity = tuple.get(QEAIMessageEntity.eAIMessageEntity);
+			String psvsysadptrbzwkgroupname = StringUtils
+					.getStringValue(tuple.get(QServiceMessageEntity.serviceMessageEntity.psvsysadptrbzwkgroupname), "");
+			String strIo = "I";
+			String strDivCd = eaiMessageEntity.getEaisvcname().substring(eaiMessageEntity.getEaisvcname().length() - 2,
+					eaiMessageEntity.getEaisvcname().length());
+
+			if (strDivCd.equals("S2") || strDivCd.equals("R2")) {
+				strIo = "O";
+			}
+
+			InterfaceUI interfaceUI = interfaceManUIMapper.toVoWithoutChildren(eaiMessageEntity);
+			interfaceUI.setIo(strIo);
+			if (!"".equals(psvsysadptrbzwkgroupname)) {
+				interfaceUI.setToName(psvsysadptrbzwkgroupname.substring(1, 4));
+			} else {
+				interfaceUI.setToName(psvsysadptrbzwkgroupname);
+			}
+
+			return interfaceUI;
+		});
+	}
+
+	public InterfaceUI selectDetail(String eaiSvcName) {
+
+		InterfaceUI interfaceUI = eaiMessageService.findById(eaiSvcName).map(interfaceManUIMapper::toVo)
+				.orElse(new InterfaceUI());
+
+		String strSvcMotivUseDstcd = "";
+
+		List<ServiceMessageUI> listServiceMessagUI = interfaceUI.getServiceMessages();
+
+		if (listServiceMessagUI != null && listServiceMessagUI.size() > 0) {
+			for (int i = 0; i < listServiceMessagUI.size(); i++) {
+				if (i == 0) {
+					if ("SYNC".equals(interfaceUI.getSvcMotivUseDstcd())
+							&& "SYNC".equals(listServiceMessagUI.get(i).getPsvIntfacDsticName())) {
+						strSvcMotivUseDstcd = "SYNC";
+					} else if ("ASYN".equals(interfaceUI.getSvcMotivUseDstcd())
+							&& "ASYN".equals(listServiceMessagUI.get(i).getPsvIntfacDsticName())) {
+						strSvcMotivUseDstcd = "ASYN";
+					} else if ("SYNC".equals(interfaceUI.getSvcMotivUseDstcd())
+							&& "ASYN".equals(listServiceMessagUI.get(i).getPsvIntfacDsticName())) {
+						strSvcMotivUseDstcd = "SYNC_ASYN";
+					} else if ("ASYN".equals(interfaceUI.getSvcMotivUseDstcd())
+							&& "SYNC".equals(listServiceMessagUI.get(i).getPsvIntfacDsticName())) {
+						strSvcMotivUseDstcd = "ASYN_SYNC";
+					}
+
+					interfaceUI.setToAdapter(listServiceMessagUI.get(i).getPsvSysAdptrBzwkGroupName());
+					interfaceUI.setLayoutMappingName(listServiceMessagUI.get(i).getChngMsgIdName());
+				} else if (i == 1) {
+					interfaceUI.setExtAdpater(listServiceMessagUI.get(i).getPsvSysAdptrBzwkGroupName());
+				}
+			}
+		}
+
+		interfaceUI.setSvcMotivUseDstcd(strSvcMotivUseDstcd);
+
+		String strServiceId = "";
+		String strBzwkSvcKeyName = "";
+		Optional<StandardMessageInfo> optional = standardMessageInfoQueryServiceForApi.findByEaiSvcName(eaiSvcName);
+		if (optional.isPresent()) {
+			StandardMessageInfo standardMessageInfo = optional.get();
+			List<StandardMessageItem> listStdMsgItem = standardMessageInfo.getStandardMessageItems();
+
+			for (StandardMessageItem tmpItem : listStdMsgItem) {
+				if ("INTERFACE_COMMON.API_PATH".equals(tmpItem.getId().getColumnname())) {
+					strServiceId = tmpItem.getColumnvalue().toString();
+					strBzwkSvcKeyName = tmpItem.getId().getBzwksvckeyname();
+				}
+			}
+		}
+
+		if ("FEP".equals(DataSourceContextHolder.getDataSourceType().getName())) {
+			setIoBySuffix(interfaceUI);
+		} else {
+			// FEP 이외에는 당발로 고정
+			interfaceUI.setIo("I");
+		}
+
+		interfaceUI.setServiceId(strServiceId);
+		interfaceUI.setBzwkSvcKeyName(strBzwkSvcKeyName);
+		if (!interfaceUI.getServiceMessages().isEmpty()
+				&& !interfaceUI.getServiceMessages().get(0).getEaiReferenceMessages().isEmpty()) {
+			interfaceUI.setLayoutMappingName(
+					interfaceUI.getServiceMessages().get(0).getEaiReferenceMessages().get(0).getRefMsgIdName());
+		} else {
+			interfaceUI.setLayoutMappingName("");
+		}
+
+		Page<FieldExtractInfoUI> pgBzwkFldName = fieldExtractInfoService.selectList(eaiSvcName, Pageable.unpaged());
+		List<FieldExtractInfoUI> arrBzwkFldName = new ArrayList<FieldExtractInfoUI>();
+
+		if (pgBzwkFldName != null && pgBzwkFldName.hasContent()) {
+			arrBzwkFldName = pgBzwkFldName.getContent();
+
+			for (int i = 0; i < arrBzwkFldName.size(); i++) {
+				if (i == 0) {
+					interfaceUI.setBzwkFldName1(arrBzwkFldName.get(i).getBzwkFldName());
+				} else if (i == 1) {
+					interfaceUI.setBzwkFldName2(arrBzwkFldName.get(i).getBzwkFldName());
+				}
+			}
+		}
+		if (!DataSourceContextHolder.getDataSourceType()
+				.equals(DataSourceTypeManager.getDataSourceType(DataSourceTypeManager.FEP))) {
+			interfaceUI.setSourceSystem(KakaoCardInterfaceNamingRule.getSourceFromIntfId(eaiSvcName));
+			interfaceUI.setTargetSystem(KakaoCardInterfaceNamingRule.getTargetFromIntfId(eaiSvcName));
+		}
+
+		return interfaceUI;
+	}
+
+	private void setIoBySuffix(InterfaceUI interfaceUI) {
+		if (!Objects.isNull(interfaceUI.getEaiSvcName())) {
+			String eaiSvcName = interfaceUI.getEaiSvcName();
+			if (eaiSvcName.endsWith("S1") || eaiSvcName.endsWith("R2")) {
+				interfaceUI.setIo("O");
+			} else if (eaiSvcName.endsWith("S2") || eaiSvcName.endsWith("R1")) {
+				interfaceUI.setIo("I");
+			} else {
+				interfaceUI.setIo("error");
+			}
+		} else {
+			interfaceUI.setIo("eaisvcname null");
+		}
+	}
+
+	public void update(InterfaceUI interfaceUI) throws Exception {
+
+		createInterfaceJummun(interfaceUI);
+	}
+
+	public String insert(InterfaceUI interfaceUI) throws Exception {
+		// 1.중복체크
+		Optional<EAIMessageEntity> dupCheck = eaiMessageService.findById(interfaceUI.getEaiSvcName());
+		if (dupCheck.isPresent()) {
+			String bzwkDstcd = (String) dupCheck.get().getEaibzwkdstcd();
+			throw new BizException("업무명[" + bzwkDstcd + "]로 이미 등록된 인터페이스입니다.\n조회가 되지 않을 시 담당자에게 문의바랍니다.");
+		}
+
+		// 2.등록
+		createInterfaceJummun(interfaceUI);
+		return null;
+	}
+
+	public void delete(InterfaceUI interfaceUI) throws Exception {
+
+		// 1.추적관리필드 삭제
+		fieldExtractInfoService.delete(interfaceUI.getEaiSvcName(), "TR");
+
+		// 2.참조메세지ID 삭제
+		// 3.EAI메시지 삭제
+		eaiMsgManService.delete(interfaceUI.getEaiSvcName());
+
+		// 4.내부표준전문 삭제
+		if (interfaceUI.getBzwkSvcKeyName() != null) {
+			Optional<StandardMessageInfo> standardMessageInfo = standardMessageInfoService
+					.findById(interfaceUI.getBzwkSvcKeyName());
+			if (standardMessageInfo.isPresent()) {
+				standardMessageInfoService.delete(standardMessageInfo.get());
+			}
+		}
+	}
+
+//	public HashMap selectCombo(String userId) throws Exception {
+//		HashMap paramMap = new HashMap();
+//		paramMap.put("userId", userId);
+// 
+//		// 전체 목록수 얻기
+//		List list = bizDao.selectUserBizCodes(paramMap);
+//		
+//		HashMap map = new HashMap();
+//
+//		map.put("bizList", list);
+//
+//		return map;
+//	}
+//	public HashMap selectDetailCombo(String userId) throws Exception {
+//		HashMap paramMap = new HashMap();
+//		paramMap.put("userId", userId);
+// 
+//		// 업무구분
+//		List listBiz = bizDao.selectUserBizCodes(paramMap);
+//
+//		// 당타발구분
+//		List<ComboVo> listIo = comboService.getFromCode("IO_TYPE");
+//
+//		// 전문요청구분
+//		List<ComboVo> listReqRes = comboService.getFromCode("REQRES_TYPE");
+//		// 송수신방법
+//		List<ComboVo> listSyncAsync = comboService.getFromCode("SYNCASYNC_TYPE");
+//
+//		// 거래흐름(INBOUND);
+//		paramMap = new HashMap();
+//		paramMap.put("adptrIoDstcd", "IN");
+//		List listFrom = adapterDao.selectListCombo(paramMap);
+//		
+//		//거래흐름(OUTBOUND);
+//		paramMap = new HashMap();
+//		paramMap.put("adptrIoDstcd", "OU");
+//		List listTo = adapterDao.selectListCombo(paramMap);
+//		//거래흐름(ASBOUND);
+//		paramMap = new HashMap();
+//		paramMap.put("adptrIoDstcd", "OU");
+//		paramMap.put("asyncDstCd", "As");
+//		List listExt = adapterDao.selectListCombo(paramMap);
+//		
+//		HashMap map = new HashMap();
+//
+//		map.put("bizList", listBiz);
+//		map.put("ioList", listIo);
+//		map.put("reqResList", listReqRes);
+//		map.put("syncAsyncList", listSyncAsync);
+//		map.put("fromList", listFrom);
+//		map.put("toList", listTo);
+//		map.put("extList", listExt);
+//
+//		return map;
+//	}	
+	public List<AdapterGroupUI> selectAdapterCombo(String adptrIoDstcd) {
+		List<AdapterGroupUI> selectAdapterGroup = adapterManService.selectListComboForAdptrIoDstcd(adptrIoDstcd);
+		List<AdapterGroupUI> resultList = new ArrayList<AdapterGroupUI>();
+
+		for (AdapterGroupUI tmpAdapter : selectAdapterGroup) {
+			if ("1".equals(tmpAdapter.getAdptruseyn())) {
+				resultList.add(tmpAdapter);
+			}
+		}
+
+		return resultList;
+	}
+
+	public String createInterfaceJummun(InterfaceUI interfaceUI) throws Exception {
+		logger.info("-------------------<< createInterfaceJummun >>----------------------------");
+		logger.debug("{}", interfaceUI);
+		logger.info("-------------------<< session 값체크>>----------------------------");
+
+		boolean isOnline = false;
+		for (DataSourceType ds : DataSourceTypeManager.getOnlineDataSourceTypes()) {
+			if (ds.getName().equals(DataSourceContextHolder.getDataSourceType().getName())) {
+				isOnline = true;
+				break;
+			}
+		}
+
+		if (!isOnline) {
+			throw new BizException("로그인 오류 (재로그인 하시기 바랍니다.)");
+		}
+
+		String currentDatasourceDstCd = DataSourceContextHolder.getDataSourceType().getName().substring(0, 1);
+		interfaceUI.setEaiSevrDstcd(currentDatasourceDstCd);
+		interfaceUI.setAuthor(SessionManager.getLoginVo().getUserId());
+		interfaceUI.setUseYn("1");
+		interfaceUI.setVerInfo("0");
+		interfaceUI.setTranType("R");
+
+		logger.info("-1. 내부 표준 전문 INSERT ----------------------------------------------------");
+		// 1. 내부 표준 전문 INSERT
+		// 비표준에서 표준으로 가는 경우 표준으로 전환하기 위한 정보 이므로 내부로 갈 때만 처리
+		if (!"SYNC_ASYN".equals(interfaceUI.getSvcMotivUseDstcd()) || !(interfaceUI.getEaiSvcName()).endsWith("R01")) { // EAI
+																														// :
+																														// SY_AS
+																														// R01의
+																														// toAdapter는
+																														// 더미
+			if (interfaceUI.getFromAdapter() == null || interfaceUI.getFromAdapter().isEmpty()
+					|| interfaceUI.getToAdapter() == null || interfaceUI.getToAdapter().isEmpty()) {
+				throw new Exception("INBOUND/OUTBOUND 설정이 되지 않았습니다.");
+			}
+		}
+
+		AdapterGroupUI adapterGroup = new AdapterGroupUI();
+
+		try {
+			adapterGroup = adapterManService.selectDetail(interfaceUI.getFromAdapter());
+		} catch (Throwable e) {
+			throw new Exception("INBOUND어댑터 오류입니다.");
+		}
+		if (!Keys.IF_STANDARD.equals(adapterGroup.getAdptrmsgptrncd())) { // 내부표준이 아니면 처리
+			if (interfaceUI.getServiceId().isEmpty()) {
+				throw new Exception("내부표준전문 생성 오류!(입력전문ID null)");
+			}
+			if (interfaceUI.getBzwkSvcKeyName().isEmpty()) {
+				throw new Exception("내부표준전문 생성 오류!(업무추출키 null)");
+			}
+
+			if ("S".equals(interfaceUI.getSplizDmndDstcd()) && "".equals(interfaceUI.getServiceId().trim())) { // Send(요청)의
+																												// 경우만
+				throw new Exception("내부표준전문 생성 오류!(입력전문ID space)");
+			}
+			if ("".equals(interfaceUI.getBzwkSvcKeyName().trim())) {
+				throw new Exception("내부표준전문 생성 오류!(업무추출키 space)");
+			}
+
+			// 기존에 데이터가 없을경우 insert 있을 경우 update
+			Optional<StandardMessageInfo> standardMessageInfo = standardMessageInfoService
+					.findById(interfaceUI.getBzwkSvcKeyName());
+
+			if (standardMessageInfo.isPresent()) {
+				StdMessageUI stdMessageUI = new StdMessageUI();
+				Map<String, Object> paramMap = new HashMap<String, Object>();
+				String strDirection = interfaceUI.getEaiSvcName().substring(interfaceUI.getEaiSvcName().length() - 1,
+						interfaceUI.getEaiSvcName().length());
+
+				stdMessageUI.setBzwkSvcKeyName(interfaceUI.getBzwkSvcKeyName());
+				stdMessageUI.setEaiSvcName(interfaceUI.getEaiSvcName());
+				stdMessageUI.setEaiTranName(interfaceUI.getEaiTranName());
+				stdMessageUI.setEaiSendRecv(interfaceUI.getSplizDmndDstcd());
+				stdMessageUI.setEaiDirection(strDirection);
+
+				paramMap.put("bzwksvckeyname", interfaceUI.getBzwkSvcKeyName());
+				paramMap.put("columnname", "INTERFACE_COMMON.API_PATH");
+				paramMap.put("columnvalue", interfaceUI.getServiceId());
+
+				stdMessageManService.update(paramMap, stdMessageUI);
+			} else {
+				StdMessageUI stdMessageUI = new StdMessageUI();
+				StdMessageItemUI stdMessageItemUI = new StdMessageItemUI();
+				List<StdMessageItemUI> listStdMessageItemUI = new ArrayList<>();
+				String strDirection = interfaceUI.getEaiSvcName().substring(interfaceUI.getEaiSvcName().length() - 1,
+						interfaceUI.getEaiSvcName().length());
+
+				stdMessageUI.setBzwkSvcKeyName(interfaceUI.getBzwkSvcKeyName());
+				stdMessageUI.setEaiSvcName(interfaceUI.getEaiSvcName());
+				stdMessageUI.setEaiTranName(interfaceUI.getEaiTranName());
+				stdMessageUI.setEaiSendRecv(interfaceUI.getSplizDmndDstcd());
+				stdMessageUI.setEaiDirection(strDirection);
+
+				stdMessageItemUI.setBzwksvckeyname(interfaceUI.getBzwkSvcKeyName());
+				stdMessageItemUI.setColumnname("INTERFACE_COMMON.API_PATH");
+				stdMessageItemUI.setColumnvalue(interfaceUI.getServiceId());
+				listStdMessageItemUI.add(stdMessageItemUI);
+				stdMessageUI.setStandardMessageItems(listStdMessageItemUI);
+
+				StandardMessageInfo insStandardMessageInfo = stdMessageUIMapper.toEntity(stdMessageUI);
+				standardMessageInfoService.save(insStandardMessageInfo);
+			}
+
+			logger.debug("TEST");
+
+		} else {
+			// 표준전문일 경우
+			Optional<StandardMessageInfo> standardMessageInfo = standardMessageInfoService
+					.findById(interfaceUI.getEaiTranName().replaceAll("_", "") + interfaceUI.getSplizDmndDstcd()
+							+ interfaceUI.getStndTelgmWtinExtnlDstcd());
+
+			if (standardMessageInfo.isPresent()) {
+				stdMessageManService.delete(interfaceUI.getBzwkSvcKeyName());
+			}
+		}
+
+		logger.info("-2. EAI메세지 INSERT -------------------------------------------------------");
+		// 2. EAI메세지 INSERT
+		///////////////////////////////////////////////////////////////////////////////////////////
+		// FlowControl 라우팅명 셋팅 - B2B 라우터 설정 확인 ( rms.flowcontrol.b2bfc )
+		///////////////////////////////////////////////////////////////////////////////////////////
+
+		String b2bfcs = monitoringContext.getStringProperty(MonitoringContext.RMS_FLOWCONTROL_B2BFC, "");
+		if (b2bfcs.indexOf(interfaceUI.getEaiTranName().substring(0, 3)) > -1
+				&& interfaceUI.getEaiSvcName().endsWith("2")) {
+			interfaceUI.setFlowCtrlRoutName(InterfaceKeys.FCR_B2B);
+		} else {
+			if (interfaceUI.getEaiSvcName().endsWith("R1")) {
+				interfaceUI.setFlowCtrlRoutName(InterfaceKeys.FCR_C2R);
+			} else {
+				interfaceUI.setFlowCtrlRoutName(InterfaceKeys.FCR_BAS);
+			}
+		}
+
+		///////////////////////////////////////////////////////////////////////////////////////////
+		// FlowControl 라우팅명 셋팅 - 큐 설정 확인 ( rms.flowcontrol.queue.[EAI/FEP].[001~012] )
+		///////////////////////////////////////////////////////////////////////////////////////////
+		for (int i = 1; i <= 12; i++) {
+			String propKey = MonitoringContext.RMS_FLOWCONTROL_QUEUE + "."
+					+ DataSourceContextHolder.getDataSourceType().getName() + "." + StringUtils.leftPad("" + i, 3, "0");
+			String queues = monitoringContext.getStringProperty(propKey, "");
+			if (queues.indexOf(interfaceUI.getEaiTranName().substring(0, 3) + interfaceUI.getSplizDmndDstcd()
+					+ interfaceUI.getStndTelgmWtinExtnlDstcd()) > -1) {
+				interfaceUI.setFlowCtrlRoutName(
+						interfaceUI.getFlowCtrlRoutName() + "_" + StringUtils.leftPad("" + i, 3, "0"));
+				break;
+			}
+		}
+
+		///////////////////////////////////////////////////////////////////////////////////////////
+		// FailOver 설정 - FailOver 대상(당발요청S2,타발응답R2)이면 사용함으로 셋팅 (
+		/////////////////////////////////////////////////////////////////////////////////////////// rms.failover.target.[EAI/FEP]
+		/////////////////////////////////////////////////////////////////////////////////////////// )
+		///////////////////////////////////////////////////////////////////////////////////////////
+		interfaceUI.setFailOver(false);
+		if (!(DataSourceTypeManager.EAI.equals(DataSourceContextHolder.getDataSourceType().getName())
+				&& "2".equals(interfaceUI.getStndTelgmWtinExtnlDstcd()))
+				|| DataSourceTypeManager.EAI.equals(DataSourceContextHolder.getDataSourceType().getName())) {
+			String propKey = MonitoringContext.RMS_FAILOVER_TARGET + "."
+					+ DataSourceContextHolder.getDataSourceType().getName();
+			String failOvers = monitoringContext.getStringProperty(propKey, "");
+			if (failOvers.indexOf(interfaceUI.getEaiTranName().substring(0, 3)) > -1) {
+				interfaceUI.setFailOver(true);
+			}
+		}
+
+		// 현재시간 구해서 최종수정시각 추가
+//        SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMddHHmmss");
+//        interfaceUI.setEaiLastAmndYMS(LocalDateTime.parse(String.valueOf(System.currentTimeMillis()), DateTimeFormatter.ofPattern( "yyyyMMddHHmmss")));
+
+		// interfaceUI.setEaiLastAmndYMS(DateUtil.getDateTimeMilliSecound());
+
+		// 화면에서 가져오지 않은 값 기존 값으로 대체
+		// insert/update에 사용할 대체 값 생성
+		EAIMessageEntity insertObj = new EAIMessageEntity();
+		Optional<EAIMessageEntity> beforeEAIMessageEntity = eaiMessageService.findById(interfaceUI.getEaiSvcName());
+		Boolean isUpdate = false;
+		if (beforeEAIMessageEntity.isPresent()) {
+
+			EAIMessageEntity eaiMessageEntity = beforeEAIMessageEntity.get();
+			interfaceUI.setFlowCtrlRoutName(!interfaceUI.getFlowCtrlRoutName().isEmpty()
+					? interfaceUI.getFlowCtrlRoutName()
+					: eaiMessageEntity.getFlowctrlroutname().isEmpty() ? "" : eaiMessageEntity.getFlowctrlroutname());
+			interfaceUI.setDmndErrChngIdName(!interfaceUI.getDmndErrChngIdName().isEmpty()
+					? interfaceUI.getDmndErrChngIdName()
+					: eaiMessageEntity.getDmnderrchngidname().isEmpty() ? "" : eaiMessageEntity.getDmnderrchngidname());
+			interfaceUI.setRspnsErrChngIdName(!interfaceUI.getRspnsErrChngIdName().isEmpty()
+					? interfaceUI.getRspnsErrChngIdName()
+					: eaiMessageEntity.getFlowctrlroutname().isEmpty() ? "" : eaiMessageEntity.getFlowctrlroutname());
+			interfaceUI.setRspnsErrChngIdName(
+					!interfaceUI.getRspnsErrChngIdName().isEmpty() ? interfaceUI.getRspnsErrChngIdName()
+							: eaiMessageEntity.getRspnserrchngidname().isEmpty() ? ""
+									: eaiMessageEntity.getRspnserrchngidname());
+			interfaceUI.setEaiSevrDstcd(!interfaceUI.getEaiSevrDstcd().isEmpty() ? interfaceUI.getEaiSevrDstcd()
+					: eaiMessageEntity.getEaisevrdstcd().isEmpty() ? "" : eaiMessageEntity.getEaisevrdstcd());
+			interfaceUI.setEaiGroupCoCd(!interfaceUI.getEaiGroupCoCd().isEmpty() ? interfaceUI.getEaiGroupCoCd()
+					: eaiMessageEntity.getEaigroupcocd().isEmpty() ? "" : eaiMessageEntity.getEaigroupcocd());
+			interfaceUI.setFlowCtrlRoutName(!interfaceUI.getFlowCtrlRoutName().isEmpty()
+					? interfaceUI.getFlowCtrlRoutName()
+					: eaiMessageEntity.getFlowctrlroutname().isEmpty() ? "" : eaiMessageEntity.getFlowctrlroutname());
+			interfaceUI.setModfiMgtStusDstcd(!interfaceUI.getModfiMgtStusDstcd().isEmpty()
+					? interfaceUI.getModfiMgtStusDstcd()
+					: eaiMessageEntity.getModfimgtstusdstcd().isEmpty() ? "" : eaiMessageEntity.getModfimgtstusdstcd());
+			interfaceUI.setTranType(!interfaceUI.getTranType().isEmpty() ? interfaceUI.getTranType()
+					: eaiMessageEntity.getTrantype().isEmpty() ? "" : eaiMessageEntity.getTrantype());
+			interfaceUI.setUseYn(!interfaceUI.getUseYn().isEmpty() ? interfaceUI.getUseYn()
+					: eaiMessageEntity.getUseyn().isEmpty() ? "" : eaiMessageEntity.getUseyn());
+
+			// update일 경우 기존 entity 를 조회하여 set
+			insertObj = eaiMessageService.getById(interfaceUI.getEaiSvcName());
+			isUpdate = true;
+		}
+
+		// 기동 어뎁터
+		// Async 인 경우 As, Sync인 경우 Sy
+		// SOCKET 인 경우 처리 후 개별 수정 하는 것으로 !
+		// he01, he02 동시에 interfaceUI 를 사용해야 하기 때문에 구분코드를 type 에 임시 저장하고 해당 값을 사용
+		String type = interfaceUI.getSvcMotivUseDstcd();
+		if ("ASYN".equals(type) || "SYNC".equals(type)) {
+			interfaceUI.setSvcMotivUseDstcd(type);
+		} else if ("ASYN_SYNC".equals(type)) {
+			interfaceUI.setSvcMotivUseDstcd("SYNC");
+		} else if ("SYNC_ASYN".equals(type)) {
+			interfaceUI.setSvcMotivUseDstcd("ASYN");
+		}
+
+		interfaceUI.setSvcHMSEonot("0");
+		interfaceUI.setSvcPrcesDsticName("SINGLE");
+		interfaceUI.setIntgraDsticName("ONLINE");
+		interfaceUI.setSvcBfClmnLogYn("0");
+		interfaceUI.setGstatSysAdptrBzwkGroupName(interfaceUI.getFromAdapter());
+		interfaceUI.setSevrLogLvelNo(0);
+		interfaceUI.setSvcLogLvelNo(3);
+
+		// serviceMessages 값을 set 필요함 기존값을 그대로 가지고오고 상황에 따라 값을 변경하여 다시 집어넣는다.
+		// svcprcssno 가 1 개인 경우 2 개인 경우가 발생할 수 있음
+		ServiceMessageUI serviceMessageUI = new ServiceMessageUI();
+
+		if ("ASYN".equals(type) || "SYNC".equals(type)) {
+			serviceMessageUI.setPsvIntfacDsticName(type);
+		} else if ("ASYN_SYNC".equals(type)) {
+			serviceMessageUI.setPsvIntfacDsticName("SYNC");
+		} else if ("SYNC_ASYN".equals(type)) {
+			serviceMessageUI.setPsvIntfacDsticName("ASYN");
+		}
+
+		serviceMessageUI.setEaiSvcName(interfaceUI.getEaiSvcName());
+		serviceMessageUI.setSvcPrcssNo(1);
+		serviceMessageUI.setPsvSysBzwkDstcd(interfaceUI.getEaiBzwkDstcd());
+		serviceMessageUI.setPsvsysidname("EAIDOM");
+		serviceMessageUI.setPsvSysSvcDsticName(" ");
+		serviceMessageUI.setFlovrYn(interfaceUI.getFailOver() ? "1" : "0");
+		serviceMessageUI.setChngEonot("0");
+		serviceMessageUI.setChngMsgIdName("");
+		serviceMessageUI.setBascRspnsMsgCmprCtnt("");
+		serviceMessageUI.setBascRspnsChngEonot("0");
+		serviceMessageUI.setBascRspnsChngMsgIdName("");
+		serviceMessageUI.setErrRspnsMsgCmprCtnt("");
+		serviceMessageUI.setErrRspnsChngEonot("0");
+		serviceMessageUI.setErrRspnsChngMsgIdName("");
+		serviceMessageUI.setNextSvcPrcssNo(1);
+		serviceMessageUI.setToutVal(Long.parseLong("60"));
+		serviceMessageUI.setCmpenSvcPrcssDsticName("");
+		serviceMessageUI.setSupplDelYn("0");
+		serviceMessageUI.setHdrCtrlDstcd("01");
+		serviceMessageUI.setHdrRefClsName("");
+		serviceMessageUI.setRestOption("");
+		serviceMessageUI.setPsvSysAdptrBzwkGroupName(interfaceUI.getToAdapter());
+
+		if ("SYNC_ASYN".equals(type) && interfaceUI.getEaiSvcName().endsWith("R1")) { // EAI에 한함
+			serviceMessageUI.setPsvSysAdptrBzwkGroupName(" ");
+			serviceMessageUI.setOutbndRoutName("HTTPOUT");
+		} else {
+			if ("NET".equals(interfaceUI.getToAdapter().substring(8, 11))) {
+				serviceMessageUI.setOutbndRoutName("SOCKETOUT");
+			} else if ("HTT".equals(interfaceUI.getToAdapter().substring(8, 11))) {
+				serviceMessageUI.setOutbndRoutName("HTTPOUT");
+			}
+		}
+
+		serviceMessageUI.setEaiReferenceMessages(new ArrayList<EAIReferenceMessageUI>());
+		serviceMessageUI.setCondPerRtgInfos(new ArrayList<CondPerRtgInfoUI>());
+
+		logger.info("-3. 참조메시지ID INSERT ----------------------------------------------------");
+		if (interfaceUI.getLayoutMappingName() != null && !interfaceUI.getLayoutMappingName().trim().isEmpty()) {
+			// EAIReferenceMessageUI 가 존재함 해당 값 insert
+			EAIReferenceMessageUI eaiReferenceMessageUI = new EAIReferenceMessageUI();
+
+			eaiReferenceMessageUI.setEaiSvcName(interfaceUI.getEaiSvcName());
+			eaiReferenceMessageUI.setSvcPrcssNo(1);
+			eaiReferenceMessageUI.setRefMsgIdNo(1);
+			eaiReferenceMessageUI.setRefMsgIdName(interfaceUI.getLayoutMappingName().replaceAll(",", ";"));
+			serviceMessageUI.getEaiReferenceMessages().add(eaiReferenceMessageUI);
+		}
+
+		logger.debug("--------------------------------------------------------------------------");
+		interfaceUI.setServiceMessages(new ArrayList<ServiceMessageUI>());
+		interfaceUI.getServiceMessages().add(serviceMessageUI);
+
+//        if( isUpdate == true ){
+//            interfaceUI.setServiceMessages(new ArrayList<ServiceMessageUI>());
+//            interfaceUI.getServiceMessages().add(serviceMessageUI);
+//        } else {
+//            insertObj.setServiceMessages(new ArrayList<ServiceMessageEntity>());
+//            ServiceMessageEntity insSrvMessage = serviceMessageUIMapper.toEntity(serviceMessageUI);
+//            insSrvMessage.setEaimessage(insertObj);
+//            insertObj.getServiceMessages().add(insSrvMessage);
+//        }
+
+		if ("ASYN_SYNC".equals(type)) {
+			ServiceMessageUI subServiceMessageUI = new ServiceMessageUI();
+
+			if ("S".equals(interfaceUI.getExtAdpater().substring(12, 13))) {
+				subServiceMessageUI.setPsvIntfacDsticName("SYNC");
+			} else {
+				subServiceMessageUI.setPsvIntfacDsticName("ASYN");
+			}
+
+			subServiceMessageUI.setEaiSvcName(interfaceUI.getEaiSvcName());
+			subServiceMessageUI.setSvcPrcssNo(2);
+			subServiceMessageUI.setPsvSysBzwkDstcd(interfaceUI.getEaiBzwkDstcd());
+			subServiceMessageUI.setPsvsysidname("EAIDOM");
+			subServiceMessageUI.setPsvSysSvcDsticName(" ");
+			subServiceMessageUI.setFlovrYn(interfaceUI.getFailOver() ? "1" : "0");
+			subServiceMessageUI.setChngEonot("0");
+			subServiceMessageUI.setChngMsgIdName("");
+			subServiceMessageUI.setBascRspnsMsgCmprCtnt("");
+			subServiceMessageUI.setBascRspnsChngEonot("0");
+			subServiceMessageUI.setBascRspnsChngMsgIdName("");
+			subServiceMessageUI.setErrRspnsMsgCmprCtnt("");
+			subServiceMessageUI.setErrRspnsChngEonot("0");
+			subServiceMessageUI.setErrRspnsChngMsgIdName("");
+			subServiceMessageUI.setNextSvcPrcssNo(1);
+			subServiceMessageUI.setToutVal(Long.parseLong("60"));
+			subServiceMessageUI.setCmpenSvcPrcssDsticName("");
+			subServiceMessageUI.setSupplDelYn("0");
+			subServiceMessageUI.setHdrCtrlDstcd("01");
+			subServiceMessageUI.setHdrRefClsName("");
+			subServiceMessageUI.setRestOption("");
+			subServiceMessageUI.setPsvSysAdptrBzwkGroupName(interfaceUI.getExtAdpater());
+			subServiceMessageUI
+					.setOutbndRoutName(interfaceUI.getExtAdpater().indexOf("NET") > -1 ? "SOCKETOUT" : "HTTPOUT");
+
+			subServiceMessageUI.setEaiReferenceMessages(new ArrayList<EAIReferenceMessageUI>());
+			subServiceMessageUI.setCondPerRtgInfos(new ArrayList<CondPerRtgInfoUI>());
+			interfaceUI.getServiceMessages().add(subServiceMessageUI);
+		}
+
+		interfaceManUIMapper.updateEntity(interfaceUI, insertObj);
+
+		if (isUpdate == true) {
+			insertObj.getServiceMessages().clear();
+			ServiceMessageEntity insSrvMessage = serviceMessageUIMapper.toEntity(serviceMessageUI);
+			insSrvMessage.setEaimessage(insertObj);
+			insertObj.getServiceMessages().add(insSrvMessage);
+		} else {
+			insertObj.setServiceMessages(new ArrayList<ServiceMessageEntity>());
+			ServiceMessageEntity insSrvMessage = serviceMessageUIMapper.toEntity(serviceMessageUI);
+			insSrvMessage.setEaimessage(insertObj);
+			insertObj.getServiceMessages().add(insSrvMessage);
+		}
+
+		eaiMessageService.save(insertObj);
+
+//        dao.mergeToHE01(vo);
+//        dao.mergeToHE02(vo);
+//        logger.info("-3. 참조메시지ID INSERT ----------------------------------------------------");
+//        // 3. 참조메시지ID INSERT
+//        //if( vo.get("layoutMappingName") != null && !"".equals(((String)vo.get("layoutMappingName")).trim())) {   //삭제
+//        //transMapping.appContext = this.appContext;
+//        HashMap<String,Object> transform = new HashMap<String,Object>();
+//        transform.put("eaiSvcName", interfaceUI.getEaiSvcName());
+//        transform.put("refMsgIdName",( interfaceUI.getLayoutMappingName().replaceAll(",", ";")));
+//        transMapping.insertRefMsgID(transform);
+//        //if( rts <= 0) {
+//        //   throw new BizException("참조메세지ID 생성 실패");
+//        //}
+//        //}
+//
+//        logger.debug("--------------------------------------------------------------------------");
+		logger.info("-4. 추적관리필드 INSERT -----------------------------------------------------");
+		// 4. 추적관리필드 INSERT
+
+		Page<FieldExtractInfoUI> fieldExtractInfoUIList = fieldExtractInfoService
+				.selectList(interfaceUI.getEaiSvcName(), Pageable.unpaged());
+
+		if (!fieldExtractInfoUIList.isEmpty()) {
+			fieldExtractInfoUIList.forEach(e -> fieldExtractInfoService.delete(e.getEaiSvcName(), e.getEtractDstcd()));
+		}
+
+		if (interfaceUI.getLayoutMappingName() != null && !"".equals(interfaceUI.getLayoutMappingName())) {
+
+			FieldExtractInfoUI fieldExtractInfoUI = new FieldExtractInfoUI();
+
+			fieldExtractInfoUI.setEaiSvcName(interfaceUI.getEaiSvcName());
+			fieldExtractInfoUI.setEtractDstcd("TR");
+			fieldExtractInfoUI.setFldprcssno(1);
+			fieldExtractInfoUI.setMsgDstcd("ASC");
+
+			fieldExtractInfoUI.setBzwkFldName(StringUtils.split(interfaceUI.getLayoutMappingName(), ",")[0]);
+			int count = 0;
+			if (interfaceUI.getBzwkFldName1() != null && !"".equals(StringUtils.trim(interfaceUI.getBzwkFldName1()))) {
+				count++;
+			}
+			if (interfaceUI.getBzwkFldName2() != null && !"".equals(StringUtils.trim(interfaceUI.getBzwkFldName2()))) {
+				count++;
+			}
+			String[][] bzwkFldArray = new String[count][3];
+			String[] bzwkFldsArray = new String[count];
+			if (interfaceUI.getBzwkFldName1() != null && !"".equals(StringUtils.trim(interfaceUI.getBzwkFldName1()))) {
+				bzwkFldArray[0][0] = StringUtils.trim(interfaceUI.getBzwkFldName1());
+				bzwkFldArray[0][1] = "0"; // StringUtils.getStringValue(vo.get("msgFldStartSituVal1"), "0");
+				bzwkFldArray[0][2] = "0"; // StringUtils.getStringValue(vo.get("msgFldLen1"), "0");
+				bzwkFldsArray[0] = StringUtils.trim(interfaceUI.getBzwkFldName1());
+			}
+			if (interfaceUI.getBzwkFldName2() != null && !"".equals(StringUtils.trim(interfaceUI.getBzwkFldName2()))) {
+				bzwkFldArray[1][0] = StringUtils.trim(interfaceUI.getBzwkFldName2());
+				bzwkFldArray[1][1] = "0"; // StringUtils.getStringValue(vo.get("msgFldStartSituVal2"), "0");
+				bzwkFldArray[1][2] = "0"; // StringUtils.getStringValue(vo.get("msgFldLen2"), "0");
+				bzwkFldsArray[1] = StringUtils.trim(interfaceUI.getBzwkFldName2());
+			}
+			StringBuilder sb = new StringBuilder();
+			sb.append("bzwkFldArray :");
+			for (String[] keys : bzwkFldArray) {
+				for (String key : keys) {
+					sb.append("[" + key + "],");
+				}
+				sb.append("\n");
+			}
+			if (logger.isDebugEnabled()) {
+				logger.debug("vo.getBzwkFldName1()=[" + interfaceUI.getBzwkFldName1() + "]");
+				logger.debug("vo.getBzwkFldName2()=[" + interfaceUI.getBzwkFldName2() + "]");
+				logger.debug("{}", sb);
+			}
+			fieldExtractInfoUI.setBzwkFldNames(bzwkFldsArray);
+
+			fieldExtractInfoService.insert(fieldExtractInfoUI);
+		}
+
+		return "";
+	}
+
+	public String getIncresedInterfaceId(HashMap<String, String> paramMap) {
+
+		String source = paramMap.get("source");
+		String target = paramMap.get("target");
+
+		String seqStr = String.format("%05d", 1);
+
+		String strInsKey = KakaoCardInterfaceNamingRule.makeSeqKey(source, target);
+
+		Optional<SequenceEntity> seqId = sequenceService.findById(strInsKey);
+
+		if (seqId.isPresent()) {
+			seqStr = String.format("%05d", seqId.get().getNext_val() + 1);
+		} else {
+			SequenceEntity insSeqEntity = new SequenceEntity();
+			insSeqEntity.setSequence_name(strInsKey);
+			insSeqEntity.setNext_val(1L);
+
+			sequenceService.save(insSeqEntity);
+		}
+
+		return KakaoCardInterfaceNamingRule.sourceTargetToIntfId(source, target, seqStr);
+	}
+
+	public Page<InterfaceUI> selectPopList(Pageable pageable, String eaiSvcName, String serviceType) {
+		Page<EAIMessageEntity> page = eaiMessageService.findAll(pageable, eaiSvcName);
+
+		List<InterfaceUI> interfaceUIs = page.getContent().stream()
+				.map(entity -> convertToInterfaceUI(entity, serviceType)).collect(Collectors.toList());
+
+		return new PageImpl<>(interfaceUIs, pageable, page.getTotalElements());
+	}
+
+	private InterfaceUI convertToInterfaceUI(EAIMessageEntity entity, String serviceType) {
+		InterfaceUI interfaceUI = new InterfaceUI();
+		String getEaiSvcName = entity.getEaisvcname();
+
+		interfaceUI.setEaiSvcName(getEaiSvcName);
+		interfaceUI.setEaiBzwkDstcd(entity.getEaibzwkdstcd());
+		interfaceUI.setEaiSvcDesc(entity.getEaisvcdesc());
+		interfaceUI.setEaiTranName(getEaiSvcName.substring(0, getEaiSvcName.length() - 2));
+
+		String lastTwoChars = getEaiSvcName.substring(getEaiSvcName.length() - 2);
+
+		if ("EAI".equals(serviceType)) {
+			interfaceUI.setIo(("S2".equals(lastTwoChars) || "R2".equals(lastTwoChars)) ? "O" : "I");
+		} else {
+			interfaceUI.setIo(("S2".equals(lastTwoChars) || "R1".equals(lastTwoChars)) ? "O" : "I");
+		}
+
+		interfaceUI.setSplizDmndDstcd(lastTwoChars.substring(0, 1)); // set S / R
+		interfaceUI.setEaiSevrDstcd(entity.getEaisevrdstcd());
+
+		return interfaceUI;
+	}
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/extnl/KakaoCardInterfaceNamingRule.java

@@ -0,0 +1,39 @@
+package com.eactive.eai.rms.onl.transaction.extnl;
+
+import org.apache.log4j.Logger;
+
+public class KakaoCardInterfaceNamingRule {
+   
+   private static final Logger logger = Logger.getLogger(KakaoCardInterfaceNamingRule.class);
+   
+   public static String makeKey(String source, String target) {
+      return source + "_" + target + "_";
+   }
+
+   public static String makeSeqKey(String source, String target) {
+      return source + "_" + target;
+   }
+   
+   public static String sourceTargetToIntfId(String source, String target, String seq) {
+      return source + "_" + target + "_" + seq;
+   }
+   
+   public static String getSourceFromIntfId(String interfaceId) {
+      try {
+         return interfaceId.split("_")[0];
+      } catch (Exception e) {
+         logger.warn(e);
+         return "";
+      }
+   }
+   
+   public static String getTargetFromIntfId(String interfaceId) {
+      try {
+         return interfaceId.split("_")[1];
+      } catch (Exception e) {
+         logger.warn(e);
+         return "";
+      }
+   }
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/extnl/mapping/InterfaceManUIMapper.java

@@ -0,0 +1,69 @@
+package com.eactive.eai.rms.onl.transaction.extnl.mapping;
+
+import com.eactive.eai.data.entity.onl.message.EAIMessageEntity;
+import com.eactive.eai.data.mapper.BaseMapperConfig;
+import com.eactive.eai.data.mapper.GenericMapper;
+import com.eactive.eai.rms.data.entity.onl.code.CodeService;
+import com.eactive.eai.rms.onl.manage.serviceinfo.eaimsg.mapping.ServiceMessageUIMapper;
+import com.eactive.eai.rms.onl.transaction.extnl.ui.InterfaceUI;
+import org.mapstruct.*;
+import org.springframework.beans.factory.annotation.Autowired;
+
+@Mapper(config = BaseMapperConfig.class, uses = { ServiceMessageUIMapper.class })
+public abstract class InterfaceManUIMapper implements GenericMapper<InterfaceUI, EAIMessageEntity> {
+
+   @Autowired
+   private CodeService codeService;
+
+   @Mapping(source = "eaisvcname", target = "eaiSvcName")
+   @Mapping(source = "eaibzwkdstcd", target = "eaiBzwkDstcd")
+   @Mapping(target = "eaiTranName", expression = "java(entity.getEaisvcname().substring(0, entity.getEaisvcname().length() - 2))")
+   @Mapping(source = "eaisvcdesc", target = "eaiSvcDesc")
+   @Mapping(target = "splizDmndDstcd", expression = "java(entity.getEaisvcname().substring(entity.getEaisvcname().length()-2, entity.getEaisvcname().length()-1))")
+   @Mapping(target = "stndTelgmWtinExtnlDstcd", expression = "java(entity.getEaisvcname().substring(entity.getEaisvcname().length()-1, entity.getEaisvcname().length()))")
+   @Mapping(target = "fromName", expression="java(entity.getEaisvcname().substring(0,3))")
+   @Mapping(target = "toName", expression="java(entity.getEaisvcname().substring(4,7))")
+
+   @Mapping(source = "gstatsysadptrbzwkgroupname", target = "fromAdapter")
+   @Mapping(source = "svcmotivusedstcd", target = "svcMotivUseDstcd")
+
+   @Mapping(source = "flowctrlroutname", target = "flowCtrlRoutName")
+   @Mapping(source = "dmnderrchngidname", target = "dmndErrChngIdName")
+   @Mapping(source = "rspnserrchngidname", target = "rspnsErrChngIdName")
+   @Mapping(source = "rspnserrfldname", target = "rspnsErrFldName")
+   @Mapping(source = "eaisevrdstcd", target = "eaiSevrDstcd")
+   @Mapping(source = "eaigroupcocd", target = "eaiGroupCoCd")
+   @Mapping(source = "modfimgtstusdstcd", target = "modfiMgtStusDstcd")
+   @Mapping(source = "trantype", target = "tranType")
+   @Mapping(source = "useyn", target = "useYn")
+
+//   @Mapping(source = "eailastamndyms", target = "eaiLastAmndYMS")
+
+   @Mapping(source = "svchmseonot", target = "svcHMSEonot")
+   @Mapping(source = "svcprcesdsticname", target = "svcPrcesDsticName")
+   @Mapping(source = "intgradsticname", target = "intgraDsticName")
+   @Mapping(source = "svcbfclmnlogyn", target = "svcBfClmnLogYn")
+   @Mapping(source = "gstatsysadptrbzwkgroupname", target = "gstatSysAdptrBzwkGroupName")
+   @Mapping(source = "sevrloglvelno", target = "sevrLogLvelNo")
+   @Mapping(source = "svcloglvelno", target = "svcLogLvelNo")
+
+   @Mapping(source = "author", target = "author")
+   @Mapping(source = "refkey", target = "bzwkSvcKeyName")
+   @Mapping(source = "verinfo", target = "verInfo")
+
+   @Override
+   public abstract InterfaceUI toVo(EAIMessageEntity entity);
+
+   @InheritInverseConfiguration(name = "toVo")
+   @Override
+   public abstract EAIMessageEntity toEntity(InterfaceUI vo);
+
+   @InheritConfiguration
+   @Mapping(target = "serviceMessages", ignore = true)
+   public abstract InterfaceUI toVoWithoutChildren(EAIMessageEntity entity);
+
+   @InheritConfiguration
+   @BeanMapping(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE)
+   public abstract void updateEntity(InterfaceUI interfaceUI, @MappingTarget EAIMessageEntity eaiMessageEntity);
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/extnl/ui/InterfaceUI.java

@@ -0,0 +1,136 @@
+package com.eactive.eai.rms.onl.transaction.extnl.ui;
+
+import com.eactive.eai.rms.onl.manage.serviceinfo.eaimsg.ui.ServiceMessageUI;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+import javax.persistence.Column;
+import java.util.List;
+
+@Data
+public class InterfaceUI {
+
+    @JsonProperty("EAIBZWKDSTCD")
+    private String eaiBzwkDstcd;
+
+    /* IF 서비스코드 */
+    @JsonProperty("EAISVCNAME")
+    private String eaiSvcName;
+
+    @JsonProperty("EAISVCDESC")
+    private String eaiSvcDesc;
+
+    /* 인터페이스 ID : if 서비스코드 substr(-2) */
+    @JsonProperty("EAITRANNAME")
+    private String eaiTranName;
+
+    /* IO : case 문으로 정리 */
+    @JsonProperty("IO")
+    private String io;
+
+    // 전문요청구분 S, R IF서비스코드 substr(-1, 1) */
+    @JsonProperty("SPLIZDMNDDSTCD")
+    private String splizDmndDstcd;
+
+    // 대내외구별코드 1, 2 IF서비스코드 substr(-1) */
+    @JsonProperty("STNDTELGMWTINEXTNLDSTCD")
+    private String stndTelgmWtinExtnlDstcd;
+
+    @JsonProperty("FROMNAME")
+    private String fromName;
+
+    @JsonProperty("TONAME")
+    private String toName;
+
+    @JsonProperty("SERVICEID")
+    private String serviceId;
+
+    @JsonProperty("LAYOUTMAPPINGNAME")
+    private String layoutMappingName;
+
+    @JsonProperty("BZWKFLDNAME1")
+    private String bzwkFldName1;
+
+    @JsonProperty("BZWKFLDNAME2")
+    private String bzwkFldName2;
+
+    @JsonProperty("FROMADAPTER")
+    private String fromAdapter;
+
+    @JsonProperty("TOADAPTER")
+    private String toAdapter;
+
+    @JsonProperty("EXTADAPTER")
+    private String extAdpater;
+
+    @JsonProperty("BZWKSVCKEYNAME")
+    private String bzwkSvcKeyName;
+
+    @Column(length = 4)
+    @JsonProperty("SVCMOTIVUSEDSTCD")
+    private String svcMotivUseDstcd;
+
+    @JsonProperty("OCCURDSTCD")
+    private String occurDstcd;
+
+    @JsonProperty("TRANSKIND")
+    private String transKind;
+
+    @JsonProperty("AUTHOR")
+    private String author;
+
+    @JsonProperty("FLOWCTRLROUTNAME")
+    private String flowCtrlRoutName;
+
+    @JsonProperty("DMNDERRCHNGIDNAME")
+    private String dmndErrChngIdName;
+
+    @JsonProperty("RSPNSERRCHNGIDNAME")
+    private String rspnsErrChngIdName;
+
+    @JsonProperty("RSPNSERRFLDNAME")
+    private String rspnsErrFldName;
+
+    @JsonProperty("EAISEVRDSTCD")
+    private String eaiSevrDstcd;
+
+    @JsonProperty("EAIGROUPCOCD")
+    private String eaiGroupCoCd;
+
+    @JsonProperty("MODFIMGTSTUSDSTCD")
+    private String modfiMgtStusDstcd;
+
+    @JsonProperty("TRANTYPE")
+    private String tranType;
+
+    @JsonProperty("USEYN")
+    private String useYn;
+
+    @JsonProperty("VERINFO")
+    private String verInfo;
+
+    @JsonProperty("SOURCESYSTEM")
+    private String sourceSystem;
+
+    @JsonProperty("TARGETSYSTEM")
+    private String targetSystem;
+
+//    @JsonProperty("EAILASTAMNDYMS")
+//    private LocalDateTime eaiLastAmndYMS;
+
+    @JsonProperty("FAILOVER")
+    private Boolean failOver;
+
+    private String svcHMSEonot;
+    private String svcPrcesDsticName;
+    private String intgraDsticName;
+    private String svcBfClmnLogYn;
+    private String gstatSysAdptrBzwkGroupName;
+    private Integer sevrLogLvelNo;
+    private Integer svcLogLvelNo;
+
+    private List<ServiceMessageUI> serviceMessages;
+
+//    @JsonProperty("bizAll")
+//    private List<BizKey> bizKeys;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/online/TransactionOnlineManController.java

@@ -0,0 +1,236 @@
+package com.eactive.eai.rms.onl.transaction.online;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Pageable;
+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.bind.annotation.SessionAttribute;
+import org.springframework.web.servlet.ModelAndView;
+
+import com.eactive.eai.data.entity.onl.server.EAIServer;
+import com.eactive.eai.rms.common.combo.ComboService;
+import com.eactive.eai.rms.common.combo.ComboVo;
+import com.eactive.eai.rms.common.login.LoginVo;
+import com.eactive.eai.rms.common.spring.BaseController;
+import com.eactive.eai.rms.common.util.CommonConstants;
+import com.eactive.eai.rms.common.vo.GridResponse;
+import com.eactive.eai.rms.data.entity.onl.server.EAIServerService;
+import com.eactive.eai.rms.onl.common.exception.BizException;
+import com.eactive.eai.rms.onl.common.exception.EMSRuntimeException;
+import com.eactive.eai.rms.onl.common.service.MemoryTrInitService;
+import com.eactive.eai.rms.onl.common.util.CallAgentUtil;
+import com.eactive.eai.rms.onl.common.vo.HostInfomationForm;
+import com.google.gson.Gson;
+
+@Controller
+public class TransactionOnlineManController extends BaseController {
+
+	private static final String AGENT_INIT_PAGE = "transaction_status_init_agent.jsp";
+
+	private TransactionOnlineManService service;
+
+	private MemoryTrInitService memTrInitService;
+
+	private ComboService comboService;
+	
+	private EAIServerService eaiServerService;
+
+	@Autowired
+	public TransactionOnlineManController(TransactionOnlineManService service, MemoryTrInitService memTrInitService,
+			ComboService comboService, EAIServerService eaiServerService) {
+		this.service = service;
+		this.memTrInitService = memTrInitService;
+		this.comboService = comboService;
+		this.eaiServerService = eaiServerService;
+	}
+
+	@GetMapping(value = "/onl/transaction/online/transactionStatus.view")
+	public String viewList() {
+		return "/onl/transaction/online/transactionStatus";
+	}
+
+	@GetMapping(value = "/onl/transaction/online/transactionStatus.view", params = "cmd=DETAIL")
+	public String viewDetail() {
+		return "/onl/transaction/online/transactionStatusDetail";
+	}
+
+	@GetMapping(value = "/onl/transaction/online/transactionStatus.view", params = "cmd=POPUP")
+	public String viewPopup() {
+		return "/onl/transaction/online/transactionStatusPopup";
+	}
+
+	@PostMapping(value = "/onl/transaction/online/transactionStatus.json", params = "cmd=LIST")
+	public ResponseEntity<GridResponse<TransactionOnlineUI>> selectList(String recentYn,
+			@SessionAttribute(CommonConstants.LOGIN) LoginVo loginVo) {
+		String userId = loginVo.getUserId();
+		List<TransactionOnlineUI> list = service.selectList(userId, recentYn);
+		return ResponseEntity.ok(new GridResponse<>(list));
+
+	}
+
+	@SuppressWarnings("unchecked")
+	@PostMapping(value = "/onl/transaction/online/transactionStatus.json", params = "cmd=DETAIL")
+	public ResponseEntity<Map<String, Object>> detailList(@SessionAttribute(CommonConstants.LOGIN) LoginVo loginVo,
+			Pageable pageable, String recentYn, String onlySum, String searchEaiBzwkDstcd, String searchFilter)
+			throws Exception {
+
+		String userId = loginVo.getUserId();
+
+		if (searchFilter == null) {
+			searchFilter = "";
+		} else {
+			searchFilter = searchFilter.trim().toUpperCase();
+		}
+
+		if (searchEaiBzwkDstcd == null || "null".equals(searchEaiBzwkDstcd)) {
+			searchEaiBzwkDstcd = "";
+		}
+
+		Map<String, Object> result = service.selectDetailList(userId, recentYn, searchEaiBzwkDstcd, searchFilter);
+
+		int totalCount = ((List<Map<String, Object>>) result.get("list")).size();
+
+		Map<String, Object> resultMap = new HashMap<>();
+		resultMap.put("total", totalCount); // 전체 페이지수
+		resultMap.put("page", pageable.getPageNumber()); // 현재 페이지수
+		resultMap.put("records", totalCount);// 전체 레코드건수
+
+		if ("Y".equals(onlySum)) {
+			resultMap.put("rows", result.get("onlySumList"));
+		} else {
+			resultMap.put("rows", result.get("sumList"));
+		}
+
+		resultMap.put("summary", result.get("summary"));
+
+		return ResponseEntity.ok(resultMap);
+	}
+
+	@PostMapping(value = "/onl/transaction/online/transactionStatus.json", params = "cmd=LIST_DETAIL_COMBO")
+	public ResponseEntity<Map<String, Object>> selectDetailCombo() {
+		List<ComboVo> bizList = comboService.getFromUserBusiness();
+		Map<String, Object> map = new HashMap<>();
+		map.put("bizList", bizList);
+
+		return ResponseEntity.ok(map);
+	}
+
+	@PostMapping(value = "/onl/transaction/online/transactionStatus.json", params = "cmd=LIST_USER_BIZ")
+	public ModelAndView selectListUserBiz(@SessionAttribute(CommonConstants.LOGIN) LoginVo loginVo) {
+		String userId = loginVo.getUserId();
+		List<TransactionTrackingFilterUI> list = service.selectTransformTrackingFilterList(userId);
+		HashMap<String, Object> map = new HashMap<>();
+		map.put("rows", list);
+		return new ModelAndView("jsonView", map);
+	}
+
+	@PostMapping(value = "/onl/transaction/online/transactionStatus.json", params = "cmd=CHANGE_USER_BIZ")
+	public ResponseEntity<Void> transactionUserBiz(@SessionAttribute(CommonConstants.LOGIN) LoginVo loginVo,
+			@RequestParam("gridData") List<TransactionTrackingFilterUI> transactionTrackingFilterUIs) {
+		String userId = loginVo.getUserId();
+		service.insertTransactionTrackingFilter(userId, transactionTrackingFilterUIs);
+		return ResponseEntity.ok().build();
+	}
+
+	@PostMapping(value = "/onl/transaction/online/transactionStatus.json", params = "cmd=INITIALIZE")
+	public ModelAndView initialize(HttpServletRequest request, HttpServletResponse response, String recentYn)
+			  {
+		String errMsg = callAgentInitPage(recentYn);
+
+		Map<String, Object> resultMap = new HashMap<>();
+		resultMap.put("message", errMsg);
+		return new ModelAndView("jsonView", resultMap);
+	}
+
+	public String callAgentInitPage(String recentYn) {
+		List<EAIServer> serverList = eaiServerService.selectEaiServerIpList();
+
+		if (serverList.isEmpty()) {
+			throw new BizException("서버리스트가 없습니다.");
+		}
+		
+		CallAgentUtil agentUtil = new CallAgentUtil();
+		String result = "";
+		StringBuilder errMsg = new StringBuilder();
+		for (EAIServer serverMap : serverList) {
+			String instName = serverMap.getEaisevrinstncname();
+			String ip = serverMap.getEaisevrip();
+			String port = serverMap.getSevrlsnportname();
+			String host = serverMap.getHostname();
+
+			String http = "http://" + ip + ":" + port + HostInfomationForm.WEB_AGENT_CONTEXT_PATH + AGENT_INIT_PAGE
+					+ "?recentYn=" + recentYn;
+			// 특정 instance 에서 에러가 발생해도 계속 진행할 수 있도록 하기 위해
+			try {
+				result = agentUtil.getAgentDataToString(http);
+			} catch (Exception e) {
+				result = e.getMessage();
+			}
+			if (!"INIT:OK".equals(result)) {
+				errMsg.append(instName).append(" :실패(").append(result).append(")\n");
+			}
+
+			// 해당 host 및 인스턴스에 대한 거래건수 정보를
+			// 메모리 Repository 에서 초기화 한다.
+			try {
+				memTrInitService.clearTransactionMemoryMap(host, instName);
+			} catch (Exception e) {
+				logger.error("clearTransactionMemory error", e);
+			}
+
+		}
+		
+		if (errMsg.length() > 0) {
+			errMsg.insert(0, "초기화에 실패했습니다. (").append(")");
+			throw new EMSRuntimeException(errMsg.toString());
+		}
+		
+		return errMsg.toString();
+	}
+
+	@PostMapping(value = "/onl/transaction/online/transactionStatus.json", params = "cmd=LIST_CODE")
+	public ResponseEntity<Map<String, Object>> codeList(@SessionAttribute(CommonConstants.LOGIN) LoginVo loginVo) {
+		HashMap<String, Object> resultMap = new HashMap<>();
+
+		List<TransactionTrackingFilterUI> codeList = service.selectListByUserOnlyUse(loginVo.getUserId());
+
+		resultMap.put("codeList", codeList);
+		return ResponseEntity.ok(resultMap);
+	}
+
+	@SuppressWarnings("unchecked")
+	@PostMapping(value = "/onl/transaction/online/transactionStatus.excel", params = "cmd=LIST_GRID_TO_EXCEL")
+	public ModelAndView listGridToExcel(String gridData, String header, String headerTitle, String fileName,
+			String merge) {
+		HashMap<String, Object> resultMap = new HashMap<>();
+
+		Gson gson = new Gson();
+		HashMap<String, Object>[] list = gson.fromJson(gridData, HashMap[].class);
+
+		String[] headers = gson.fromJson(header, String[].class);
+		String[] headerTitles = gson.fromJson(headerTitle, String[].class);
+
+		HashMap<String, Object>[] lmerge = null;
+		if (merge != null) {
+			lmerge = gson.fromJson(merge, HashMap[].class);
+		}
+
+		resultMap.put("headers", headers);
+		resultMap.put("headerTitles", headerTitles);
+		resultMap.put("datas", list);
+		resultMap.put("fileName", fileName);
+		resultMap.put("merge", lmerge);
+		return new ModelAndView("excelView", resultMap);
+	}
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/online/TransactionOnlineManService.java

@@ -0,0 +1,651 @@
+package com.eactive.eai.rms.onl.transaction.online;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.eactive.eai.data.entity.onl.server.EAIServer;
+import com.eactive.eai.data.entity.onl.unifbwk.UnifBwkTp;
+import com.eactive.eai.rms.common.datasource.DataSourceContextHolder;
+import com.eactive.eai.rms.data.entity.onl.server.EAIServerService;
+import com.eactive.eai.rms.data.entity.onl.transaction.TransactionTrackingFilter;
+import com.eactive.eai.rms.data.entity.onl.transaction.TransactionTrackingFilterService;
+import com.eactive.eai.rms.data.entity.onl.unifbwk.UnifBwkTpService;
+import com.eactive.eai.rms.onl.adapter.socket.MapComparator;
+import com.eactive.eai.rms.onl.common.service.EAISvcCodeMapService;
+import com.eactive.eai.rms.onl.server.repository.TransactionRepositoryService;
+import com.eactive.eai.rms.onl.vo.TransactionTrackingVo;
+
+import edu.emory.mathcs.backport.java.util.Collections;
+
+@Service("transactionOnlineService")
+@Transactional
+public class TransactionOnlineManService {
+
+	private EAISvcCodeMapService eaiSvcCodeMapService;
+
+	private TransactionRepositoryService transactionRepositoryService;
+
+	private UnifBwkTpService unifBwkTpService;
+
+	private EAIServerService eaiServerService;
+
+	private TransactionTrackingFilterService transactionTrackingFilterService;
+
+	private TransactionTrackingFilterUIMapper transactionTrackingFilterUIMapper;
+
+	@Autowired
+	public TransactionOnlineManService(TransactionRepositoryService transactionRepositoryService,
+			UnifBwkTpService unifBwkTpService, EAIServerService eaiServerService,
+			TransactionTrackingFilterService transactionTrackingFilterService,
+			EAISvcCodeMapService eaiSvcCodeMapService,
+			TransactionTrackingFilterUIMapper transactionTrackingFilterUIMapper) {
+		this.unifBwkTpService = unifBwkTpService;
+		this.eaiServerService = eaiServerService;
+		this.transactionTrackingFilterService = transactionTrackingFilterService;
+		this.eaiSvcCodeMapService = eaiSvcCodeMapService;
+		this.transactionTrackingFilterUIMapper = transactionTrackingFilterUIMapper;
+		this.transactionRepositoryService = transactionRepositoryService;
+	}
+
+	public List<TransactionTrackingVo> findTransactionList(List<EAIServer> instList) {
+
+		TransactionTrackingVo origin = new TransactionTrackingVo();
+
+		List<TransactionTrackingVo> list = new ArrayList<>();
+		for (EAIServer eaiServer : instList) {
+
+			origin.setHostName(eaiServer.getHostname());
+			origin.setInstanceName(eaiServer.getEaisevrinstncname());
+
+			TransactionTrackingVo vo = transactionRepositoryService.getTrackingVo(origin);
+
+			if (vo != null) {
+				vo.setService(DataSourceContextHolder.getDataSourceType().getName());
+				list.add(vo);
+			}
+		}
+		return list;
+	}
+
+	public List<TransactionOnlineUI> selectList(String userId, String recentYn) {
+		// 권한이 등록리스트 TSEAIRM06
+		List<UnifBwkTp> unifBwkTps = unifBwkTpService.findUserBizCodesByUserId(userId);
+		List<EAIServer> instList = eaiServerService.selectEaiServerIpList();
+		List<TransactionTrackingVo> transactionTrackings = findTransactionList(instList);
+
+		// filter하고 싶은 업무코드 TSEAIMN04
+		Set<String> filter = transactionTrackingFilterService
+				.findAllByUserId(userId)
+				.stream()
+				.map(f -> f.getId().getEaibzwkdstcd())
+				.collect(Collectors.toSet());
+
+		List<TransactionOnlineUI> result = new ArrayList<>();
+		DecimalFormat f1 = new DecimalFormat("##0.###");
+		for (UnifBwkTp unifBwkTp : unifBwkTps) { // 권한이 부여된 리스트
+			String bizCode = unifBwkTp.getEaibzwkdstcd();
+			String bizName = unifBwkTp.getBzwkdsticname();
+
+			if (!filter.contains(bizCode)) {
+				continue;
+			}
+			selectList(recentYn, bizCode, bizName, transactionTrackings, result, f1);
+		}
+		return result;
+	}
+
+	private void selectList(String recentYn, String bizCode, String bizName,
+			List<TransactionTrackingVo> transactionTrackings, List<TransactionOnlineUI> result, DecimalFormat f1) {
+		Integer checkCount = 0;
+
+		double timeEai = 0;
+		double timePsv = 0;
+		double timeTotal = 0;
+
+		double countEai = 0;
+		double countPsv = 0;
+		double countTotal = 0;
+
+		TransactionTrackingVo sum = new TransactionTrackingVo();
+		for (TransactionTrackingVo transactionTrackingVo : transactionTrackings) {
+			HashMap<String, HashMap<String, TransactionTrackingVo>> map;
+			HashMap<String, TransactionTrackingVo> mapSub;
+
+			if ("Y".equals(recentYn)) { // recent 10 mins
+				map = transactionTrackingVo.getMapRecent();
+			} else { // today
+				map = transactionTrackingVo.getMapToday();
+			}
+
+			// EAI 서버에서 map 값이 null 인 상태로 값이 오는경우 Exception 발생을 방지하기 위함.
+			if (map == null) {
+				continue;
+			}
+
+			// DB 에 있는 업무코드는 CHAR[4] 타입이다.
+			mapSub = map.get(bizCode);
+
+			if (mapSub == null) {
+				continue;
+			}
+
+			Iterator<String> it = mapSub.keySet().iterator();
+			String[] svcKeys = new String[mapSub.size()]; // eai service code
+			for (int j = 0; it.hasNext(); j++) {
+				svcKeys[j] = it.next();
+			}
+			Arrays.sort(svcKeys);
+
+			for (int k = 0; k < svcKeys.length; k++) {
+				TransactionTrackingVo vo = mapSub.get(svcKeys[k]);
+
+				sum.addProc100(vo.getProc100());
+				sum.addProc200(vo.getProc200());
+				sum.addProc300(vo.getProc300());
+				sum.addProc400(vo.getProc400());
+				sum.addError100(vo.getError100());
+				sum.addError200(vo.getError200());
+				sum.addError300(vo.getError300());
+				sum.addError400(vo.getError400());
+				sum.addError900(vo.getError900());
+				sum.addError9300(vo.getError9300());
+				sum.addError9400(vo.getError9400());
+				sum.addError9900(vo.getError9900());
+
+				// 공정한 평균값 을 계산하기 위해
+				// 계산식을 수정한다.
+				if (vo.getTimeEai() != 0 || vo.getTimePsv() != 0 || vo.getTimeTotal() != 0) {
+					timeEai += vo.getTimeEai();
+					countEai++;
+					timePsv += vo.getTimePsv();
+					countPsv++;
+					timeTotal += vo.getTimeTotal();
+					countTotal++;
+				}
+
+				checkCount++;
+
+				sum.addTps(vo.getTps());
+			} // for svcKeys
+		}
+		if (checkCount == 0)
+			return; // There is no VO data !
+
+		if (countEai == 0)
+			countEai = 1;
+		if (countPsv == 0)
+			countPsv = 1;
+		if (countTotal == 0)
+			countTotal = 1;
+
+		TransactionOnlineUI transactionOnlineUI = new TransactionOnlineUI();
+		transactionOnlineUI.setBizCode(bizCode);
+		transactionOnlineUI.setBizName(bizName);
+		transactionOnlineUI.setProc100(sum.getProc100());
+		transactionOnlineUI.setProc200(sum.getProc200());
+		transactionOnlineUI.setProc300(sum.getProc300());
+		transactionOnlineUI.setProc400(sum.getProc400());
+
+		transactionOnlineUI.setError100(sum.getError100());
+		transactionOnlineUI.setError200(sum.getError200());
+		transactionOnlineUI.setError300(sum.getError300());
+		transactionOnlineUI.setError400(sum.getError400());
+		transactionOnlineUI.setError900(sum.getError900());
+
+		transactionOnlineUI.setError9300(sum.getError9300());
+		transactionOnlineUI.setError9400(sum.getError9400());
+		transactionOnlineUI.setError9900(sum.getError9900());
+
+		transactionOnlineUI.setAvgEai(f1.format(Double.isNaN(timeEai / countEai) ? 0 : (timeEai / countEai)));
+		transactionOnlineUI.setAvgPsv(f1.format(Double.isNaN(timePsv / countPsv) ? 0 : (timePsv / countPsv)));
+		transactionOnlineUI.setAvgTotal(f1.format(Double.isNaN(timeTotal / countTotal) ? 0 : (timeTotal / countTotal)));
+
+		result.add(transactionOnlineUI);
+	}
+
+	public Map<String, Object> selectDetailList(String userId, String recentYn, String bwk, String searchFilter)
+			throws Exception {
+		// 권한이 등록리스트 TSEAIRM06
+		List<UnifBwkTp> unifBwkTps = unifBwkTpService.findUserBizCodesByUserId(userId);
+		List<EAIServer> instList = eaiServerService.selectEaiServerIpList();
+		List<TransactionTrackingVo> transactionTrackings = findTransactionList(instList);
+
+		// filter하고 싶은 업무코드 TSEAIMN04
+		Set<String> filter = transactionTrackingFilterService
+				.findAllByUserId(userId)
+				.stream()
+				.map(f -> f.getId().getEaibzwkdstcd())
+				.collect(Collectors.toSet());
+
+		HashMap<String, String> allEaiSvcMap = eaiSvcCodeMapService.selectAllMap();
+
+		String[] arrFilter = null;
+		if (!"".equals(searchFilter)) {
+			arrFilter = searchFilter.split(",");
+		}
+
+		DecimalFormat f1 = new DecimalFormat("##0.###");
+
+		List<HashMap<String, Object>> result = new ArrayList<>();
+		Map<String, Object> resultMap = new HashMap<>();
+		Map<String, Object> summaryMap = new HashMap<>();
+		int p100 = 0;
+		int p200 = 0;
+		int p300 = 0;
+		int p400 = 0;
+
+		int e100 = 0;
+		int e200 = 0;
+		int e300 = 0;
+		int e400 = 0;
+		int e900 = 0;
+
+		int e9300 = 0;
+		int e9400 = 0;
+		int e9900 = 0;
+
+		double avgEai = 0.0f;
+		double avgPsv = 0.0f;
+		double avgTotal = 0.0f;
+
+		int totCount = 0;
+
+		for (UnifBwkTp unifBwkTp : unifBwkTps) { // 권한이 부여된 리스트
+			String bizCode = unifBwkTp.getEaibzwkdstcd();
+			String bizName = unifBwkTp.getBzwkdsticname();
+			if (!filter.contains(bizCode))
+				continue; // 보고싶은 업무구분코드 본다.
+			if (!"".equals(bwk) && !bizCode.equals(bwk))
+				continue; // select filter
+			for (TransactionTrackingVo instVo : transactionTrackings) {
+				HashMap<String, HashMap<String, TransactionTrackingVo>> map;
+				HashMap<String, TransactionTrackingVo> mapSub;
+
+				if ("Y".equals(recentYn)) { // recent 10 mins
+					map = instVo.getMapRecent();
+				} else { // today
+					map = instVo.getMapToday();
+				}
+
+				// EAI 서버에서 map 값이 null 인 상태로 값이 오는경우 Exception 발생을 방지하기 위함.
+				if (map == null) {
+					continue;
+				}
+
+				// DB 에 있는 업무코드는 CHAR[4] 타입이다.
+				mapSub = map.get(bizCode);
+
+				if (mapSub == null) {
+					continue;
+				}
+
+				Iterator<String> it = mapSub.keySet().iterator();
+				String[] svcKeys = new String[mapSub.size()]; // eai service code
+				for (int j = 0; it.hasNext(); j++) {
+					svcKeys[j] = it.next();
+				}
+				Arrays.sort(svcKeys);
+
+				for (int k = 0; k < svcKeys.length; k++) {
+					TransactionTrackingVo vo = mapSub.get(svcKeys[k]);
+					if (arrFilter != null) {
+						boolean isFound = false;
+						for (String f : arrFilter) {
+							if (vo.getEaiServiceCode().indexOf(f) > -1) {
+								isFound = true;
+								break;
+							}
+						}
+
+						if (!isFound) {
+							continue;
+						}
+					}
+
+					HashMap<String, Object> m = new HashMap<>();
+					m.put("BIZCODE", bizCode);
+					m.put("BIZNAME", bizName);
+
+					m.put("SVCCODE", vo.getEaiServiceCode());
+					m.put("SVCNAME", allEaiSvcMap.get(vo.getEaiServiceCode()));
+					m.put("INSTNAME", instVo.getInstanceName());
+
+					m.put("P100", vo.getProc100());
+					m.put("P200", vo.getProc200());
+					m.put("P300", vo.getProc300());
+					m.put("P400", vo.getProc400());
+
+					m.put("E100", vo.getError100());
+					m.put("E200", vo.getError200());
+					m.put("E300", vo.getError300());
+					m.put("E400", vo.getError400());
+					m.put("E900", vo.getError900());
+
+					m.put("E9300", vo.getError9300());
+					m.put("E9400", vo.getError9400());
+					m.put("E9900", vo.getError9900());
+					m.put("E9900", vo.getError9900());
+
+					m.put("AVGEAI", vo.getTimeEai());
+					m.put("AVGPSV", vo.getTimePsv());
+					m.put("AVGTOTAL", vo.getTimeTotal());
+
+					result.add(m);
+
+					// 전문별 거래현황 합계
+					p100 += vo.getProc100();
+					p200 += vo.getProc200();
+					p300 += vo.getProc300();
+					p400 += vo.getProc400();
+
+					e100 += vo.getError100();
+					e200 += vo.getError200();
+					e300 += vo.getError300();
+					e400 += vo.getError400();
+					e900 += vo.getError900();
+
+					e9300 += vo.getError9300();
+					e9400 += vo.getError9400();
+					e9900 += vo.getError9900();
+
+					avgEai += vo.getTimeEai();
+					avgPsv += vo.getTimePsv();
+					avgTotal += vo.getTimeTotal();
+
+					if (vo.getProc400() > 0) {
+						totCount += vo.getProc400();
+					} else {
+						totCount += vo.getProc200();
+					}
+				} // for svcKeys
+			}
+
+		}
+
+		// 전문별 거래현황 합계
+		summaryMap.put("P100", p100);
+		summaryMap.put("P200", p200);
+		summaryMap.put("P300", p300);
+		summaryMap.put("P400", p400);
+
+		summaryMap.put("E100", e100);
+		summaryMap.put("E200", e200);
+		summaryMap.put("E300", e300);
+		summaryMap.put("E400", e400);
+		summaryMap.put("E900", e900);
+
+		summaryMap.put("E9300", e9300);
+		summaryMap.put("E9400", e9400);
+		summaryMap.put("E9900", e9900);
+
+		if (totCount > 0) {
+			summaryMap.put("AVGEAI", f1.format(avgEai / totCount));
+			summaryMap.put("AVGPSV", f1.format(avgPsv / totCount));
+			summaryMap.put("AVGTOTAL", f1.format(avgTotal / totCount));
+		} else {
+			summaryMap.put("AVGEAI", f1.format(0.0));
+			summaryMap.put("AVGPSV", f1.format(0.0));
+			summaryMap.put("AVGTOTAL", f1.format(0.0));
+		}
+
+		// 서비스별 합계 추가 start
+		List<HashMap<String, Object>> sumList = new ArrayList<>();
+		List<HashMap<String, Object>> onlySumList = new ArrayList<>();
+
+		int sumP100 = 0;
+		int sumP200 = 0;
+		int sumP300 = 0;
+		int sumP400 = 0;
+		int sumE100 = 0;
+		int sumE200 = 0;
+		int sumE300 = 0;
+		int sumE400 = 0;
+		int sumE900 = 0;
+		int sumE9300 = 0;
+		int sumE9400 = 0;
+		int sumE9900 = 0;
+
+		double sumEAI = 0;
+		double sumPSV = 0;
+		double sumTOTAL = 0;
+
+		String svcCode = "";
+		String prevSvcCode = null;
+		int divCount = 0;
+
+		String prevBizname = "";
+		String prevSvcname = "";
+
+		String[] compareParam = { "BIZNAME", "SVCCODE", "INSTNAME" };
+
+		MapComparator comp = new MapComparator(compareParam);
+		Collections.sort(result, comp);
+
+		for (int i = 0; i < result.size(); i++) {
+			HashMap<String, Object> tmp = result.get(i);
+
+			svcCode = (String) tmp.get("SVCCODE");
+
+			if (prevSvcCode != null && !svcCode.equals(prevSvcCode)) {
+				HashMap<String, Object> sumMap = new HashMap<>();
+
+				divCount = sumP400;
+
+				if (divCount == 0) {
+					divCount = sumP200;
+				}
+
+				sumMap.put("P100", sumP100);
+				sumMap.put("P200", sumP200);
+				sumMap.put("P300", sumP300);
+				sumMap.put("P400", sumP400);
+
+				if (divCount > 0) {
+					sumMap.put("AVGEAI", sumEAI / divCount);
+					sumMap.put("AVGPSV", sumPSV / divCount);
+					sumMap.put("AVGTOTAL", sumTOTAL / divCount);
+					sumMap.put("AVGEAI", f1.format((double) sumMap.get("AVGEAI")));
+					sumMap.put("AVGPSV", f1.format((double) sumMap.get("AVGPSV")));
+					sumMap.put("AVGTOTAL", f1.format((double) sumMap.get("AVGTOTAL")));
+				} else {
+					sumMap.put("AVGEAI", f1.format(0));
+					sumMap.put("AVGPSV", f1.format(0));
+					sumMap.put("AVGTOTAL", f1.format(0));
+				}
+
+				sumMap.put("E100", sumE100);
+				sumMap.put("E200", sumE200);
+				sumMap.put("E300", sumE300);
+				sumMap.put("E400", sumE400);
+				sumMap.put("E900", sumE900);
+				sumMap.put("E9300", sumE9300);
+				sumMap.put("E9400", sumE9400);
+				sumMap.put("E9900", sumE9900);
+				sumMap.put("BIZNAME", (i == 0 ? tmp.get("BIZNAME") : prevBizname));
+				sumMap.put("SVCNAME", (i == 0 ? tmp.get("SVCNAME") : prevSvcname));
+				sumMap.put("INSTNAME", "합 계");
+				sumMap.put("SVCCODE", prevSvcCode);
+
+				sumList.add(sumMap);
+				onlySumList.add(sumMap);
+				sumP100 = 0;
+				sumP200 = 0;
+				sumP300 = 0;
+				sumP400 = 0;
+
+				sumEAI = 0;
+				sumPSV = 0;
+				sumTOTAL = 0;
+
+				sumE100 = 0;
+				sumE200 = 0;
+				sumE300 = 0;
+				sumE400 = 0;
+				sumE900 = 0;
+
+				sumE9300 = 0;
+				sumE9400 = 0;
+				sumE9900 = 0;
+			}
+
+			sumP100 += (Integer) tmp.get("P100");
+			sumP200 += (Integer) tmp.get("P200");
+			sumP300 += (Integer) tmp.get("P300");
+			sumP400 += (Integer) tmp.get("P400");
+
+			int totalCount = (Integer) tmp.get("P400");
+
+			if (totalCount == 0) {
+				totalCount = (Integer) tmp.get("P200");
+			}
+			sumEAI += ((double) tmp.get("AVGEAI") * totalCount);
+			sumPSV += ((double) tmp.get("AVGPSV") * totalCount);
+			sumTOTAL += ((double) tmp.get("AVGTOTAL") * totalCount);
+
+			sumE100 += (Integer) tmp.get("E100");
+			sumE200 += (Integer) tmp.get("E200");
+			sumE300 += (Integer) tmp.get("E300");
+			sumE400 += (Integer) tmp.get("E400");
+			sumE900 += (Integer) tmp.get("E900");
+
+			sumE9300 += (Integer) tmp.get("E9300");
+			sumE9400 += (Integer) tmp.get("E9400");
+			sumE9900 += (Integer) tmp.get("E9900");
+
+			// Check
+			tmp.put("AVGEAI", f1.format((double) tmp.get("AVGEAI")));
+			tmp.put("AVGPSV", f1.format((double) tmp.get("AVGPSV")));
+			tmp.put("AVGTOTAL", f1.format((double) tmp.get("AVGTOTAL")));
+
+			sumList.add(tmp);
+			prevSvcCode = svcCode;
+
+			prevBizname = (String) tmp.get("BIZNAME");
+			prevSvcname = (String) tmp.get("SVCNAME");
+		}
+
+		if (result != null && !result.isEmpty()) {
+			HashMap<String, Object> sumMap = new HashMap<>();
+			sumMap.put("P100", sumP100);
+			sumMap.put("P200", sumP200);
+			sumMap.put("P300", sumP300);
+			sumMap.put("P400", sumP400);
+
+			divCount = sumP400;
+
+			if (divCount == 0) {
+				divCount = sumP200;
+			}
+
+			if (divCount > 0) {
+				sumMap.put("AVGEAI", sumEAI / divCount);
+				sumMap.put("AVGPSV", sumPSV / divCount);
+				sumMap.put("AVGTOTAL", sumTOTAL / divCount);
+
+				// Check
+				sumMap.put("AVGEAI", f1.format((double) sumMap.get("AVGEAI")));
+				sumMap.put("AVGPSV", f1.format((double) sumMap.get("AVGPSV")));
+				sumMap.put("AVGTOTAL", f1.format((double) sumMap.get("AVGTOTAL")));
+			} else {
+				sumMap.put("AVGEAI", f1.format(0));
+				sumMap.put("AVGPSV", f1.format(0));
+				sumMap.put("AVGTOTAL", f1.format(0));
+			}
+
+			sumMap.put("E100", sumE100);
+			sumMap.put("E200", sumE200);
+			sumMap.put("E300", sumE300);
+			sumMap.put("E400", sumE400);
+			sumMap.put("E900", sumE900);
+			sumMap.put("E9300", sumE9300);
+			sumMap.put("E9400", sumE9300);
+			sumMap.put("E9900", sumE9300);
+			sumMap.put("BIZNAME", prevBizname);
+			sumMap.put("SVCNAME", prevSvcname);
+			sumMap.put("INSTNAME", "합  계");
+			sumMap.put("SVCCODE", prevSvcCode);
+
+			sumList.add(sumMap);
+			onlySumList.add(sumMap);
+		}
+
+		resultMap.put("sumList", sumList);
+		resultMap.put("onlySumList", onlySumList);
+		resultMap.put("list", result);
+		resultMap.put("summary", summaryMap);
+
+		return resultMap;
+	}
+
+	public List<TransactionTrackingFilterUI> selectListByUserOnlyUse(String userId) {
+		List<TransactionTrackingFilterUI> transactionTrackingFilterUIs = transactionTrackingFilterService
+				.findAllByUserId(userId)
+				.stream()
+				.map(transactionTrackingFilterUIMapper::toVo)
+				.collect(Collectors.toList());
+
+		transactionTrackingFilterUIs.forEach(ui -> {
+			String bzwkdsticname = unifBwkTpService.getById(ui.getEaibzwkdstcd()).getBzwkdsticname();
+			ui.setBzwkdsticname(bzwkdsticname);
+		});
+
+		return transactionTrackingFilterUIs;
+	}
+
+	public List<TransactionTrackingFilterUI> selectTransformTrackingFilterList(String userId) {
+
+		List<TransactionTrackingFilterUI> transactionTrackingFilterUIs = unifBwkTpService
+				.findUserBizCodesByUserId(userId)
+				.stream()
+				.map(transactionTrackingFilterUIMapper::toVo)
+				.collect(Collectors.toList());
+
+		Set<String> eaibzwkdstcds = transactionTrackingFilterService
+				.findAllByUserId(userId)
+				.stream()
+				.map(t -> t.getId().getEaibzwkdstcd())
+				.collect(Collectors.toSet());
+
+		transactionTrackingFilterUIs.forEach(ui -> {
+			if (eaibzwkdstcds.contains(ui.getEaibzwkdstcd())) {
+				ui.setChk("true");
+			} else {
+				ui.setChk("false");
+			}
+		});
+
+		return transactionTrackingFilterUIs;
+	}
+
+	public void insertTransactionTrackingFilter(String userId, List<TransactionTrackingFilterUI> uis) {
+
+		List<TransactionTrackingFilter> oldFilters = transactionTrackingFilterService.findAllByUserId(userId);
+		List<TransactionTrackingFilter> newFilters = uis
+				.stream()
+				.filter(ui -> "true".equals(ui.getChk()))
+				.map(transactionTrackingFilterUIMapper::toEntity)
+				.collect(Collectors.toList());
+		newFilters.forEach(filter -> filter.getId().setUserid(userId));
+
+		List<TransactionTrackingFilter> deleteFilters = oldFilters
+				.stream()
+				.filter(filter -> !newFilters.contains(filter))
+				.collect(Collectors.toList());
+
+		newFilters.removeIf(oldFilters::contains);
+		transactionTrackingFilterService.saveAll(newFilters);
+		transactionTrackingFilterService.deleteAll(deleteFilters);
+	}
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/online/TransactionOnlineUI.java

@@ -0,0 +1,79 @@
+package com.eactive.eai.rms.onl.transaction.online;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.Data;
+
+@Data
+
+public class TransactionOnlineUI {
+
+	/** 업무 코드 */
+	@JsonProperty("BIZCODE")
+	private String bizCode;
+
+	/** 업무 이름 */
+	@JsonProperty("BIZNAME")
+	private String bizName;
+
+	/** 처리 건수 100 */
+	@JsonProperty("P100")
+	private Integer proc100;
+
+	/** 처리 건수 200 */
+	@JsonProperty("P200")
+	private Integer proc200;
+
+	/** 처리 건수 300 */
+	@JsonProperty("P300")
+	private Integer proc300;
+
+	/** 처리 건수 400 */
+	@JsonProperty("P400")
+	private Integer proc400;
+
+	/** 오류 건수 100 */
+	@JsonProperty("E100")
+	private Integer error100;
+
+	/** 오류 건수 200 */
+	@JsonProperty("E200")
+	private Integer error200;
+
+	/** 오류 건수 300 */
+	@JsonProperty("E300")
+	private Integer error300;
+
+	/** 오류 건수 400 */
+	@JsonProperty("E400")
+	private Integer error400;
+
+	/** 오류 건수 900 */
+	@JsonProperty("E900")
+	private Integer error900;
+
+	/** 오류 건수 9300 */
+	@JsonProperty("E9300")
+	private Integer error9300;
+
+	/** 오류 건수 9400 */
+	@JsonProperty("E9400")
+	private Integer error9400;
+
+	/** 오류 건수 9900 */
+	@JsonProperty("E9900")
+	private Integer error9900;
+
+	/** 평균 EAI 처리 시간 */
+	@JsonProperty("AVGEAI")
+	private String avgEai;
+
+	/** 평균 PSV 처리 시간 */
+	@JsonProperty("AVGPSV")
+	private String avgPsv;
+
+	/** 평균 총 처리 시간 */
+	@JsonProperty("AVGTOTAL")
+	private String avgTotal;
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/online/TransactionTrackingFilterUI.java

@@ -0,0 +1,20 @@
+package com.eactive.eai.rms.onl.transaction.online;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.Data;
+
+@Data
+
+public class TransactionTrackingFilterUI {
+
+	@JsonProperty("EAIBZWKDSTCD")
+	private String eaibzwkdstcd;
+
+	@JsonProperty("BZWKDSTICNAME")
+	private String bzwkdsticname;
+
+	@JsonProperty("CHK")
+	private String chk;
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/online/TransactionTrackingFilterUIMapper.java

@@ -0,0 +1,25 @@
+package com.eactive.eai.rms.onl.transaction.online;
+
+import org.mapstruct.InheritInverseConfiguration;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+
+import com.eactive.eai.data.entity.onl.unifbwk.UnifBwkTp;
+import com.eactive.eai.data.mapper.BaseMapperConfig;
+import com.eactive.eai.data.mapper.GenericMapper;
+import com.eactive.eai.rms.data.entity.onl.transaction.TransactionTrackingFilter;
+
+@Mapper(config = BaseMapperConfig.class)
+public interface TransactionTrackingFilterUIMapper
+		extends GenericMapper<TransactionTrackingFilterUI, TransactionTrackingFilter> {
+
+	@Mapping(source = "id.eaibzwkdstcd", target = "eaibzwkdstcd")
+	TransactionTrackingFilterUI toVo(TransactionTrackingFilter entity);
+
+	@InheritInverseConfiguration
+	TransactionTrackingFilter toEntity(TransactionTrackingFilterUI vo);
+
+	@Mapping(source = "eaibzwkdstcd", target = "eaibzwkdstcd")
+	@Mapping(source = "bzwkdsticname", target = "bzwkdsticname")
+	TransactionTrackingFilterUI toVo(UnifBwkTp unifBwkTp);
+}

src/main/java/com/eactive/eai/rms/onl/transaction/simpleinterface/SimpleInterfaceController.java

@@ -0,0 +1,182 @@
+package com.eactive.eai.rms.onl.transaction.simpleinterface;
+
+import com.eactive.eai.agent.command.Command;
+import com.eactive.eai.agent.command.CommonCommand;
+import com.eactive.eai.rms.common.base.OnlBaseAnnotationController;
+import com.eactive.eai.rms.common.login.SessionManager;
+import com.eactive.eai.rms.common.vo.GridResponse;
+import com.eactive.eai.rms.data.entity.onl.eaimsg.EAIMessageUISearch;
+import com.eactive.eai.rms.onl.common.exception.BizException;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.ui.AdapterGroupUI;
+import com.eactive.eai.rms.onl.transaction.simpleinterface.ui.SimpleInterfaceUI;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+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 javax.servlet.http.HttpServletRequest;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+@Controller
+public class SimpleInterfaceController extends OnlBaseAnnotationController {
+
+    public static final Log logger = LogFactory.getLog(SimpleInterfaceController.class);    
+
+    @Autowired
+    public SimpleInterfaceService service;
+
+	@GetMapping(value = "/onl/transaction/simpleinterface/simpleInterfaceMan.view")
+	public void view() {
+	}
+
+	@GetMapping(value = "/onl/transaction/simpleinterface/simpleInterfaceMan.view", params = "cmd=DETAIL")
+	public String viewDetail() {
+		return "/onl/transaction/simpleinterface/simpleInterfaceManDetail";
+	}
+
+	@PostMapping(value= "/onl/transaction/simpleinterface/simpleInterfaceMan.json", params = "cmd=LIST")
+	public ResponseEntity<GridResponse<SimpleInterfaceUI>> selectList(EAIMessageUISearch eaiMessageUISearch,
+																	  Pageable pageable, String sortname,  String sortorder) {
+		Page<SimpleInterfaceUI> page = service.selectList(eaiMessageUISearch, pageable, sortname, sortorder);
+		return ResponseEntity.ok(new GridResponse<>(page));
+	}
+
+	@PostMapping(value= "/onl/transaction/simpleinterface/simpleInterfaceMan.json",params = "cmd=DETAIL")
+	public ResponseEntity<SimpleInterfaceUI> selectDetail(String eaiSvcName) throws Exception {
+		SimpleInterfaceUI simpleInterfaceUI = service.selectDetail(eaiSvcName);
+		return ResponseEntity.ok(simpleInterfaceUI);
+	}
+	
+	@PostMapping(value= "/onl/transaction/simpleinterface/simpleInterfaceMan.json",params = "cmd=LIST_COMBO")
+	public ResponseEntity<Map<String, Object>> selectCombo(HttpServletRequest request) throws Exception {
+		String userId = SessionManager.getUserId(request);
+		Map<String, Object> map = service.selectCombo(userId);
+		return ResponseEntity.ok(map);
+	}
+	
+	@PostMapping(value= "/onl/transaction/simpleinterface/simpleInterfaceMan.json",params = "cmd=LIST_DETAIL_COMBO")
+	public ResponseEntity<Map<String, Object>> selectDetailCombo(HttpServletRequest request) throws Exception {
+		String userId = SessionManager.getUserId(request);
+		Map<String, Object> map = service.selectDetailCombo(userId);
+		return ResponseEntity.ok(map);
+	}		
+	
+	@PostMapping(value= "/onl/transaction/simpleinterface/simpleInterfaceMan.json",params = "cmd=DETAIL_ADAPTER_URL")
+	public ResponseEntity<Map<String, Object>> getHttpAdapterUrl(String adapterGroupName) throws Exception {
+		Map<String, Object> map = service.getAdapterUrl(adapterGroupName);
+		return ResponseEntity.ok(map);
+	}
+	
+	@PostMapping(value= "/onl/transaction/simpleinterface/simpleInterfaceMan.json",params = "cmd=DETAIL_ADAPTER_GROUP")
+	public ResponseEntity<AdapterGroupUI> selectAdapterGroupDetail(String adapterGroupName) throws Exception {
+		return ResponseEntity.ok(service.selectAdapterGroupDetail(adapterGroupName));
+	}
+
+	@PostMapping(value= "/onl/transaction/simpleinterface/simpleInterfaceMan.json",params = "cmd=INSERT")
+	public ResponseEntity<Map<String, Object>> insert(SimpleInterfaceUI simpleInterfaceUI) throws Exception {
+		try {
+			List<String> standardMessageKeyList = service.insert(simpleInterfaceUI);
+			Map<String, Object> resultMap = null;
+			for (String standardMessageKey : standardMessageKeyList){
+				resultMap = reloadSync(standardMessageKey, simpleInterfaceUI);
+			}
+			return ResponseEntity.ok(resultMap);
+		}catch(Exception e) {
+			logger.error(e);
+			if(e instanceof BizException) {
+				throw e;
+			}
+			throw new BizException("오류가 발생했습니다. 확인바랍니다. error:"+e.getMessage(), e);
+		}
+	}
+	@PostMapping(value= "/onl/transaction/simpleinterface/simpleInterfaceMan.json", params = "cmd=UPDATE")
+	public ResponseEntity<Map<String, Object>> update(SimpleInterfaceUI simpleInterfaceUI) throws Exception {
+		try {
+			List<String> standardMessageKeyList = service.update(simpleInterfaceUI);
+			Map<String, Object> resultMap = null;
+			for (String standardMessageKey : standardMessageKeyList){
+				 resultMap = reloadSync(standardMessageKey, simpleInterfaceUI);	
+			}
+			return ResponseEntity.ok(resultMap);
+		}catch(Exception e) {
+			if(e instanceof BizException) {
+				throw e;
+			}
+			if(e instanceof DuplicateKeyException) {
+				DuplicateKeyException dupEx = (DuplicateKeyException) e;
+				Throwable cause = dupEx.getMostSpecificCause();
+				throw new BizException("중복 오류가 발생했습니다. 확인바랍니다. 오류메시지: "+cause.getMessage());
+			}
+			logger.error(e);
+			throw new BizException("오류가 발생했습니다. 확인바랍니다. 오류메시지: "+e.getMessage());
+		}
+
+	}
+	@PostMapping(value= "/onl/transaction/simpleinterface/simpleInterfaceMan.json",params = "cmd=DELETE")
+	public ResponseEntity<Map<String, Object>> delete(SimpleInterfaceUI simpleInterfaceUI) throws Exception {
+		try {
+			String standardMessageKey = service.delete(simpleInterfaceUI);
+			Map<String, Object> resultMap = deleteSync(standardMessageKey, simpleInterfaceUI);
+			return ResponseEntity.ok(resultMap);
+		}catch(Exception e) {
+			if(e instanceof BizException) {
+				throw e;
+			}
+			throw new BizException("오류가 발생했습니다. 확인바랍니다. error:"+e.getMessage(), e);
+		}
+	}
+
+	public Map<String, Object> reloadSync(String standardMessageKey, SimpleInterfaceUI simpleInterfaceUI) throws Exception {
+		logger.info("- 수정 동기화 시작 [" + simpleInterfaceUI.getEaiSvcName() + "]");
+
+		//HS04,HS05 내부표준전문
+		if (StringUtils.isNotBlank(standardMessageKey)){
+			//URL 변경 시 KEY 자체가 변경되므로 이전 가비지가 남게됨 우선 ALL로 처리
+			Command command = new CommonCommand("com.ext.eai.agent.stdmessage.ReloadSTDMessageCommand", "ALL");
+			agentUtilService.broadcast(command);
+		}
+
+		//HE01 EAI 메시지 공통부
+		CommonCommand cmdHE01 = new CommonCommand("com.eactive.eai.agent.eaimessage.ReloadEAIMessageCommand", simpleInterfaceUI.getEaiSvcName());
+		HashMap<String, Object> resultMap = agentUtilService.broadcast(cmdHE01);
+		logger.info("- 수정 동기화 완료 [" + simpleInterfaceUI.getEaiSvcName() + "]");
+		return resultMap;
+	}
+
+	public Map<String, Object> deleteSync(String standardMessageKey, SimpleInterfaceUI simpleInterfaceUI) throws Exception {
+		logger.info("- 삭제 동기화 시작 [" + simpleInterfaceUI.getEaiSvcName() + "]");
+		//HS04,HS05 내부표준전문
+		callCommandIfExists(standardMessageKey, "com.eactive.eai.agent.stdmessage.RemoveSTDMessageCommand");
+
+		//HE01 EAI 메시지 공통부
+		CommonCommand cmdHE01 = new CommonCommand("com.eactive.eai.agent.eaimessage.RemoveEAIMessageCommand", simpleInterfaceUI.getEaiSvcName());
+		HashMap<String, Object> resultMap = agentUtilService.broadcast(cmdHE01);
+
+		// Transform 및 Layout 삭제
+		callCommandIfExists(simpleInterfaceUI.getRequestTransform(), "com.eactive.eai.agent.transformer.RemoveTransformCommand");
+		callCommandIfExists(simpleInterfaceUI.getResponseTransform(), "com.eactive.eai.agent.transformer.RemoveTransformCommand");
+		callCommandIfExists(simpleInterfaceUI.getInboundRequestLayout(), "com.eactive.eai.agent.transformer.RemoveLayoutCommand");
+		callCommandIfExists(simpleInterfaceUI.getOutboundRequestLayout(), "com.eactive.eai.agent.transformer.RemoveLayoutCommand");
+		callCommandIfExists(simpleInterfaceUI.getInboundResponseLayout(), "com.eactive.eai.agent.transformer.RemoveLayoutCommand");
+		callCommandIfExists(simpleInterfaceUI.getOutboundResponseLayout(), "com.eactive.eai.agent.transformer.RemoveLayoutCommand");
+
+		logger.info("- 삭제 동기화 완료 [" + simpleInterfaceUI.getEaiSvcName() + "]");
+		return resultMap;
+	}
+
+	public void callCommandIfExists(String value, String commandName) throws Exception {
+		if (StringUtils.isNotBlank(value)) {
+			agentUtilService.broadcast(new CommonCommand(commandName, value));
+		}
+	}
+}

src/main/java/com/eactive/eai/rms/onl/transaction/simpleinterface/SimpleInterfaceDao.java

@@ -0,0 +1,26 @@
+package com.eactive.eai.rms.onl.transaction.simpleinterface;
+
+import com.eactive.eai.rms.common.base.SqlMapClientTemplateDao;
+import com.eactive.eai.transformer.util.Logger;
+import org.springframework.stereotype.Repository;
+
+import java.util.HashMap;
+import java.util.List;
+
+@Repository("simpleInterfaceDao")
+public class SimpleInterfaceDao extends SqlMapClientTemplateDao {
+
+	private static final Logger logger = Logger.getLogger(SimpleInterfaceDao.class);
+
+	public int selectListCount(HashMap<?, ?> paramMap) throws Exception {
+		return (Integer) template.queryForObject("Interface.selectListCount", paramMap);
+	}
+
+	public List<?> selectList(HashMap<?, ?> paramMap) throws Exception {
+		return template.queryForList("Interface.selectList", paramMap);
+	}
+
+	public HashMap selectDetail(HashMap paramMap) throws Exception {
+		return (HashMap) template.queryForObject("Interface.selectDetail", paramMap);
+	}
+}

src/main/java/com/eactive/eai/rms/onl/transaction/simpleinterface/SimpleInterfaceService.java

@@ -0,0 +1,572 @@
+package com.eactive.eai.rms.onl.transaction.simpleinterface;
+
+import com.eactive.eai.adapter.Keys;
+import com.eactive.eai.data.entity.onl.message.EAIMessageEntity;
+import com.eactive.eai.data.entity.onl.message.QEAIMessageEntity;
+import com.eactive.eai.data.entity.onl.message.ServiceMessageEntity;
+import com.eactive.eai.data.entity.onl.messagekey.MessageKey;
+import com.eactive.eai.data.entity.onl.stdmessage.StandardMessageInfo;
+import com.eactive.eai.rms.common.base.OnlBaseService;
+import com.eactive.eai.rms.common.combo.ComboService;
+import com.eactive.eai.rms.common.combo.ComboVo;
+import com.eactive.eai.rms.data.entity.onl.eaimsg.EAIMessageService;
+import com.eactive.eai.rms.data.entity.onl.eaimsg.EAIMessageUISearch;
+import com.eactive.eai.rms.data.entity.onl.eaimsg.ServiceMessageService;
+import com.eactive.eai.rms.data.entity.onl.layout.LayoutService;
+import com.eactive.eai.rms.data.entity.onl.messagekey.MessageKeyService;
+import com.eactive.eai.rms.onl.common.exception.BizException;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.AdapterManService;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.ui.AdapterGroupUI;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.ui.AdapterPropUI;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.ui.AdapterUI;
+import com.eactive.eai.rms.onl.transaction.apim.BizCodeQueryServiceForApi;
+import com.eactive.eai.rms.onl.transaction.apim.StandardMessageInfoQueryServiceForApi;
+import com.eactive.eai.rms.onl.transaction.apim.mapping.BizCodeMapper;
+import com.eactive.eai.rms.onl.transaction.apim.vo.BizCodeVo;
+import com.eactive.eai.rms.onl.transaction.apim.vo.RestOption;
+import com.eactive.eai.rms.onl.transaction.simpleinterface.mapping.SimpleInterfaceUIMapper;
+import com.eactive.eai.rms.onl.transaction.simpleinterface.ui.SimpleInterfaceUI;
+import com.eactive.eai.transformer.transform.loader.TransformLoader;
+import com.eactive.eai.transformer.util.Logger;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.querydsl.core.Tuple;
+import org.apache.commons.lang.StringUtils;
+import org.jetbrains.annotations.NotNull;
+import org.json.simple.JSONObject;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+@Transactional
+@Repository
+public class SimpleInterfaceService extends OnlBaseService {
+
+	private static final Logger logger = Logger.getLogger(SimpleInterfaceService.class);
+
+	public static final String STEMSG_SERVICE_URL_DELIMITER = "|";
+
+	public static final String STEMSG_METHOD_DELIMITER = ":";
+
+	public static final String STEMSG_SERVICE_HEADER_DELIMITER = "^";
+
+	public static final String STEMSG_HEADER_SEPARATOR = ";";
+
+	@Autowired
+	MessageKeyService messageKeyService;
+
+	@Autowired
+	private SimpleInterfaceUIMapper simpleInterfaceUIMapper;
+
+	@Autowired
+	private EAIMessageService eaiMessageQueryService;
+
+	@Autowired
+	private ServiceMessageService serviceMessageQueryService;
+
+	@Autowired
+	private StandardMessageInfoQueryServiceForApi standardMessageInfoQueryService;
+
+	@Autowired
+	private AdapterManService adapterService;
+
+	@Autowired
+	private LayoutService layoutService;
+
+	@Autowired
+	private TransformLoader transformLoader;
+
+	@Autowired
+	private ComboService comboService;
+
+	@Autowired
+	private BizCodeMapper bizCodeMapper;
+
+	@Autowired
+	private BizCodeQueryServiceForApi bizCodeQueryServiceForApi;
+
+	@Transactional
+	public Page<SimpleInterfaceUI> selectList(EAIMessageUISearch eaiMessageUISearch, Pageable pageable, String sortname,  String sortorder) {
+		Page<Tuple> tuples = eaiMessageQueryService.selectList(eaiMessageUISearch, pageable, sortname, sortorder);
+
+		return tuples.map(tuple -> {
+			EAIMessageEntity eaiMessageEntity = tuple.get(QEAIMessageEntity.eAIMessageEntity);
+
+			SimpleInterfaceUI simpleInterfaceUI;
+			if(eaiMessageEntity.getServiceMessages() != null && eaiMessageEntity.getServiceMessages().size() > 0){
+				simpleInterfaceUI = simpleInterfaceUIMapper.toVo(eaiMessageEntity, eaiMessageEntity.getServiceMessages().get(0));
+			}else{
+				simpleInterfaceUI = simpleInterfaceUIMapper.toVo(eaiMessageEntity);
+			}
+
+			return simpleInterfaceUI;
+		});
+	}
+
+	public HashMap selectCombo(String userId) throws Exception {
+
+		List<BizCodeVo> voList = bizCodeMapper.toVoList(bizCodeQueryServiceForApi.selectUserBizCodes(userId));
+		// 전체 목록수 얻기
+		HashMap map = new HashMap();
+		map.put("bizList", voList);
+
+		return map;
+	}
+
+	@Transactional
+	public SimpleInterfaceUI selectDetail(String eaiSvcName) throws Exception {
+		EAIMessageEntity eaiMessageEntity = eaiMessageQueryService.findById(eaiSvcName).get();
+		SimpleInterfaceUI simpleInterfaceUI;
+		ServiceMessageEntity serviceMessageEntity = null;
+		List<ServiceMessageEntity> serviceMessageEntityList = eaiMessageEntity.getServiceMessages();
+		if(serviceMessageEntityList != null && serviceMessageEntityList.size() > 0){
+			serviceMessageEntity = serviceMessageEntityList.get(0);
+			simpleInterfaceUI = simpleInterfaceUIMapper.toVo(eaiMessageEntity, serviceMessageEntity);
+		}else{
+			simpleInterfaceUI = simpleInterfaceUIMapper.toVo(eaiMessageEntity);
+		}
+
+			// 레이아웃 이름 설정
+		setLayoutNames(simpleInterfaceUI, eaiMessageEntity.getEaibzwkdstcd(), eaiSvcName);
+		String transformYn = "N";
+
+		if(serviceMessageEntity != null){
+			String requestTranform = serviceMessageEntity.getChngmsgidname();
+			simpleInterfaceUI.setRequestTransform(requestTranform);
+			String responseTranform = serviceMessageEntity.getBascrspnschngmsgidname();
+			simpleInterfaceUI.setResponseTransform(responseTranform);
+
+			if("1".equals(serviceMessageEntity.getChngeonot()) || "1".equals(serviceMessageEntity.getBascrspnschngeonot()) ){// 요청이나 응답 변환 여부
+				transformYn = "Y";
+			}
+
+			String restOptionStr = serviceMessageEntity.getRestoption();
+
+			if(StringUtils.isNotBlank(restOptionStr)) {
+				ObjectMapper mapper = new ObjectMapper();
+				RestOption restOption = mapper.readValue(restOptionStr, RestOption.class);
+
+				simpleInterfaceUI.setOutboundHttpMethod(restOption.getMethod());
+				simpleInterfaceUI.setOutboundRestPath(restOption.getExtraPath());
+			}
+		}
+
+		if("asyncSync".equals(simpleInterfaceUI.getSyncAsyncType()) && serviceMessageEntityList.size() > 1){
+			ServiceMessageEntity extraServiceMessageEntity = serviceMessageEntityList.get(1);
+			simpleInterfaceUI.setFromResponseAdapter(extraServiceMessageEntity.getPsvsysadptrbzwkgroupname());
+			String restOptionStr = extraServiceMessageEntity.getRestoption();
+
+			if(StringUtils.isNotBlank(restOptionStr)) {
+				ObjectMapper mapper = new ObjectMapper();
+				RestOption restOption = mapper.readValue(restOptionStr, RestOption.class);
+
+				simpleInterfaceUI.setInboundResponseHttpMethod(restOption.getMethod());
+				simpleInterfaceUI.setInboundResponseRestPath(restOption.getExtraPath());
+			}
+		}
+
+		simpleInterfaceUI.setTransformYn(transformYn);
+
+		Optional<StandardMessageInfo> optional = standardMessageInfoQueryService.findByEaiSvcName(eaiSvcName);
+		if(optional.isPresent()){
+			StandardMessageInfo standardMessageInfo = optional.get();
+			String stdKey = standardMessageInfo.getBzwksvckeyname();
+			String inboundRestPath = StringUtils.substringAfter(stdKey, STEMSG_SERVICE_URL_DELIMITER);
+			simpleInterfaceUI.setInboundRestPath(inboundRestPath);
+
+			String inboundHttpMethod;
+			if(StringUtils.contains(stdKey, STEMSG_SERVICE_HEADER_DELIMITER)){
+				inboundHttpMethod = StringUtils.substringBetween(stdKey, STEMSG_METHOD_DELIMITER, STEMSG_SERVICE_HEADER_DELIMITER);
+				String headerRoutingValueString = StringUtils.substringAfter(stdKey, STEMSG_SERVICE_HEADER_DELIMITER);
+
+				List<String> headerValues = new ArrayList<>();
+				String[] values = headerRoutingValueString.split(SimpleInterfaceService.STEMSG_HEADER_SEPARATOR);
+
+				for (String value : values) {
+					headerValues.add(value);
+				}
+				simpleInterfaceUI.setHeaderValues(headerValues);
+			}else {
+				inboundHttpMethod = StringUtils.substringBetween(stdKey, STEMSG_METHOD_DELIMITER, STEMSG_SERVICE_URL_DELIMITER);
+			}
+
+			simpleInterfaceUI.setInboundHttpMethod(inboundHttpMethod == null ?  "" :inboundHttpMethod.toLowerCase());
+		}
+
+		if("syncAsync".equals(simpleInterfaceUI.getSyncAsyncType()) && StringUtils.isNotBlank(eaiSvcName) && eaiSvcName.charAt(eaiSvcName.length() - 2) == 'S') {
+			String recvEaiSvcName = simpleInterfaceUIMapper.changeEaiSvcNameToRecv(eaiSvcName);
+			EAIMessageEntity recvEaiMessageEntity = eaiMessageQueryService.getById(recvEaiSvcName);
+			simpleInterfaceUI.setToResponseAdapter(recvEaiMessageEntity.getGstatsysadptrbzwkgroupname());
+
+			optional = standardMessageInfoQueryService.findByEaiSvcName(recvEaiSvcName);
+			if(optional.isPresent()){
+				StandardMessageInfo standardMessageInfo = optional.get();
+				String stdKey = standardMessageInfo.getBzwksvckeyname();
+				String restPath = StringUtils.substringAfter(stdKey, STEMSG_SERVICE_URL_DELIMITER);
+				simpleInterfaceUI.setOutboundResponseRestPath(restPath);
+				String httpMethod = StringUtils.substringBetween(stdKey, STEMSG_METHOD_DELIMITER, STEMSG_SERVICE_URL_DELIMITER);
+				simpleInterfaceUI.setOutboundResponseHttpMethod(httpMethod == null ?  "" :httpMethod.toLowerCase());
+			}
+		}
+
+		return simpleInterfaceUI;
+	}
+
+	private void setLayoutNames(SimpleInterfaceUI simpleInterfaceUI, String bzcd, String eaiSvcName) {
+		String[] types = {"SRCS", "TGTS", "TGTR", "SRCR"};
+		for (String type : types) {
+			String layoutName = bzcd + "_" + eaiSvcName + "_" + type;
+			boolean hasLayout = layoutService.findById(layoutName).isPresent();
+			if (hasLayout) {
+				// 각 타입에 대한 서로 다른 속성을 설정한다고 가정
+				// 실제 setter에 맞게 이 부분을 업데이트하세요
+				switch (type) {
+					case "SRCS":
+						simpleInterfaceUI.setInboundRequestLayout(layoutName);
+						break;
+					case "TGTS":
+						simpleInterfaceUI.setOutboundRequestLayout(layoutName);
+						break;
+					case "TGTR":
+						simpleInterfaceUI.setOutboundResponseLayout(layoutName);
+						break;
+					case "SRCR":
+						simpleInterfaceUI.setInboundResponseLayout(layoutName);
+						break;
+				}
+			}
+		}
+	}
+
+	@Transactional
+	public HashMap selectDetailCombo(String userId) throws Exception {
+		HashMap paramMap = new HashMap();
+		paramMap.put("userId", userId);
+
+		//업무구분
+		List<BizCodeVo> listBiz = bizCodeMapper.toVoList(bizCodeQueryServiceForApi.selectUserBizCodes(userId));
+		//당타발구분
+		List<ComboVo> listIo = comboService.getFromCode("IO_TYPE");
+		//전문요청구분
+		List listReqRes = comboService.getFromCode("REQRES_TYPE");
+		//송수신방법
+		List listSyncAsync = comboService.getFromCode("SYNCASYNC_TYPE");
+		//거래흐름(INBOUND);
+		List<AdapterGroupUI> listFrom = adapterService.selectListComboForAdptrIoDstcd("IN");
+		//거래흐름(OUTBOUND);
+		List<AdapterGroupUI> listTo = adapterService.selectListComboForAdptrIoDstcd("OU");
+
+		Map<String, List<String>> fromAdapterMessageKeyMap = new HashMap<>();
+
+		listFrom.forEach(adapterGroup -> {
+			String adapterGroupName = adapterGroup.getAdptrbzwkgroupname();
+			List<String> messageKeyGroup = getFirstBzwkfldnameListsByGroup(adapterGroupName);
+			if(messageKeyGroup != null && messageKeyGroup.size() > 0){
+				fromAdapterMessageKeyMap.put(adapterGroupName, messageKeyGroup);
+			}
+		});
+
+		HashMap map = new HashMap();
+
+		map.put("bizList", listBiz);
+		map.put("ioList", listIo);
+		map.put("reqResList", listReqRes);
+		map.put("syncAsyncList", listSyncAsync);
+		map.put("fromList", listFrom);
+		map.put("fromAdapterMessageKeyMap", fromAdapterMessageKeyMap);
+		map.put("toList", listTo);
+
+		return map;
+	}
+
+	public HashMap getAdapterUrl(String adapterGroupName) throws Exception {
+		AdapterGroupUI adapterGroup = adapterService.selectDetail(adapterGroupName);
+		String adptriodstcd = adapterGroup.getAdptriodstcd();
+		StringBuilder urlPathBuilder = new StringBuilder();
+
+		for(AdapterUI adapter : adapterGroup.getAdapters()) {
+			String url = null;
+			for (AdapterPropUI prop : adapter.getAdapterPropGroup().getAdapterProps()) {
+				String propName = "I".equals(adptriodstcd) ? "API_PATH" : "URL";
+				if (propName.equals(prop.getPrptyname())) {
+					url = prop.getPrpty2val();
+					break;
+				}
+			}
+
+			if (url != null) {
+				if (urlPathBuilder.length() > 100) {
+					urlPathBuilder.append("...");
+					break;
+				}
+				if (urlPathBuilder.length() > 0) {
+					urlPathBuilder.append(", "); // 기존에 문자열이 있다면 쉼표 추가
+				}
+				urlPathBuilder.append(url); // 새로운 URL 부분 추가
+			}
+		}
+		String urlPath = urlPathBuilder.toString(); // 최종 문자열 얻기
+
+		HashMap<String, String> resultMap = new HashMap<>();
+		resultMap.put("urlPath", urlPath);
+		return resultMap;
+	}
+
+	@Transactional
+	public AdapterGroupUI selectAdapterGroupDetail(String adapterGroupName) throws Exception {
+		return adapterService.selectDetail(adapterGroupName);
+	}
+
+	public List<String> update(SimpleInterfaceUI simpleInterfaceUI) throws Exception {
+		String eaiSvcName = simpleInterfaceUI.getEaiSvcName();
+
+		EAIMessageEntity eaiMessageEntity = eaiMessageQueryService.getById(eaiSvcName);
+		simpleInterfaceUIMapper.updateEaiMessageEntity(simpleInterfaceUI, eaiMessageEntity);
+		eaiMessageQueryService.save(eaiMessageEntity);
+
+		List<ServiceMessageEntity> serviceMessageEntityList = eaiMessageEntity.getServiceMessages();
+
+		if(eaiMessageEntity.getServiceMessages().size() > 0){
+			ServiceMessageEntity serviceMessageEntity = eaiMessageEntity.getServiceMessages().get(0);
+			simpleInterfaceUIMapper.updateServiceMessageEntity(simpleInterfaceUI, serviceMessageEntity);
+		}else{
+			ServiceMessageEntity serviceMessageEntity = simpleInterfaceUIMapper.toServiceMessageEntity(simpleInterfaceUI);
+			serviceMessageEntityList.add(serviceMessageEntity);
+		}
+
+		setServiceMessageRoutingInfo(simpleInterfaceUI, eaiMessageEntity, serviceMessageEntityList);
+
+		for(ServiceMessageEntity serviceMessageEntity : serviceMessageEntityList){
+			serviceMessageQueryService.save(serviceMessageEntity);
+		}
+
+		List<String> standardMessageKeyList = new ArrayList<>();
+		standardMessageKeyList.add(mergeStdMessage(simpleInterfaceUI, false));
+
+		if("syncAsync".equals(simpleInterfaceUI.getSyncAsyncType()) && StringUtils.isNotBlank(eaiSvcName) && eaiSvcName.charAt(eaiSvcName.length() - 2) == 'S'){
+			String recvEaiSvcName = simpleInterfaceUIMapper.changeEaiSvcNameToRecv(eaiSvcName);
+			EAIMessageEntity recvEaiMessageEntity = eaiMessageQueryService.getById(recvEaiSvcName);
+			recvEaiMessageEntity.setGstatsysadptrbzwkgroupname(simpleInterfaceUI.getToResponseAdapter());
+
+			eaiMessageQueryService.save(recvEaiMessageEntity);
+
+			standardMessageKeyList.add(mergeStdMessage(simpleInterfaceUI, true));
+		}
+
+		return standardMessageKeyList;
+	}
+
+	private void setRouterAndRestOption(ServiceMessageEntity serviceMessageEntity, String adapterGroupName, String method, String restPath) throws Exception {
+		String restOption = "";
+		String outbndRoutName = getRouterByAdapter(adapterGroupName);
+		boolean isRestOut = "RESTOUT".equals(outbndRoutName);
+
+		serviceMessageEntity.setOutbndroutname(outbndRoutName);
+
+		if(isRestOut) {
+			restOption = getRestOption(method, restPath);
+		}
+		serviceMessageEntity.setRestoption(restOption);
+	}
+
+	private void setServiceMessageRoutingInfo(SimpleInterfaceUI vo, EAIMessageEntity eaiMessageEntity, List<ServiceMessageEntity> serviceMessageEntityList) throws Exception{
+		ServiceMessageEntity serviceMessageEntity = serviceMessageEntityList.get(0);
+		setRouterAndRestOption(serviceMessageEntity, vo.getToAdapter(), vo.getOutboundHttpMethod(), vo.getOutboundRestPath());
+
+		if("asyncSync".equals(vo.getSyncAsyncType())){
+			ServiceMessageEntity asyncResponseServiceMessageEntity;
+			if(eaiMessageEntity.getServiceMessages().size() > 1){
+				asyncResponseServiceMessageEntity = eaiMessageEntity.getServiceMessages().get(1);
+				simpleInterfaceUIMapper.updateAsyncSyncResServiceMessageEntity(vo, serviceMessageEntity);
+			}else{
+				asyncResponseServiceMessageEntity = simpleInterfaceUIMapper.toAsyncSyncResServiceMessageEntity(vo);
+				serviceMessageEntityList.add(asyncResponseServiceMessageEntity);
+				asyncResponseServiceMessageEntity.setEaimessage(eaiMessageEntity);
+			}
+			String fromResponseRoutName = getRouterByAdapter(vo.getFromResponseAdapter());
+			asyncResponseServiceMessageEntity.setOutbndroutname(fromResponseRoutName);
+			setRouterAndRestOption(asyncResponseServiceMessageEntity, vo.getFromResponseAdapter(), vo.getInboundResponseHttpMethod(), vo.getInboundResponseRestPath());
+		}
+	}
+
+	private static String getRestOption(String outboundHttpMethod, String outboundRestPath) {
+		String restOption;
+		JSONObject jsonObject = new JSONObject();
+		jsonObject.put("method", outboundHttpMethod);
+		jsonObject.put("extraPath", outboundRestPath);
+
+		String pathType = outboundRestPath.matches(".*\\{[a-zA-Z]+\\}.*") ? "variableUrlRequest" : "simpleRequest";
+		jsonObject.put("type", pathType);
+		restOption = jsonObject.toString();
+		return restOption;
+	}
+
+	@NotNull
+	private String getRouterByAdapter(String adapterGroupName) throws Exception {
+		AdapterGroupUI outboundAdapter = adapterService.selectDetail(adapterGroupName);
+		if(outboundAdapter == null){
+			throw new Exception("아웃바운드 어댑터 오류입니다.");
+		}
+
+		boolean isRestOut = false;
+		HashMap<String, Object> paramMap = new HashMap<>();
+		String outbndRoutName;
+		switch ((String) outboundAdapter.getAdptrcd()){
+			case "HTT": outbndRoutName = "HTTPOUT"; break;
+			case "NET": outbndRoutName = "SOCKETOUT"; break;
+			default:
+				outbndRoutName = "RESTOUT";
+			break;
+		}
+		return outbndRoutName;
+	}
+
+
+	public List<String> insert(SimpleInterfaceUI simpleInterfaceUI) throws Exception {
+		String eaiSvcName = simpleInterfaceUI.getEaiSvcName();
+
+		Optional<EAIMessageEntity> optional = eaiMessageQueryService.findById(eaiSvcName);
+		if (optional.isPresent()) {
+			String bzwkDstcd = optional.get().getEaibzwkdstcd();
+			throw new BizException("업무명[" + bzwkDstcd + "]로 이미 등록된 인터페이스입니다.\n조회가 되지 않을 시 담당자에게 문의바랍니다.");
+		}
+
+		EAIMessageEntity eaiMessageEntity = simpleInterfaceUIMapper.toEaiMessageEntity(simpleInterfaceUI);
+		ServiceMessageEntity serviceMessageEntity = simpleInterfaceUIMapper.toServiceMessageEntity(simpleInterfaceUI);
+		serviceMessageEntity.setEaimessage(eaiMessageEntity);
+		List<ServiceMessageEntity> serviceMessageEntityList = new ArrayList<>();
+		serviceMessageEntityList.add(serviceMessageEntity);
+		eaiMessageEntity.setServiceMessages(serviceMessageEntityList);
+
+		setServiceMessageRoutingInfo(simpleInterfaceUI, eaiMessageEntity, serviceMessageEntityList);
+
+		eaiMessageQueryService.save(eaiMessageEntity);
+
+		List<String> standardMessageKeyList = new ArrayList<>();
+		standardMessageKeyList.add(mergeStdMessage(simpleInterfaceUI, false));
+
+		if("syncAsync".equals(simpleInterfaceUI.getSyncAsyncType()) && StringUtils.isNotBlank(eaiSvcName) && eaiSvcName.charAt(eaiSvcName.length() - 2) == 'S'){
+			EAIMessageEntity recvEaiMessageEntity = simpleInterfaceUIMapper.toSyncAsyncResEaiMessageEntity(simpleInterfaceUI);
+			ServiceMessageEntity recvServiceMessageEntity = simpleInterfaceUIMapper.toSyncAsyncResServiceMessageEntity(simpleInterfaceUI);
+			recvServiceMessageEntity.setEaimessage(recvEaiMessageEntity);
+			List<ServiceMessageEntity> recvServiceMessageEntityList = new ArrayList<>();
+			recvServiceMessageEntityList.add(recvServiceMessageEntity);
+			recvEaiMessageEntity.setServiceMessages(recvServiceMessageEntityList);
+
+			setRouterAndRestOption(recvServiceMessageEntity, simpleInterfaceUI.getToResponseAdapter(), simpleInterfaceUI.getOutboundResponseHttpMethod(), simpleInterfaceUI.getOutboundResponseRestPath());
+
+			eaiMessageQueryService.save(recvEaiMessageEntity);
+
+			standardMessageKeyList.add(mergeStdMessage(simpleInterfaceUI, true));
+		}
+
+		return standardMessageKeyList;
+	}
+
+
+	public String mergeStdMessage(SimpleInterfaceUI vo, boolean isSyncAsyncResponse) throws Exception {
+		logger.info ("내부 표준 전문 INSERT");
+		// 내부 표준 전문 INSERT
+		// 비표준에서 표준으로 가는 경우 표준으로 전환하기 위한 정보 이므로 내부로 갈 때만 처리
+		String inboundAdapterGroupName;
+		String eaiServiceName;
+		StandardMessageInfo standardMessageInfo;
+		if(isSyncAsyncResponse){
+			inboundAdapterGroupName = vo.getToResponseAdapter();
+			eaiServiceName = simpleInterfaceUIMapper.changeEaiSvcNameToRecv(vo.getEaiSvcName());
+			standardMessageInfo = simpleInterfaceUIMapper.toSyncAsyncResStandardMessageInfo(vo);
+		}else {
+			inboundAdapterGroupName = vo.getFromAdapter();
+			eaiServiceName = vo.getEaiSvcName();
+			standardMessageInfo = simpleInterfaceUIMapper.toStandardMessageInfo(vo);
+		}
+
+		AdapterGroupUI adapterGroup = adapterService.selectDetail(inboundAdapterGroupName);
+
+		if(Keys.IF_STANDARD.equals(adapterGroup.getAdptrmsgptrncd())) {
+			throw new RuntimeException("인바운드 어댑터가 표준전문으로 설정되어있습니다.");
+		}
+		if(!"RST".equals(adapterGroup.getAdptrcd())) {
+			throw new RuntimeException("인바운드 어댑터가 타입이 REST가 아닙니다. 타입을 확인하세요");
+		}
+
+		standardMessageInfoQueryService.deleteByEaiSvcName(eaiServiceName);
+		standardMessageInfoQueryService.save(standardMessageInfo);
+
+		return standardMessageInfo.getBzwksvckeyname();
+	}
+
+
+	public String delete(SimpleInterfaceUI simpleInterfaceUI) throws Exception {
+		StandardMessageInfo standardMessageInfo = standardMessageInfoQueryService.findByEaiSvcName(simpleInterfaceUI.getEaiSvcName()).get();
+
+		String eaiSvcName = simpleInterfaceUI.getEaiSvcName();
+		if("syncAsync".equals(simpleInterfaceUI.getSyncAsyncType()) && StringUtils.isNotBlank(eaiSvcName) && eaiSvcName.charAt(eaiSvcName.length() - 2) == 'S'){
+			StringBuilder sb = new StringBuilder(eaiSvcName);
+			// 끝에서 두 번째 문자를 'S'로 변경
+			sb.setCharAt(eaiSvcName.length() - 2, 'R');
+			String recvEaiSvcName = sb.toString();
+			deleteResourcesWithEaiSvcName(recvEaiSvcName);
+		}
+		deleteResourcesWithEaiSvcName(eaiSvcName);
+		deleteIfNotBlank(simpleInterfaceUI.getRequestTransform(), transformLoader::deleteById);
+		deleteIfNotBlank(simpleInterfaceUI.getResponseTransform(), transformLoader::deleteById);
+		deleteIfNotBlank(simpleInterfaceUI.getInboundRequestLayout(), layoutService::deleteById);
+		deleteIfNotBlank(simpleInterfaceUI.getOutboundRequestLayout(), layoutService::deleteById);
+		deleteIfNotBlank(simpleInterfaceUI.getInboundResponseLayout(), layoutService::deleteById);
+		deleteIfNotBlank(simpleInterfaceUI.getOutboundResponseLayout(), layoutService::deleteById);
+
+		return standardMessageInfo.getBzwksvckeyname();
+	}
+
+	private void deleteResourcesWithEaiSvcName(String eaiSvcName) throws Exception {
+		if (StringUtils.isNotBlank(eaiSvcName)) {
+			eaiMessageQueryService.deleteById(eaiSvcName);
+			standardMessageInfoQueryService.deleteByEaiSvcName(eaiSvcName);
+		}
+	}
+
+
+	private void deleteIfNotBlank(String value, Consumer<String> deleteFunction) throws Exception {
+		if (StringUtils.isNotBlank(value)) {
+			deleteFunction.accept(value);
+		}
+	}
+
+	protected List<String> getFirstBzwkfldnameListsByGroup(String adapterGroupName){
+		List<List<String>> messageKeyGroupList = getBzwkfldnameListsByGroup(adapterGroupName);
+		if(messageKeyGroupList == null || messageKeyGroupList.size() == 0){
+			return null;
+		}
+
+		return messageKeyGroupList.get(0);
+	}
+
+	protected List<List<String>> getBzwkfldnameListsByGroup(String adapterGroupName){
+		List<MessageKey> messageKeys = messageKeyService.findByAdptrBzwkGroupNameAndIoDstcd(adapterGroupName, "I", true);
+
+		// groupinorno 별로 MessageKey 객체들을 그룹화합니다.
+		Map<Integer, List<MessageKey>> groupedByGroupNo = messageKeys.stream()
+				.collect(Collectors.groupingBy(key -> key.getId().getGroupinorno()));
+
+		List<List<String>> headerNamesLists = new ArrayList<>();
+		// 각 그룹별로 bzwkfldname 값을 추출하여 리스트로 만듭니다.
+		for (Map.Entry<Integer, List<MessageKey>> entry : groupedByGroupNo.entrySet()) {
+			List<MessageKey> groupedKeys = entry.getValue();
+			List<String> headerNames = new ArrayList<>();
+
+			for (MessageKey key : groupedKeys) {
+				headerNames.add(key.getBzwkfldname());
+			}
+
+			headerNamesLists.add(headerNames);
+		}
+
+		return headerNamesLists;
+	}
+}

src/main/java/com/eactive/eai/rms/onl/transaction/simpleinterface/mapping/SimpleInterfaceUIMapper.java

@@ -0,0 +1,218 @@
+package com.eactive.eai.rms.onl.transaction.simpleinterface.mapping;
+
+import com.eactive.eai.data.entity.onl.message.EAIMessageEntity;
+import com.eactive.eai.data.entity.onl.message.ServiceMessageEntity;
+import com.eactive.eai.data.entity.onl.stdmessage.StandardMessageInfo;
+import com.eactive.eai.data.mapper.BaseMapperConfig;
+import com.eactive.eai.rms.onl.transaction.apim.ApiInterfaceService;
+import com.eactive.eai.rms.onl.transaction.simpleinterface.ui.SimpleInterfaceUI;
+import org.apache.commons.lang.StringUtils;
+import org.mapstruct.*;
+
+import java.util.List;
+
+@Mapper(config = BaseMapperConfig.class)
+public interface SimpleInterfaceUIMapper {
+
+    @Mapping(source = "eaiSvcName", target = "eaisvcname")
+    @Mapping(source = "eaiBzwkDstcd", target = "eaibzwkdstcd")
+    @Mapping(source = "sevrLogLvelNo", target = "sevrloglvelno", defaultValue = "3")
+    @Mapping(source = "sevrLogLvelNo", target = "svcloglvelno", defaultValue = "3")
+    @Mapping(source = "eaiSvcDesc", target = "eaisvcdesc")
+    @Mapping(source = "fromAdapter", target = "gstatsysadptrbzwkgroupname")
+    @Mapping(target = "svchmseonot", constant = "0")
+    @Mapping(target = "svcmotivusedstcd", constant = "SYNC")
+    @Mapping(target = "svcprcesdsticname", constant = "SINGLE")
+    @Mapping(target = "flowctrlroutname", constant = "BASEFC")
+    @Mapping(target = "intgradsticname", constant = "ONLINE")
+    @Mapping(target = "svcbfclmnlogyn", constant = "0")
+    @Mapping(target = "useyn", constant = "1")
+    EAIMessageEntity toEaiMessageEntity(SimpleInterfaceUI vo);
+
+    @InheritInverseConfiguration(name = "toEaiMessageEntity")
+    SimpleInterfaceUI toVo(EAIMessageEntity eaiMessageEntity);
+
+    @Mapping(target = "eaiSvcName", source = "eaiMessageEntity.eaisvcname")
+    @Mapping(target = "eaiBzwkDstcd", source = "eaiMessageEntity.eaibzwkdstcd")
+    @Mapping(target = "eaiSvcDesc", source = "eaiMessageEntity.eaisvcdesc")
+    @Mapping(target = "fromAdapter", source = "eaiMessageEntity.gstatsysadptrbzwkgroupname")
+    @Mapping(target = "author", source = "eaiMessageEntity.author")
+    @Mapping(target = "toAdapter", source = "serviceMessageEntity.psvsysadptrbzwkgroupname")
+    SimpleInterfaceUI toVo(EAIMessageEntity eaiMessageEntity, ServiceMessageEntity serviceMessageEntity);
+
+
+    @AfterMapping
+    default void afterVoMapping(@MappingTarget SimpleInterfaceUI apiInterfaceUI,
+                              EAIMessageEntity eaiMessageEntity,
+                              ServiceMessageEntity serviceMessageEntity) {
+        String simYn = "T".equals(eaiMessageEntity.getTrantype()) ? "Y" : "N";
+        apiInterfaceUI.setSimYn(simYn);
+
+        String inboundSyncAsyncType = eaiMessageEntity.getSvcmotivusedstcd();
+        String outboundSyncAsyncType = serviceMessageEntity.getPsvintfacdsticname();
+        String syncAsyncType = "sync";
+        if(inboundSyncAsyncType.equals("ASYN") && outboundSyncAsyncType.equals("ASYN")){
+            syncAsyncType = "async";
+        }else if(inboundSyncAsyncType.equals("SYNC") && outboundSyncAsyncType.equals("ASYN")){
+            syncAsyncType = "syncAsync";
+        }else if(inboundSyncAsyncType.equals("ASYN") && outboundSyncAsyncType.equals("SYNC")){
+            syncAsyncType = "asyncSync";
+        }
+        apiInterfaceUI.setSyncAsyncType(syncAsyncType);
+    }
+
+    @AfterMapping
+    default void setEaiMessageEntity(SimpleInterfaceUI vo, @MappingTarget EAIMessageEntity entity) {
+        String tranType = "Y".equals(vo.getSimYn()) ? "T" : "R";
+        entity.setTrantype(tranType);
+        switch(vo.getSyncAsyncType()){
+            case "async":
+            case "asyncSync":
+                entity.setSvcmotivusedstcd("ASYN");
+                break;
+        }
+    }
+
+    @InheritConfiguration(name="toEaiMessageEntity")
+    void updateEaiMessageEntity(SimpleInterfaceUI vo, @MappingTarget EAIMessageEntity entity);
+
+    @AfterMapping
+    default void setServiceMessageEntity(SimpleInterfaceUI vo, @MappingTarget ServiceMessageEntity entity) {
+        if("asyncSync".equals(vo.getSyncAsyncType())  && 2 == entity.getId().getSvcprcssno()
+        || "syncAsync".equals(vo.getSyncAsyncType())  && entity.getId().getEaisvcname().charAt(entity.getId().getEaisvcname().length() - 2) == 'R'){
+            return;
+        }
+
+        switch(vo.getSyncAsyncType()){
+            case "async":
+            case "syncAsync":
+                entity.setPsvintfacdsticname("ASYN");
+                break;
+        }
+
+        String requestTransfrom = StringUtils.defaultString((String) vo.getRequestTransform());
+        String requestTransformYn = StringUtils.isBlank(requestTransfrom) ? "0" : "1";
+
+        String responseTransfrom = StringUtils.defaultString((String) vo.getResponseTransform());
+        String responseTransfromYn = StringUtils.isBlank(responseTransfrom) ? "0" : "1";
+
+        if("N".equals(vo.getTransformYn())) {
+            requestTransformYn = "0";
+            responseTransfromYn = "0";
+        }
+
+        entity.setChngeonot(requestTransformYn);
+        entity.setBascrspnschngeonot(responseTransfromYn);
+    }
+
+    @Mapping(target = "psvsysbzwkdstcd", source = "eaiBzwkDstcd")
+    @Mapping(target = "psvsysadptrbzwkgroupname", source = "toAdapter")
+    @Mapping(target = "chngmsgidname", source = "requestTransform")
+    @Mapping(target = "bascrspnschngmsgidname", source = "responseTransform")
+    @Mapping(target = "toutval", source = "toutVal", defaultValue = "0L")
+    @Mapping(target = "psvsysidname", constant = "EAIDOM")
+    @Mapping(target = "psvintfacdsticname", constant = "SYNC")
+    @Mapping(target = "psvsyssvcdsticname", constant = " ")
+    @Mapping(target = "flovryn", constant = "0")
+    @Mapping(target = "bascrspnsmsgcmprctnt", constant = " ")
+    @Mapping(target = "errrspnsmsgcmprctnt", constant = " ")
+    @Mapping(target = "errrspnschngeonot", constant = "0")
+    @Mapping(target = "errrspnschngmsgidname", constant = " ")
+    @Mapping(target = "nextsvcprcssno", constant = "1")
+    @Mapping(target = "cmpensvcprcssdsticname", constant = " ")
+    @Mapping(target = "suppldelyn", constant = "0")
+    @Mapping(target = "hdrctrldstcd", constant = "01")
+    @Mapping(target = "hdrrefclsname", constant = " ")
+    void updateServiceMessageEntity(SimpleInterfaceUI vo, @MappingTarget ServiceMessageEntity entity);
+
+    @InheritConfiguration(name="updateServiceMessageEntity")
+    @Mapping(target = "id.eaisvcname", source = "eaiSvcName")
+    @Mapping(target = "id.svcprcssno", constant = "1")
+    ServiceMessageEntity toServiceMessageEntity(SimpleInterfaceUI vo);
+
+    @InheritConfiguration(name="updateServiceMessageEntity")
+    @Mapping(target = "psvsysadptrbzwkgroupname", source = "fromResponseAdapter")
+    void updateAsyncSyncResServiceMessageEntity(SimpleInterfaceUI vo, @MappingTarget ServiceMessageEntity entity);
+
+
+    @Mapping(target = "eaisvcname", source = "eaiSvcName")
+    @Mapping(target = "eaisendrecv", source = "sendRecvType")
+    @Mapping(target = "eaidirection", source = "inOutType")
+    StandardMessageInfo toStandardMessageInfo(SimpleInterfaceUI vo);
+
+    @InheritConfiguration(name="toStandardMessageInfo")
+    @Mapping(source = "eaiSvcName", target = "eaisvcname", qualifiedByName = "changeEaiSvcNameToRecv")
+    @Mapping(target = "eaisendrecv", constant = "R")
+    StandardMessageInfo toSyncAsyncResStandardMessageInfo(SimpleInterfaceUI vo);
+
+    @InheritConfiguration(name="updateServiceMessageEntity")
+    @Mapping(target = "id.eaisvcname", source = "eaiSvcName")
+    @Mapping(target = "id.svcprcssno", constant = "2")
+    @Mapping(target = "psvintfacdsticname", constant = "ASYN")
+    @Mapping(target = "psvsysadptrbzwkgroupname", source = "fromResponseAdapter")
+    @Mapping(target = "chngmsgidname", constant = " ")
+    @Mapping(target = "bascrspnschngmsgidname", constant = " ")
+    ServiceMessageEntity toAsyncSyncResServiceMessageEntity(SimpleInterfaceUI vo);
+
+    @InheritConfiguration(name="updateServiceMessageEntity")
+    @Mapping(target = "id.eaisvcname", source = "eaiSvcName", qualifiedByName = "changeEaiSvcNameToRecv")
+    @Mapping(target = "id.svcprcssno", constant = "1")
+    @Mapping(target = "psvintfacdsticname", constant = "ASYN")
+    @Mapping(target = "chngmsgidname", constant = " ")
+    @Mapping(target = "bascrspnschngmsgidname", constant = " ")
+    ServiceMessageEntity toSyncAsyncResServiceMessageEntity(SimpleInterfaceUI vo);
+
+    @InheritConfiguration(name = "toEaiMessageEntity")
+    @Mapping(source = "eaiSvcName", target = "eaisvcname", qualifiedByName = "changeEaiSvcNameToRecv")
+    @Mapping(target = "gstatsysadptrbzwkgroupname", source = "toResponseAdapter")
+    EAIMessageEntity toSyncAsyncResEaiMessageEntity(SimpleInterfaceUI vo);
+
+    @Named("changeEaiSvcNameToRecv")
+    default String changeEaiSvcNameToRecv(String eaiSvcName) {
+        if (eaiSvcName != null && eaiSvcName.length() > 1) {
+            StringBuilder sb = new StringBuilder(eaiSvcName);
+            sb.setCharAt(sb.length() - 2, 'R'); // 끝에서 두 번째 문자를 'R'로 변경
+            return sb.toString();
+        }
+        return eaiSvcName; // 원본 반환
+    }
+
+    @AfterMapping
+    default void setStandardMessageInfo(SimpleInterfaceUI vo, @MappingTarget StandardMessageInfo entity) throws RuntimeException {
+        String eaiSvcName = entity.getEaisvcname();
+        String inboundAdapterGroupName;
+        String inboundRestPath;
+        String inboundHttpMethod;
+
+        if(eaiSvcName.charAt(eaiSvcName.length() - 2) == 'R'){
+            inboundAdapterGroupName = (String) vo.getToResponseAdapter();
+            inboundRestPath = (String) vo.getOutboundResponseRestPath();
+            inboundHttpMethod = (String) vo.getOutboundResponseHttpMethod();
+        }else {
+            inboundAdapterGroupName = (String) vo.getFromAdapter();
+            inboundRestPath = (String) vo.getInboundRestPath();
+            inboundHttpMethod = (String) vo.getInboundHttpMethod();
+        }
+
+        String inboundMethod = StringUtils.defaultString(inboundHttpMethod, "POST").toUpperCase();
+
+        List<String> headerValues = vo.getHeaderValues();
+
+        String stdMessageKey = inboundAdapterGroupName + ApiInterfaceService.STEMSG_METHOD_DELIMITER + inboundMethod;
+
+        if(vo.getIsHeaderRouting() && headerValues != null && headerValues.size() > 0){
+            stdMessageKey += ApiInterfaceService.STEMSG_SERVICE_HEADER_DELIMITER + String.join(ApiInterfaceService.STEMSG_HEADER_SEPARATOR, headerValues);
+        }else{
+            if(StringUtils.isBlank(inboundRestPath)) {
+                throw new RuntimeException("inbound 서비스 URL이 정의되어 있지 않습니다.");
+            }
+            stdMessageKey += ApiInterfaceService.STEMSG_SERVICE_URL_DELIMITER + inboundRestPath;
+        }
+
+        entity.setBzwksvckeyname(stdMessageKey);
+
+        String eaiTranName = eaiSvcName.substring(0, eaiSvcName.length() - 2);
+        entity.setEaitranname(eaiTranName);
+    }
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/simpleinterface/ui/SimpleInterfaceUI.java

@@ -0,0 +1,50 @@
+package com.eactive.eai.rms.onl.transaction.simpleinterface.ui;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class SimpleInterfaceUI {
+    private Integer sevrLogLvelNo;
+    private String eaiBzwkDstcd;
+    private String sendRecvType;
+    private Integer inOutType;
+    private String eaiSvcDesc;
+    private String fromAdapter;
+    private String toAdapter;
+    private String headerEaiIfId;
+    private String commonInputGramId;
+    private String commonInputGramLwrId;
+    private String inboundHttpMethod;
+    private String inboundRestPath;
+    private String outboundHttpMethod;
+    private String outboundRestPath;
+    private String checkApiCacheUrlKey;
+    private String inboundRequestLayout;
+    private String requestTransform;
+    private String outboundRequestLayout;
+    private String inboundResponseLayout;
+    private String responseTransform;
+    private String outboundResponseLayout;
+    private String interfaceId;
+    private String eaiSvcName;
+    private String transformYn;
+    private Long toutVal;
+    private String simYn;
+    private String author;
+    private String apiCacheYn;
+    private String apiCacheType;
+    private String syncAsyncType;
+    private Boolean isHeaderRouting;
+    private List<String> headerValues;
+
+    //ASYNC-SYNC 용
+    private String inboundResponseHttpMethod;
+    private String inboundResponseRestPath;
+    private String fromResponseAdapter;
+    //SYNC-ASYNC 용
+    private String toResponseAdapter;
+    private String outboundResponseHttpMethod;
+    private String outboundResponseRestPath;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/tracking/BizGridItem.java

@@ -0,0 +1,12 @@
+package com.eactive.eai.rms.onl.transaction.tracking;
+
+import lombok.Data;
+
+@Data
+public class BizGridItem {
+    private int rownum;
+	private String name;
+	private String desc;
+	private String value;
+	private String len;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/tracking/DbTrackingController.java

@@ -0,0 +1,542 @@
+package com.eactive.eai.rms.onl.transaction.tracking;
+
+import com.eactive.eai.common.EAITable;
+import com.eactive.eai.common.logger.HttpAdapterExtraLogVo;
+import com.eactive.eai.common.util.MessageUtil;
+import com.eactive.eai.data.entity.onl.adapter.AdapterGroup;
+import com.eactive.eai.rms.common.combo.ComboVo;
+import com.eactive.eai.rms.common.context.MonitoringContext;
+import com.eactive.eai.rms.common.logging.UserAccessLogger;
+import com.eactive.eai.rms.common.util.CommonUtil;
+import com.eactive.eai.rms.common.vo.GridResponse;
+import com.eactive.eai.rms.data.entity.onl.adapter.AdapterGroupService;
+import com.eactive.eai.rms.data.entity.onl.logger.EAILogDetailSearch;
+import com.eactive.eai.rms.data.entity.onl.logger.EAILogSearch;
+import com.eactive.eai.transformer.message.ISO8583MessageFactory;
+import com.eactive.eai.transformer.util.CommonLib;
+import com.eactive.eai.transformer.util.IConv;
+import com.eactive.eai.transformer.util.ISO8583DumpUtil;
+import com.google.gson.Gson;
+import com.solab.iso8583.IsoMessage;
+import org.apache.commons.io.HexDump;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.log4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.ByteArrayOutputStream;
+import java.util.*;
+
+@Controller
+public class DbTrackingController {
+	private static final Logger logger = Logger
+							.getLogger(DbTrackingController.class);
+
+	private final DbTrackingService service;
+	private final MonitoringContext monitoringContext;
+	private final AdapterGroupService adapterGroupService;
+
+
+	@Autowired
+	public DbTrackingController(DbTrackingService service,
+							MonitoringContext monitoringContext,
+							AdapterGroupService adapterGroupService) {
+		this.service = service;
+		this.monitoringContext = monitoringContext;
+		this.adapterGroupService = adapterGroupService;
+	}
+
+	@GetMapping(value = "/onl/transaction/tracking/trackingMan.view")
+	public String viewList() {
+		return "/onl/transaction/tracking/trackingMan";
+	}
+
+	@GetMapping(value = "/onl/transaction/tracking/trackingMan.view", params = "cmd=DETAIL")
+	public String viewDetail() {
+		return "/onl/transaction/tracking/trackingManDetail";
+	}
+
+	@GetMapping(value = "/onl/transaction/tracking/trackingMan.view", params = "cmd=DETAILPOPUP")
+	public String viewDetailPopup() {
+		return "/onl/transaction/tracking/trackingManDetailpopup";
+	}
+
+	@GetMapping(value = "/onl/transaction/tracking/trackingMan.view", params = "cmd=TRANSFORMPOPUP")
+	public String viewTransformpopup() {
+		return "/onl/transaction/tracking/trackingManTransformpopup";
+	}
+
+	@GetMapping(value = "/onl/transaction/tracking/trackingMan.view", params = "cmd=TRANSFORMPOPUP2")
+	public String viewTransformpopup2() {
+		return "/onl/transaction/tracking/trackingManTransformpopup2";
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=LIST")
+	public ResponseEntity<GridResponse<EAILogUI>> selectList(
+							HttpServletRequest request, Pageable pageable,
+							EAILogSearch eaiLogSearch) {
+		UserAccessLogger.log(request, "거래로그DB", "L", "cmd=LIST");
+		Page<EAILogUI> page = service.selectList(pageable, eaiLogSearch);
+		return ResponseEntity.ok(new GridResponse<>(page));
+	}
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=COUNT")
+	public ResponseEntity<Map<String, Long>> selectList(HttpServletRequest request, EAILogSearch eaiLogSearch) {
+
+		UserAccessLogger.log(request, "거래로그DB", "L", "cmd=COUNT");
+		Map<String, Long> transactionCounts = service.getTransactionCounts(eaiLogSearch);
+
+		long  totalLogs = transactionCounts.values().stream().mapToInt(Long::intValue).sum();
+		long displayedLogs = Math.min(totalLogs, 1000);
+
+		Map<String, Long> result = new HashMap<>();
+		result.put("totalLogs", totalLogs);
+		result.put("displayedLogs", displayedLogs);
+		return ResponseEntity.ok(result);
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=DETAIL")
+	public ResponseEntity<EAILogUI> selectDetail(
+							EAILogDetailSearch eaiLogDetailSearch)
+							throws Exception {
+		EAILogUI map = service.selectDetail(eaiLogDetailSearch);
+
+		processDetail(eaiLogDetailSearch, map);
+
+		return ResponseEntity.ok(map);
+	}
+
+	private void processDetail(EAILogDetailSearch eaiLogDetailSearch,
+							EAILogUI map) {
+		processXmlData(map);
+		processBizData(eaiLogDetailSearch, map);
+		processInputMediaData(map);
+		processMsgType(map);
+	}
+
+	// XML 데이터 처리
+	private void processXmlData(EAILogUI map) {
+
+		map.setXmlDataYn("N"); // xml button hide/show
+		map.setOrgDataYn("N"); // detail button hide/show
+
+		String xmlYn = monitoringContext.getStringProperty(
+								MonitoringContext.RMS_DBTRACKING_XML_YN, "N");
+
+		if ("Y".equals(xmlYn)) {
+			String logProcessNo = map.getLogprcssserno();
+
+			if (("ASYN".equals(map.getSvcmotivusedstcd()) && "ASYN"
+									.equals(map.getPsvintfacdsticname())) &&
+									("100".equals(logProcessNo) || "300".equals(
+															logProcessNo))
+									&& ("100".equals(logProcessNo))) {
+				map.setOrgDataYn("Y");
+			}
+
+			map.setXmlDataYn("Y");
+		}
+
+	}
+
+	// 업무 데이터 처리 - 그리드로 보기
+	// TODO: 그리드 보기 처리 수정 필요
+	private void processBizData(EAILogDetailSearch eaiLogDetailSearch,
+							EAILogUI map) {
+		map.setBizDataYn("N");
+
+		// table이 선언은 되었으나 service.resultByMessage에도 필요하지 않음.
+		// String date = map.getMsgdpstyms();
+		// String table = CommonUtil.getLogTable(date, true);
+		try {
+			LogBizResultItem logBizResultItem = service.resultByMessageWithLogDetail(eaiLogDetailSearch, map, "GRID");
+			String bizData = logBizResultItem.getResultString();
+			String base64LogDetail = new String(Base64.getEncoder().encode(logBizResultItem.getBizLogObjectDetail().getBytes("utf-8")));
+			map.setBizLogObjectDetail(base64LogDetail);
+			
+			List<BizGridItem> bizGridList = new ArrayList<>();
+
+			if (bizData != null) {
+				String[] strArr = bizData.split("\\^LINE\\^");
+
+				for (int i = 0; i < strArr.length; i++) {
+					BizGridItem tmp = new BizGridItem();
+					String biz = strArr[i];
+					String[] bizArr = biz.split("\\^FLD\\^");
+
+					for (int k = 0; k < bizArr.length; k++) {
+						tmp.setRownum(i + 1);
+						tmp.setName(bizArr[0]);
+						tmp.setDesc(bizArr[1]);
+						tmp.setValue(bizArr[2]);
+						tmp.setLen(bizArr[3]);
+					}
+
+					bizGridList.add(tmp);
+				}
+
+				map.setBizDataYn("Y");
+			}
+
+			map.setBizGridRows(bizGridList);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+
+	}
+
+	// 입력 매체 데이터 처리
+	// 입력매체부 팝업 TELGMDMNDDSTCD CHNLDSTCD 수동어댑터가 표준이면서
+	// INPTMDIAPARTLLEN(입력매체부 길이가 0이상)
+	private boolean determineIsMedia(EAILogUI map, String targetSyncAsync,
+							int logSeq, String inptmdiapartllen) {
+
+		Optional<AdapterGroup> targetAdapterInfo = adapterGroupService
+								.findById(map.getPsvsysadptrbzwkgroupname());
+		String outAdptrMsgPtrnCd = targetAdapterInfo
+								.map(AdapterGroup::getAdptrmsgptrncd)
+								.orElse("N");
+
+		// 표준 어댑터이고 입력 매체 부분 길이가 0보다 큰 경우 로직 실행
+		if (com.eactive.eai.adapter.Keys.IF_STANDARD.equals(outAdptrMsgPtrnCd)
+								&& Integer.parseInt(inptmdiapartllen) > 0) {
+
+			// 비동기 서비스 조건 체크
+			if ("ASYN".equals(map.getSvcmotivusedstcd())
+									&& "ASYN".equals(targetSyncAsync)) {
+				return logSeq == 200 || logSeq == 400;
+			} else { // 동기 서비스 조건 체크
+				return logSeq == 200 || logSeq == 300;
+			}
+
+		}
+
+		return false; // 기본적으로 false 반환
+	}
+
+	private void processInputMediaData(EAILogUI map) {
+		map.setInputMediaDataYn("N");
+
+		String inptmdiapartllen = "0";
+
+		int logSeq = Integer.parseInt(map.getLogprcssserno());
+		String targetSyncAsync = map.getPsvintfacdsticname();
+		boolean isMedia = determineIsMedia(map, targetSyncAsync, logSeq,
+								inptmdiapartllen);
+
+		if (isMedia) {
+			map.setInputMediaDataYn("Y");
+		}
+
+	}
+
+	// 메시지 유형 처리
+	private void processMsgType(EAILogUI map) {
+		int logSeq = Integer.parseInt(map.getLogprcssserno());
+		String msgType;
+
+		if (logSeq == 100 || logSeq == 400) {
+			String sourceAdapter = map.getGstatsysadptrbzwkgroupname();
+			Optional<AdapterGroup> sourceAdapterInfo = adapterGroupService
+									.findById(sourceAdapter);
+			msgType = sourceAdapterInfo.map(AdapterGroup::getAdptrmsgdstcd)
+									.orElse("");
+		} else {
+			msgType = adapterGroupService
+									.findById((map.getPsvsysadptrbzwkgroupname()))
+									.map(AdapterGroup::getAdptrmsgdstcd)
+									.orElse("");
+		}
+
+		map.setMsgType(msgType);
+
+		if (ISO8583MessageFactory.isISO8583Message(msgType)) {
+			map.setIso8583DataYn("Y");
+		}
+
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.excel", params = "cmd=LIST_GRID_TO_EXCEL")
+	public ModelAndView listGridToExcel(Pageable pageable,
+							EAILogSearch eaiLogSearch) {
+		HashMap<String, Object> resultMap = new HashMap<>();
+
+		List<Map<String, Object>> datas = service
+								.selectListToExcel(eaiLogSearch);
+		resultMap.put("datas", datas);
+		return new ModelAndView("excelView", resultMap);
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.excel", params = "cmd=LIST_BIZGRID_TO_EXCEL")
+	public ModelAndView listBizGridToExcel(
+							@RequestParam Map<String, Object> paramMap) {
+		HashMap<String, Object> resultMap = new HashMap<>();
+		Gson gson = new Gson();
+		String jsonStr = (String) paramMap.get("gridData");
+		resultMap.put("datas", gson.fromJson(jsonStr, HashMap[].class));
+		return new ModelAndView("excelView", resultMap);
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=LIST_COMBO")
+	public ResponseEntity<Map<String, List<ComboVo>>> selectCombo() {
+		Map<String, List<ComboVo>> map = service.selectCombo();
+		return ResponseEntity.ok(map);
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=LIST_DETAIL_COMBO")
+	public ResponseEntity<Map<String, List<ComboVo>>> selectDetailCombo() {
+
+		Map<String, List<ComboVo>> map = service.selectDetailCombo();
+		return ResponseEntity.ok(map);
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=DETAIL_XML")
+	public String showXML(HttpServletRequest request,
+							EAILogDetailSearch eaiLogDetailSearch)
+							throws Exception {
+		String errorMsg = "";
+
+		// 조회테이블 지정
+		String date = eaiLogDetailSearch.getMsgDpstYMS();
+		String table = CommonUtil.getLogTable(date, true);
+
+		if (table == null || "".equals(table)) {
+			// 에러
+			errorMsg = "Unable to specify log table name. => time=" + date;
+			request.setAttribute("param", errorMsg);
+			return "forward:/common/jsp/popupXml.jsp";
+		}
+
+		// 상세화면에서 업무구분코드는 지정하지 않아도 된다.
+
+		// 조회
+		EAILogUI data = service.selectDetail(eaiLogDetailSearch);
+
+		if (data == null) {
+			errorMsg = "Data retrieval failed";
+			request.setAttribute("param", errorMsg);
+			return "forward:/common/jsp/popupXml.jsp";
+		}
+
+		String xmlData = service.resultByMessage(eaiLogDetailSearch,
+								data, "XML");
+		logger.warn("xmlData = " + xmlData);
+		if (!xmlData.isEmpty())
+			request.setAttribute("param", xmlData);
+		return "forward:/common/jsp/popupXml.jsp";
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=DETAIL_JSON")
+	public String showJSON() {
+
+		return "forward:/common/jsp/popupJson.jsp";
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=DETAIL_INPTMDIA")
+	public ModelAndView showINPTMDIA(HttpServletRequest request,
+							HttpServletResponse response,
+							@RequestParam Map<String, Object> paramMap,
+							EAILogDetailSearch eaiLogDetailSearch)
+							throws Exception {
+		EAILogUI map = service.selectDetail(eaiLogDetailSearch);
+
+		// String date = eaiLogDetailSearch.getMsgDpstYMS();
+		// String table = CommonUtil.getLogTable(date, true);
+		String mediaData = service.resultByMessage(eaiLogDetailSearch,
+								map, "MEDIA");
+
+		List<HashMap<String, Object>> mediaGridList = new ArrayList<>();
+
+		if (mediaData != null) {
+			String[] strArr = mediaData.split("\\^LINE\\^");
+
+			for (int i = 0; i < strArr.length; i++) {
+				HashMap<String, Object> tmp = new HashMap<>();
+				String biz = strArr[i];
+				String[] bizArr = biz.split("\\^FLD\\^");
+
+				for (int k = 0; k < bizArr.length; k++) {
+					tmp.put("rownum", i + 1);
+					tmp.put("name", bizArr[0]);
+					tmp.put("desc", bizArr[1]);
+					tmp.put("value", bizArr[2]);
+					tmp.put("len", bizArr[3]);
+				}
+
+				mediaGridList.add(tmp);
+			}
+
+		}
+
+		Map<String, Object> resultMap = new HashMap<>();
+		resultMap.put("rows", mediaGridList);
+		return new ModelAndView("jsonView", resultMap);
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=DETAIL_EBCDIC")
+	public String showEbcdic(HttpServletRequest request,
+							EAILogDetailSearch eaiLogDetailSearch)
+							throws Exception {
+		String errorMsg = "";
+
+		// 조회테이블 지정
+		String date = eaiLogDetailSearch.getMsgDpstYMS();
+		String table = CommonUtil.getLogTable(date, true);
+
+		if (table == null || "".equals(table)) {
+			// 에러
+			errorMsg = "Unable to specify log table name. => time=" + date;
+			request.setAttribute("param", errorMsg);
+			return "forward:/common/jsp/popupXml.jsp";
+		}
+
+		// 조회
+		EAILogUI eaiLogUI = service.selectDetail(eaiLogDetailSearch);
+
+		if (eaiLogUI == null) {
+			errorMsg = "Data retrieval failed";
+			request.setAttribute("param", errorMsg);
+			return "forward:/common/jsp/popupMessage.jsp";
+		}
+
+		String bizData = eaiLogUI.getBzwkdatactnt();
+		String printData = "";
+
+		byte[] orgBytes = bizData.getBytes();
+
+		printData = IConv.ebcdicToASCIIWithSOSIEX(orgBytes);
+
+		String[] dump = CommonLib.makeDumpFormat(orgBytes);
+
+		StringBuilder sb = new StringBuilder();
+
+		for (String s : dump) {
+			sb.append(s).append("<br>");
+		}
+
+		String dumpData = sb.toString();
+
+		if (!printData.isEmpty()) {
+			request.setAttribute("bizData", printData);
+			request.setAttribute("bizDataHexa", dumpData);
+		}
+
+		return "forward:/common/jsp/popupMessage.jsp";
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=DETAIL_ORG")
+	public String showOrgMessage(HttpServletRequest request,
+							EAILogDetailSearch eaiLogDetailSearch)
+							throws Exception {
+		String errorMsg = "";
+		// 상세화면에서 업무구분코드는 지정하지 않아도 된다.
+		EAILogUI data = service.selectDetail(eaiLogDetailSearch);
+
+		if (data == null) {
+			errorMsg = "Data retrieval failed";
+			request.setAttribute("param", errorMsg);
+			return "forward:/common/jsp/popupMessage.jsp";
+		}
+
+		String bizData = data.getBzwkdatactnt();
+		request.setAttribute("bizData", bizData);
+
+		return "forward:/common/jsp/popupOrgMessage.jsp";
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=DETAIL_HTTP_LOG")
+	public ResponseEntity<HttpAdapterExtraLogVo> selectHttpAdapterExtraLog(
+							@RequestParam int dayOfWeekNumber,
+							@RequestParam String guid,
+							@RequestParam int serviceProcessNumber) {
+		return ResponseEntity.ok(service.selectHttpAdapterExtraLog(
+								dayOfWeekNumber, guid, serviceProcessNumber));
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/trackingMan.json", params = "cmd=DETAIL_8583")
+	public String showIso8583(HttpServletRequest request,
+							EAILogDetailSearch eaiLogDetailSearch)
+							throws Exception {
+		String errorMsg = "";
+
+		// 조회테이블 지정
+		String date = eaiLogDetailSearch.getMsgDpstYMS();
+		String table = CommonUtil.getLogTable(date, true);
+
+		if (table == null || "".equals(table)) {
+			// 에러
+			errorMsg = "Unable to specify log table name. => time=" + date;
+			request.setAttribute("param", errorMsg);
+			return "forward:/common/jsp/popupXml.jsp";
+		}
+
+		// 상세화면에서 업무구분코드는 지정하지 않아도 된다.
+
+		// 조회
+		EAILogUI data = service.selectDetail(eaiLogDetailSearch);
+
+		if (data == null) {
+			errorMsg = "Data retrieval failed";
+			request.setAttribute("param", errorMsg);
+			return "forward:/common/jsp/popupMessage.jsp";
+		}
+
+		String bizData = data.getBzwkdatactnt();
+		String adapterName = "";
+
+		try {
+			String logPrcssSerno = eaiLogDetailSearch.getLogPrcssSerno();
+
+			if (StringUtils.equalsAny(logPrcssSerno, "200", "300")) {
+				adapterName = data.getPsvsysadptrbzwkgroupname();
+			} else {
+				adapterName = data.getGstatsysadptrbzwkgroupname();
+			}
+
+			Optional<AdapterGroup> adapterInfo = adapterGroupService
+									.findById(adapterName);
+			String adapterMsgType = adapterInfo
+									.map(AdapterGroup::getAdptrmsgdstcd)
+									.orElse(EAITable.ISO8583_TYPE);
+
+			if (ISO8583MessageFactory.isISO8583Message(adapterMsgType)) {
+				byte[] bizDataBytes = bizData.getBytes();
+				IsoMessage m = MessageUtil.parseIsoMessage(bizDataBytes,
+										adapterMsgType);
+				String dump = ISO8583DumpUtil.dumpIsoMessageForEms(m,
+										adapterMsgType);
+				String result = "[Hex Dump]\n" + dumpstr(bizDataBytes) + "\n";
+				result += "[Parsed Iso8583 Message]\n" + dump;
+				bizData = result;
+			}
+
+		} catch (Exception ex) {
+			logger.error("Error generating ISO8583 message", ex);
+		}
+
+		request.setAttribute("bizData", bizData);
+
+		return "forward:/common/jsp/popupOrgMessage.jsp";
+	}
+
+	public static String dumpstr(final byte[] data) {
+		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+
+		try {
+			HexDump.dump(data, 0, byteArrayOutputStream, 0);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+
+		return new String(byteArrayOutputStream.toByteArray());
+	}
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/tracking/EAILogUI.java

@@ -0,0 +1,367 @@
+package com.eactive.eai.rms.onl.transaction.tracking;
+
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.eactive.eai.message.StandardLogItem;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.Data;
+import org.hibernate.annotations.Comment;
+
+import javax.persistence.Column;
+
+@Data
+
+public class EAILogUI {
+
+	/** EAI업무구분코드 */
+	@JsonProperty("EAIBZWKDSTCD")
+	private String eaibzwkdstcd;
+
+	/** 메시지수신시각 */
+	@JsonProperty("MSGDPSTYMS")
+	private String msgdpstyms;
+
+	/** EAI서비스일련번호 */
+	@JsonProperty("EAISVCSERNO")
+	private String eaisvcserno;
+
+	/** 로그처리일련번호 */
+	@JsonProperty("LOGPRCSSSERNO")
+	private String logprcssserno;
+
+	/** EAI서버인스턴스명 */
+	@JsonProperty("EAISEVRINSTNCNAME")
+	private String eaisevrinstncname;
+
+	/** EAI서비스명 */
+	@JsonProperty("EAISVCNAME")
+	private String eaisvcname;
+
+	/** 서비스시각유무 */
+	@JsonProperty("SVCHMSEONOT")
+	private String svchmseonot;
+
+	/** 서비스동기사용구분코드 */
+	@JsonProperty("SVCMOTIVUSEDSTCD")
+	private String svcmotivusedstcd;
+
+	/** 서비스처리구분명 */
+	@JsonProperty("SVCPRCSSDSTICNAME")
+	private String svcprcssdsticname;
+
+	/** 흐름통제라우팅명 */
+	@JsonProperty("FLOWCTRLROUTNAME")
+	private String flowctrlroutname;
+
+	/** 통합구분명 */
+	@JsonProperty("INTGRADSTICNAME")
+	private String intgradsticname;
+
+	/** 기동서비스구분명 */
+	@JsonProperty("GSTATSVCDSTICNAME")
+	private String gstatsvcdsticname;
+
+	/** 서비스처리번호 */
+	@JsonProperty("SVCPRCSSNO")
+	private String svcprcssno;
+
+	/** 서비스전컬럼로그여부 */
+	@JsonProperty("SVCBFCLMNLOGYN")
+	private String svcbfclmnlogyn;
+
+	/** 표준메시지사용여부 */
+	@JsonProperty("STNDMSGUSEYN")
+	private String stndmsguseyn;
+
+	/** 기동시스템어댑터업무그룹명 */
+	@JsonProperty("GSTATSYSADPTRBZWKGROUPNAME")
+	private String gstatsysadptrbzwkgroupname;
+
+	/** 현재메시지ID명 */
+	@JsonProperty("PRSNTMSGIDNAME")
+	private String prsntmsgidname;
+
+	/** 응답에러코드명 */
+	@JsonProperty("RSPNSERRCDNAME")
+	private String rspnserrcdname;
+
+	/** 메시지처리시각 */
+	@JsonProperty("MSGPRCSSYMS")
+	private String msgprcssyms;
+
+	/** 서버로그레벨번호 */
+	@JsonProperty("SEVRLOGLVELNO")
+	private String sevrloglvelno;
+
+	/** 서비스로그레벨번호 */
+	@JsonProperty("SVCLOGLVELNO")
+	private String svcloglvelno;
+
+	/** 오류EAI서비스명 */
+	@JsonProperty("ERREAISVCNAME")
+	private String erreaisvcname;
+
+	/** 요청오류변환ID명 */
+	@JsonProperty("DMNDERRCHNGIDNAME")
+	private String dmnderrchngidname;
+
+	/** 요청에러필드명 */
+	@JsonProperty("DMNDERRFLDNAME")
+	private String dmnderrfldname;
+
+	/** 응답오류변환ID명 */
+	@JsonProperty("RSPNSERRCHNGIDNAME")
+	private String rspnserrchngidname;
+
+	/** 응답에러필드명 */
+	@JsonProperty("RSPNSERRFLDNAME")
+	private String rspnserrfldname;
+
+	/** 수동인터페이스구분명 */
+	@JsonProperty("PSVINTFACDSTICNAME")
+	private String psvintfacdsticname;
+
+	/** 수동업무시스템명 */
+	@JsonProperty("PSVBZWKSYSNAME")
+	private String psvbzwksysname;
+
+	/** 수동시스템ID명 */
+	@JsonProperty("PSVSYSIDNAME")
+	private String psvsysidname;
+
+	/** 수동시스템서비스구분명 */
+	@JsonProperty("PSVSYSSVCDSTICNAME")
+	private String psvsyssvcdsticname;
+
+	/** 수동시스템어댑터업무그룹명 */
+	@JsonProperty("PSVSYSADPTRBZWKGROUPNAME")
+	private String psvsysadptrbzwkgroupname;
+
+	/** 장애극복여부 */
+	@JsonProperty("FLOVRYN")
+	private String flovryn;
+
+	/** 변환여부 */
+	@JsonProperty("CHNGYN")
+	private String chngyn;
+
+	/** 변환메시지ID명 */
+	@JsonProperty("CHNGMSGIDNAME")
+	private String chngmsgidname;
+
+	/** 입력메시지ID명 */
+	@JsonProperty("INPTMSGIDNAME")
+	private String inptmsgidname;
+
+	/** 기본응답메시지비교내용 */
+	@JsonProperty("BASCRSPNSMSGCMPRCTNT")
+	private String bascrspnsmsgcmprctnt;
+
+	/** 기본응답변환여부 */
+	@JsonProperty("BASCRSPNSCHNGYN")
+	private String bascrspnschngyn;
+
+	/** 기본응답변환메시지ID명 */
+	@JsonProperty("BASCRSPNSCHNGMSGIDNAME")
+	private String bascrspnschngmsgidname;
+
+	/** 오류응답메시지비교내용 */
+	@JsonProperty("ERRRSPNSMSGCMPRCTNT")
+	private String errrspnsmsgcmprctnt;
+
+	/** 오류응답변환여부 */
+	@JsonProperty("ERRRSPNSCHNGYN")
+	private String errrspnschngyn;
+
+	/** 오류응답변환메시지ID명 */
+	@JsonProperty("ERRRSPNSCHNGMSGIDNAME")
+	private String errrspnschngmsgidname;
+
+	/** 다음서비스처리번호 */
+	@JsonProperty("NEXTSVCPRCSSNO")
+	private String nextsvcprcssno;
+
+	/** 타임아웃값 */
+	@JsonProperty("TOUTVAL")
+	private Integer toutval;
+
+	/** 추가업무데이터여부 */
+	@JsonProperty("SUPPLBZWKDATAYN")
+	private String supplbzwkdatayn;
+
+	/** 키관리메시지내용 */
+	@JsonProperty("KEYMGTMSGCTNT")
+	private String keymgtmsgctnt;
+
+	/** 추적보조키1내용 */
+	@JsonProperty("TRACKASISKEY1CTNT")
+	private String trackasiskey1ctnt;
+
+	/** 추적보조키2내용 */
+	@JsonProperty("TRACKASISKEY2CTNT")
+	private String trackasiskey2ctnt;
+
+	/** 추적보조키3내용 */
+	@JsonProperty("TRACKASISKEY3CTNT")
+	private String trackasiskey3ctnt;
+
+	/** 추적보조키4내용 */
+	@JsonProperty("TRACKASISKEY4CTNT")
+	private String trackasiskey4ctnt;
+
+	/** EAI서비스코드의 그룹회사코드 */
+	@JsonProperty("EAIGROUPCODSTCD")
+	private String eaigroupcodstcd;
+
+	/** PGUID */
+	@JsonProperty("PGUID")
+	private String pguid;
+
+	/** 송수신구분 */
+	@JsonProperty("TRANTYPE")
+	private String trantype;
+
+	/** 응답변환타입 */
+	@JsonProperty("RSPNSCHNGMSGTYPE")
+	private String rspnschngmsgtype;
+
+	/** EAI에러코드 */
+	@JsonProperty("EAIERRCD")
+	private String eaierrcd;
+
+	/** EAI에러내용 */
+	@JsonProperty("EAIERRCTNT")
+	private String eaierrctnt;
+
+	/** 서버그룹명 */
+	@JsonProperty("SEVRGROUPNAME")
+	private String sevrgroupname;
+
+	/** 업체코드 */
+	@JsonProperty("COMPANYCODE")
+	private String companycode;
+
+	/** 전문크기 */
+	@JsonProperty("SPLIZLENGTH")
+	private Integer splizlength;
+
+	/** adapter nick name */
+	@JsonProperty("ADPTRINSTICODE")
+	private String adptrinsticode;
+
+	/** 거래ID */
+	@JsonProperty("TXID")
+	private String txid;
+
+	/** 참조ID */
+	@JsonProperty("REFKEY")
+	private String refkey;
+
+	/** 대외업무구분코드 */
+	@JsonProperty("EXTBIZCD")
+	private String extbizcd;
+
+	/** EAI 업무 개별부 */
+	@JsonProperty("BZWKDATACTNT")
+	private String bzwkdatactnt;
+
+	/** 표준전문레이아웃 명 */
+	@JsonProperty("STDLAYOUTNAME")
+	private String stdlayoutname;
+
+	/** 보상서비스처리명 */
+	@JsonProperty("CMPENSVCPRCSSNAME")
+	private String cmpensvcprcssname;
+
+	/** Outbound라우팅명 */
+	@JsonProperty("OUTBNDROUTNAME")
+	private String outbndroutname;
+
+	/** client id */
+	@JsonProperty("CLIENTID")
+	private String clientid;
+
+	@JsonProperty("ADPTRINSTINAME")
+	private String adptrinstiname;
+
+	@JsonProperty("EAISVCDESC")
+	private String eaisvcdesc;
+
+	@JsonProperty("CLIENTNAME")
+	private String clientname;
+
+	@JsonProperty("CLIENTIP")
+	private String clientip;
+
+	@JsonProperty("ORGID")
+	private String orgid;
+
+	@JsonProperty("ORGNAME")
+	private String orgname;
+
+	@JsonProperty("FULLMESSAGEDATA")
+	private String fullmessagedata;
+
+	@JsonProperty("EAISVCSERNO_TMP")
+	private String getEaisvcsernoTmp() {
+		return eaisvcserno;
+	}
+
+	@JsonProperty("LOGPRCSSSERNO_TMP")
+	private String getLogprcsssernoTmp() {
+		return logprcssserno;
+	}
+
+	@JsonProperty("EAIBZWKDSTCD_TMP")
+	private String getEaibzwkdstcdTmp() {
+		return eaibzwkdstcd;
+	}
+
+	@JsonProperty("MSGDPSTYMS_TMP")
+	private String getMsgdpstymsTmp() {
+		return msgdpstyms;
+	}
+
+	@JsonProperty("ERRYN")
+	private String getErryn() {
+		if (StringUtils.isBlank(eaierrctnt)) {
+			return "N";
+		} else {
+			return "Y";
+		}
+	}
+
+	///////////////////////////////////////////////////////////// detail 변수들
+	private List<StandardLogItem> standardHeader;
+
+	private String errStandardHeaderText;
+
+	private String subHeaderExist;
+
+	private List<StandardLogItem> subHeader;
+
+	private String errSubHeaderText;
+
+	private String xmlDataYn;
+
+	private String bizDataYn;
+
+	private List<BizGridItem> bizGridRows;
+
+	private String orgDataYn;
+
+	private String inputMediaDataYn;
+
+	private String msgType;
+
+	private String iso8583DataYn;
+
+	private String OUTPTDPTRNDSTCD;
+
+	private String TELGMDMNDDSTCD;
+
+	private String bizLogObjectDetail;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/tracking/EAILogUIMapper.java

@@ -0,0 +1,31 @@
+package com.eactive.eai.rms.onl.transaction.tracking;
+
+import org.mapstruct.InheritInverseConfiguration;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+
+import com.eactive.eai.data.entity.onl.logger.EAILog;
+import com.eactive.eai.data.mapper.BaseMapperConfig;
+import com.eactive.eai.data.mapper.GenericMapper;
+import com.eactive.eai.rms.data.entity.onl.logger.EAILogDto;
+
+@Mapper(config = BaseMapperConfig.class)
+public interface EAILogUIMapper extends GenericMapper<EAILogUI, EAILog> {
+
+	@Mapping(source = "id.eaibzwkdstcd", target = "eaibzwkdstcd")
+	@Mapping(source = "id.eaisvcserno", target = "eaisvcserno")
+	@Mapping(source = "id.logprcssserno", target = "logprcssserno")
+	@Mapping(source = "id.msgdpstyms", target = "msgdpstyms")
+	@Override
+	EAILogUI toVo(EAILog entity);
+
+	@InheritInverseConfiguration
+	@Override
+	EAILog toEntity(EAILogUI vo);
+
+	default EAILogUI toVo(EAILogDto dto) {
+		EAILogUI ui = toVo(dto.getEaiLog());
+		ui.setEaisvcdesc(dto.getEaiSvcDesc());
+		return ui;
+	}
+}

src/main/java/com/eactive/eai/rms/onl/transaction/tracking/LogBizResultItem.java

@@ -0,0 +1,9 @@
+package com.eactive.eai.rms.onl.transaction.tracking;
+
+import lombok.Data;
+
+@Data
+public class LogBizResultItem {
+	private String resultString;
+	private String bizLogObjectDetail;
+}

src/main/java/com/eactive/eai/rms/onl/transaction/tracking/STDXmlParser.java

@@ -0,0 +1,246 @@
+package com.eactive.eai.rms.onl.transaction.tracking;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+import org.jdom.Document;
+import org.jdom.Element;
+import org.jdom.input.SAXBuilder;
+
+
+public class STDXmlParser {
+	private static final String XML_HEADER = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
+	private static Logger logger = Logger.getLogger(STDXmlParser.class);
+	public static void main(String[] args) throws Exception{
+		String data = 
+				"<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n" +
+				"       <STD_SYSTEMHEADER_REQ desc=\"표준전문-시스템헤더\">\r\n" + 
+				"           <VRSN desc=\"버전\" length=\"3\"></VRSN>\r\n" + 
+				"           <INPT_OUPT_DVSN_CODE desc=\"입력출력구분코드\" length=\"1\">I</INPT_OUPT_DVSN_CODE>\r\n" + 
+				"           <VFST_GUID desc=\"최초GUID\" length=\"38\">CBK20210312121212000ieaiinst1100000001</VFST_GUID>\r\n" + 
+				"           <GUID desc=\"GUID\" length=\"38\">CBK20210312121212000ieaiinst1100000001</GUID>\r\n" + 
+				"           <PRGR_SQNU desc=\"진행일련번호\" length=\"4\">0</PRGR_SQNU>\r\n" + 
+				"           <TLGR_CRYP_YN desc=\"전문암호화여부\" length=\"1\"></TLGR_CRYP_YN>\r\n" + 
+				"           <CHNL_DVSN desc=\"채널구분\" length=\"2\"></CHNL_DVSN>\r\n" + 
+				"           <IP_VRSN_DVSN_CODE desc=\"IP버전구분코드\" length=\"2\"></IP_VRSN_DVSN_CODE>\r\n" + 
+				"           <FRST_RQUT_SYS_IP desc=\"최초요청시스템IP\" length=\"39\"></FRST_RQUT_SYS_IP>\r\n" + 
+				"           <FRST_RQUT_SYS_MAC desc=\"최초요청시스템MAC\" length=\"17\"></FRST_RQUT_SYS_MAC>\r\n" + 
+				"           <ENVR_INFO_DVSN_CODE desc=\"환경정보구분코드\" length=\"1\">D</ENVR_INFO_DVSN_CODE>\r\n" + 
+				"           <FRST_RQUT_SYS_CODE desc=\"최초요청시스템코드\" length=\"3\"></FRST_RQUT_SYS_CODE>\r\n" + 
+				"           <TRAN_SYS_CODE desc=\"전송시스템코드\" length=\"3\"></TRAN_SYS_CODE>\r\n" + 
+				"           <MCI_IF_ID desc=\"MCI_인터페이스ID\" length=\"15\">MITTCBK00000009</MCI_IF_ID>\r\n" + 
+				"           <MCI_IF_SESN_ID desc=\"MCI_인터페이스세션ID\" length=\"40\"></MCI_IF_SESN_ID>\r\n" + 
+				"           <MCI_IF_NODE_ID desc=\"MCI_인터페이스노드ID\" length=\"2\"></MCI_IF_NODE_ID>\r\n" + 
+				"           <EAI_IF_ID desc=\"EAI_인터페이스ID\" length=\"15\"></EAI_IF_ID>\r\n" + 
+				"           <EAI_IF_SESN_ID desc=\"EAI_인터페이스세션ID\" length=\"40\"></EAI_IF_SESN_ID>\r\n" + 
+				"           <EAI_IF_NODE_ID desc=\"EAI_인터페이스노드ID\" length=\"2\"></EAI_IF_NODE_ID>\r\n" + 
+				"           <FEP_IF_ID desc=\"FEP_인터페이스ID\" length=\"15\"></FEP_IF_ID>\r\n" + 
+				"           <FEP_IF_SESN_ID desc=\"FEP_인터페이스세션ID\" length=\"40\"></FEP_IF_SESN_ID>\r\n" + 
+				"           <FEP_IF_NODE_ID desc=\"FEP_인터페이스노드ID\" length=\"2\"></FEP_IF_NODE_ID>\r\n" + 
+				"           <FRST_TLGR_RQUT_DATE desc=\"최초전문요청일시\" length=\"17\">20210312100000000</FRST_TLGR_RQUT_DATE>\r\n" + 
+				"           <RQUT_SYS_CODE desc=\"요청시스템코드\" length=\"3\"></RQUT_SYS_CODE>\r\n" + 
+				"           <RQUT_SYS_NODE_ID desc=\"요청시스템노드ID\" length=\"3\"></RQUT_SYS_NODE_ID>\r\n" + 
+				"           <TLGR_RQUT_DATE desc=\"전문요청일시\" length=\"17\">20210312100000000</TLGR_RQUT_DATE>\r\n" + 
+				"           <TX_PROC_DVSN_CODE desc=\"거래처리구분코드\" length=\"1\"></TX_PROC_DVSN_CODE>\r\n" + 
+				"           <RESP_SYS_CODE desc=\"응답시스템코드\" length=\"3\"></RESP_SYS_CODE>\r\n" + 
+				"           <TLGR_RESP_DATE desc=\"전문응답일시\" length=\"17\"></TLGR_RESP_DATE>\r\n" + 
+				"           <RESP_RSLT_DVSN_CODE desc=\"응답결과구분코드\" length=\"1\"></RESP_RSLT_DVSN_CODE>\r\n" + 
+				"           <MULTILNG_DVSN_CODE desc=\"다국어구분코드\" length=\"2\"></MULTILNG_DVSN_CODE>\r\n" + 
+				"           <MSG_CHNL_DVSN desc=\"메시지채널구분\" length=\"2\"></MSG_CHNL_DVSN>\r\n" + 
+				"           <TX_ID desc=\"거래ID\" length=\"10\">ATDCI00010</TX_ID>\r\n" + 
+				"           <CANL_TX_YN desc=\"취소거래여부\" length=\"1\"></CANL_TX_YN>\r\n" + 
+				"           <TLGR_TYPE_CODE desc=\"전문 유형코드\" length=\"1\"></TLGR_TYPE_CODE>\r\n" + 
+				"           <LVOL_DATA_PROC_DVSN_CODE desc=\"대량데이터처리구분코드\" length=\"1\"></LVOL_DATA_PROC_DVSN_CODE>\r\n" + 
+				"           <LVOL_DATA_PROC_SERI_SEQ desc=\"대량데이터처리일련번호\" length=\"4\">0</LVOL_DATA_PROC_SERI_SEQ>\r\n" + 
+				"           <SMLT_TX_DVSN_CODE desc=\"시뮬레이션 거래 구분코드\" length=\"1\"></SMLT_TX_DVSN_CODE>\r\n" + 
+				"           <ACNT_MODE_DVSN_CODE desc=\"계정모드 구분코드\" length=\"1\"></ACNT_MODE_DVSN_CODE>\r\n" + 
+				"           <NORM_RESP_RCVM_TX_ID desc=\"정상응답수신거래ID\" length=\"10\"></NORM_RESP_RCVM_TX_ID>\r\n" + 
+				"           <OUTR_TX_TIMR_ACTN_KEY desc=\"대외거래TIMER실행키\" length=\"50\"></OUTR_TX_TIMR_ACTN_KEY>\r\n" + 
+				"           <ERR_RESP_RCVM_TX_ID desc=\"오류응답수신거래ID\" length=\"10\"></ERR_RESP_RCVM_TX_ID>\r\n" + 
+				"       </STD_SYSTEMHEADER_REQ>\r\n" + 
+				"<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n" +
+				"       <STD_COMMONHEADER_REQ desc=\"표준전문-공통헤더\">\r\n" + 
+				"           <ROFC_CODE desc=\"청코드\" length=\"2\"></ROFC_CODE>\r\n" + 
+				"           <BRN_CODE desc=\"국코드\" length=\"6\"></BRN_CODE>\r\n" + 
+				"           <TRMT_ROFC_CODE desc=\"취급청코드\" length=\"2\"></TRMT_ROFC_CODE>\r\n" + 
+				"           <TRMT_BRN_CODE desc=\"취급국코드\" length=\"6\"></TRMT_BRN_CODE>\r\n" + 
+				"           <TX_TRMN_NO desc=\"거래단말번호\" length=\"8\"></TX_TRMN_NO>\r\n" + 
+				"           <USER_ID desc=\"사용자ID\" length=\"9\">TEST00001</USER_ID>\r\n" + 
+				"           <RSPS_APRV_PROC_CODE desc=\"책임자승인처리코드\" length=\"1\">R</RSPS_APRV_PROC_CODE>\r\n" + 
+				"           <RSPS_APRV_ORDR desc=\"책임자승인차수\" length=\"1\"></RSPS_APRV_ORDR>\r\n" + 
+				"           <approveCodeList desc=\"책임자승인코드 목록 시작\">\r\n" + 
+				"               <RSPS_APRV_CODE desc=\"책임자승인코드\" length=\"8\"></RSPS_APRV_CODE>\r\n" + 
+				"               <RSPS_APRV_RESN desc=\"책임자승인사유\" length=\"300\"></RSPS_APRV_RESN>\r\n" + 
+				"           </approveCodeList>\r\n" + 
+				"           <approveList desc=\"책임자승인 목록 시작\">\r\n" + 
+				"               <RSPS_APRV_DVSN_CODE desc=\"책임자승인구분코드\" length=\"2\"></RSPS_APRV_DVSN_CODE>\r\n" + 
+				"               <APRV_USER_ID desc=\"승인사용자ID\" length=\"9\">TEST00001</APRV_USER_ID>\r\n" + 
+				"               <APRV_TRMN_NO desc=\"승인단말번호\" length=\"8\"></APRV_TRMN_NO>\r\n" + 
+				"               <RSPS_TX_DVSN_CODE desc=\"책임자거래구분코드\" length=\"2\"></RSPS_TX_DVSN_CODE>\r\n" + 
+				"               <LGIN_YN desc=\"로그인여부\" length=\"1\"></LGIN_YN>\r\n" + 
+				"               <APRV_RQUT_MSG desc=\"승인요청메시지\" length=\"300\"></APRV_RQUT_MSG>\r\n" + 
+				"               <APRV_MEAN_CODE desc=\"승인수단코드\" length=\"1\"></APRV_MEAN_CODE>\r\n" + 
+				"               <APRV_RSLT_CODE desc=\"승인결과코드\" length=\"1\"></APRV_RSLT_CODE>\r\n" + 
+				"               <APRV_RSLT_MSG desc=\"승인결과메시지\" length=\"300\"></APRV_RSLT_MSG>\r\n" + 
+				"           </approveList>\r\n" + 
+				"           <MSG_MARK_DVSN_CODE desc=\"메시지표시구분코드\" length=\"1\"></MSG_MARK_DVSN_CODE>\r\n" + 
+				"           <messageList desc=\"메시지 목록 시작 (1~10)\">\r\n" + 
+				"               <MSG_CODE desc=\"메시지코드\" length=\"10\"></MSG_CODE>\r\n" + 
+				"               <MSG_CNTT desc=\"메시지내용\" length=\"300\"></MSG_CNTT>\r\n" + 
+				"               <MSRS_MSG_CNTT desc=\"조치메시지내용\" length=\"300\"></MSRS_MSG_CNTT>\r\n" + 
+				"               <ERR_PGM_NM desc=\"오류프로그램명\" length=\"100\"></ERR_PGM_NM>\r\n" + 
+				"               <ERR_PGM_LINE_NO desc=\"오류프로그램라인번호\" length=\"8\">0</ERR_PGM_LINE_NO>\r\n" + 
+				"           </messageList>\r\n" + 
+				"       </STD_COMMONHEADER_REQ>\r\n" + 
+				"<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n" +
+				"       <STD_DATAHEADER_REQ desc=\"표준전문-데이터헤더\">\r\n" + 
+				"           <terminalInfo desc=\"단말정보\">\r\n" + 
+				"               <SCRN_ID desc=\"화면ID\" length=\"10\"></SCRN_ID>\r\n" + 
+				"               <SCRN_CALL_NO desc=\"화면호출번호\" length=\"5\"></SCRN_CALL_NO>\r\n" + 
+				"               <CURY_RAMT desc=\"통화잔액\" length=\"15\">0</CURY_RAMT>\r\n" + 
+				"               <TRSF_RAMT desc=\"대체잔액\" length=\"15\">0</TRSF_RAMT>\r\n" + 
+				"               <OTBC_RAMT desc=\"타점권잔액\" length=\"15\">0</OTBC_RAMT>\r\n" + 
+				"               <TRSF_NSAM_YN desc=\"대체불일치여부\" length=\"1\"></TRSF_NSAM_YN>\r\n" + 
+				"               <PUSH_DVSN_CODE desc=\"Push구분코드\" length=\"1\">S</PUSH_DVSN_CODE>\r\n" + 
+				"           </terminalInfo>\r\n" + 
+				"           <noneFacingInfo desc=\"비대면정보\">\r\n" + 
+				"           </noneFacingInfo>\r\n" + 
+				"           <atmInfo desc=\"ATM정보\">\r\n" + 
+				"           </atmInfo>\r\n" + 
+				"           <callCenterInfo desc=\"콜센터정보\">\r\n" + 
+				"           </callCenterInfo>\r\n" + 
+				"           <externalInfo desc=\"대외정보\">\r\n" + 
+				"               <OUTR_INST_CODE desc=\"대외기관코드\" length=\"5\"></OUTR_INST_CODE>\r\n" + 
+				"               <OUTR_TX_OIWD_DVSN_CODE desc=\"대외거래당타발구분코드\" length=\"1\"></OUTR_TX_OIWD_DVSN_CODE>\r\n" + 
+				"           </externalInfo>\r\n" + 
+				"           <centerCutInfo desc=\"센터컷정보\">\r\n" + 
+				"               <CC_ID desc=\"센터컷ID\" length=\"9\"></CC_ID>\r\n" + 
+				"               <CC_PROC_YMD desc=\"센터컷처리일자\" length=\"8\"></CC_PROC_YMD>\r\n" + 
+				"               <CC_PROC_TMS desc=\"센터컷처리회차\" length=\"5\">0</CC_PROC_TMS>\r\n" + 
+				"               <CC_PROC_SQNU desc=\"센터컷처리일련번호\" length=\"9\">0</CC_PROC_SQNU>\r\n" + 
+				"               <CC_PROC_DVSN_CODE desc=\"센터컷처리구분코드\" length=\"2\"></CC_PROC_DVSN_CODE>\r\n" + 
+				"               <CC_PROC_RSLT_CODE desc=\"센터컷처리결과코드\" length=\"2\"></CC_PROC_RSLT_CODE>\r\n" + 
+				"           </centerCutInfo>\r\n" + 
+				"       </STD_DATAHEADER_REQ>\r\n";
+		
+		HashMap<String,Object> result = new HashMap<String,Object>();
+		result=getData(data);
+		//logger.debug(result);
+		
+	}
+	public static HashMap<String,Object> getData(String data) throws Exception{
+		HashMap<String,Object> vo = new HashMap<String,Object>();
+		List<String> splitData = xmlSplit(data);
+		for(String xmlData : splitData ) {
+			HashMap<String,Object> xmlRow = xmlParse(xmlData);
+			String name =(String)xmlRow.get("name");
+			List<HashMap<String,Object>> list = (List<HashMap<String,Object>>)xmlRow.get("list");
+			vo.put(name,list);
+		}
+		return vo;
+	}
+	private static List<String> xmlSplit(String data)throws Exception{
+
+		String xmlData = data;
+		String strData = "";		
+		ArrayList<String> sptXmlData = new ArrayList<String>();
+		int idx = xmlData.indexOf(XML_HEADER);
+		int startIdx = 0;
+		int endIdx = 0;
+		while ( idx  >= 0 ){
+			if(idx==0){
+				idx=xmlData.indexOf(XML_HEADER,1);
+				endIdx = idx-1;
+				if(idx==-1){
+					idx=xmlData.indexOf(XML_HEADER,0);
+					endIdx = xmlData.length();
+				}
+			}else{
+				startIdx = idx-1;
+				idx=xmlData.indexOf(XML_HEADER,idx);
+				
+				endIdx = idx-1;
+				if(idx==-1){
+					idx=xmlData.indexOf(XML_HEADER,startIdx);
+					endIdx = xmlData.length();
+					if(startIdx==idx){
+						strData = xmlData.substring(startIdx, endIdx);
+						if(strData.length()>0){
+							sptXmlData.add(strData);
+							//logger.debug(strData);
+						}
+						break;
+					}
+				}
+			}
+			idx++;
+			
+			strData = xmlData.substring(startIdx, endIdx);
+			if(strData.length()>0){
+				sptXmlData.add(strData);
+				//logger.debug(strData);
+			}
+		}
+
+		return sptXmlData;
+
+	}
+	private static HashMap<String,Object> xmlParse(String data) throws Exception{
+		HashMap<String,Object> vo = new HashMap<String,Object>();
+		
+    	InputStream is = null;
+    	try { 
+    		is = StringToStream(data,"utf-8");
+			SAXBuilder builder = new SAXBuilder();
+	        Document doc = builder.build(is);
+	
+	        Element format = doc.getRootElement();
+	        
+	        
+	        String name = format.getName();
+	        String desc = format.getAttributeValue("desc");
+	        
+	        List<HashMap<String,Object>> list = new ArrayList<HashMap<String,Object>>();
+	        list.addAll(xmlDataParse(format));
+	        vo.put("name",name);
+	        vo.put("desc",desc);
+	        vo.put("list", list);
+		}catch(Exception e){
+			throw new Exception("layout parsing error "+e.getMessage(),e);
+    	}finally{
+    		if (is != null){try{is.close();}catch(Exception e ){}}
+    	}
+    	return vo;
+		
+	}
+	private static List<HashMap<String,Object>> xmlDataParse(Element e) throws Exception {
+		List<HashMap<String,Object>> list = new ArrayList<HashMap<String,Object>>();
+
+        List<Element> items = e.getChildren();
+        for(Element el : items) {
+            HashMap<String,Object> item = new HashMap<String,Object>();
+
+            item.put("fieldName",el.getName());
+            item.put("korName",el.getAttributeValue("desc"));
+            item.put("dataLen", el.getAttributeValue("length"));
+            item.put("data",el.getTextTrim());
+            list.add(item);
+            if( el.getChildren() != null && el.getChildren().size() > 0 ) {
+            	list.addAll(xmlDataParse(el));
+            }
+        }  // end FOR
+		
+		return list;
+	}
+	private static InputStream StringToStream(String s, String encoding) throws UnsupportedEncodingException{
+		ByteArrayInputStream buffer = new ByteArrayInputStream(s.getBytes(encoding));
+		return buffer;
+	}
+
+}
+

src/main/java/com/eactive/eai/rms/onl/transaction/trackingchart/TrackingChartController.java

@@ -0,0 +1,455 @@
+package com.eactive.eai.rms.onl.transaction.trackingchart;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+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;
+import org.springframework.web.bind.annotation.PostMapping;
+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.login.SessionManager;
+import com.eactive.eai.rms.common.util.CamelCaseUtil;
+import com.eactive.eai.rms.common.vo.GridResponse;
+import com.eactive.eai.rms.common.vo.JsonPageVo;
+import com.eactive.eai.rms.onl.manage.rule.layout.LayoutManService;
+import com.eactive.eai.rms.onl.manage.rule.layout.ui.LayoutUI;
+import com.eactive.eai.rms.onl.manage.rule.layout.ui.LayoutUISearch;
+import com.eactive.eai.rms.onl.manage.rule.transform.TransformManService;
+import com.google.gson.Gson;
+
+/**
+ * <pre>
+ *     1. 기능 : 거래흐름도
+ * </pre>
+ *
+ * @author : music75
+ * @version : $Revision: 1.26.2.5 $
+ * @since : rts 1.0
+ */
+@SuppressWarnings("unchecked")
+@Controller
+public class TrackingChartController extends OnlBaseAnnotationController {
+
+	@Autowired
+	private TrackingChartService service;
+
+	@Autowired
+	private LayoutManService layoutservice;
+
+	@Autowired
+	private TransformManService transformManService;
+
+	@Autowired
+	@Qualifier("comboService")
+	private ComboService comboService;
+
+	@Autowired
+	private LayoutManService layoutManService;
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.view")
+	private String viewList(HttpServletRequest request, @RequestParam(value = "cmd", required = false) String cmd)
+			throws Exception {
+		if (cmd == null || "LIST".equals(cmd.toUpperCase())) {
+			cmd = "";
+		} else {
+			cmd = CamelCaseUtil.converCamelCase(cmd);
+		}
+		String path = request.getServletPath();
+		return path.split("[.]")[0] + cmd;
+	}
+
+	/**
+	 * @param request
+	 * @param response
+	 * @throws Exception
+	 */
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST")
+	private ModelAndView selectList(HttpServletRequest request, String searchName) throws Exception {
+
+		HashMap map = service.selectCodeGroupList(searchName);
+
+		Map resultMap = new HashMap();
+		resultMap.put("rows", map.get("list"));
+
+		ModelAndView modelAndView = new ModelAndView("jsonView", resultMap);
+		return modelAndView;
+
+	}
+
+	/**
+	 * @param request
+	 * @param response
+	 * @throws Exception
+	 */
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_POP")
+	private ModelAndView selectPopList(HttpServletRequest request, HttpServletResponse response, JsonPageVo pageVo,
+			@RequestParam HashMap<String, Object> paramMap) throws Exception {
+
+		HashMap map = service
+				.selectPopList(pageVo.getStartNum(), pageVo.getEndNum(), (String) paramMap.get("eaiSvcName"));
+
+		pageVo.setTotalCount((Integer) map.get("totalCount"));
+
+		Map resultMap = new HashMap();
+		resultMap.put("total", pageVo.getTotal()); // 전체 페이지수
+		resultMap.put("page", pageVo.getPage()); // 현재 페이지수
+		resultMap.put("records", pageVo.getTotalCount());// 전체 레코드건수
+		resultMap.put("rows", map.get("list"));
+
+		ModelAndView modelAndView = new ModelAndView("jsonView", resultMap);
+
+		return modelAndView;
+
+	}
+
+	/**
+	 * @param request
+	 * @param response
+	 * @throws Exception
+	 */
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=DETAIL")
+	public ModelAndView selectDetail(HttpServletRequest request, HttpServletResponse response, String key)
+			throws Exception {
+
+		HashMap<String, Object> map = service.selectDetail(key);
+
+		ModelAndView modelAndView = new ModelAndView("jsonView", map);
+
+		return modelAndView;
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_CHK_CNT")
+	public ModelAndView selectCntList(HttpServletRequest request, HttpServletResponse response, String transformData,
+			String eaiSvcName) throws Exception {
+		List mList = service.selectCntList(transformData, eaiSvcName);
+
+		HashMap map = new HashMap();
+		map.put("layout", mList);
+
+		ModelAndView modelAndView = new ModelAndView("jsonView", map);
+
+		return modelAndView;
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_ADAPTER_COMBO")
+	public ModelAndView selectAdapterCombo(HttpServletRequest request, HttpServletResponse response,
+			@RequestParam HashMap<String, Object> paramMap) throws Exception {
+
+		HashMap<String, Object> map = service.selectAdapterCombo(paramMap);
+		ModelAndView modelAndView = new ModelAndView("jsonView", map);
+		return modelAndView;
+	}
+
+	@PostMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_FIELD")
+	public ResponseEntity<Map<String, Object>> selectDetailLauout(String loutName) {
+		Map<String, Object> layoutDetailMap = layoutManService.selectDetail(loutName);
+		return ResponseEntity.ok(layoutDetailMap);
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_TRANSFORM_ITEM")
+	public ModelAndView transformItem(HttpServletRequest request, HttpServletResponse response, String cnvsnName,
+			String loutName) throws Exception {
+		List list = transformManService.selectTransformItems(cnvsnName, loutName);
+
+		HashMap map = new HashMap();
+		map.put("rows", list);
+
+		ModelAndView modelAndView = new ModelAndView("jsonView", map);
+		return modelAndView;
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_LAYOUT_ITEM")
+	public ModelAndView listLayoutItem(HttpServletRequest request, HttpServletResponse response, String loutName)
+			throws Exception {
+
+		List list = transformManService.selectLayoutItems(loutName);
+		HashMap map = new HashMap();
+		map.put("rows", list);
+		ModelAndView modelAndView = new ModelAndView("jsonView", map);
+		return modelAndView;
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=INSERT")
+	private String insert(HttpServletRequest request, HttpServletResponse response,
+			@RequestParam HashMap<String, Object> map, String transformData) throws Exception {
+
+		List forRld = service.insert(map, transformData);
+
+		// 인터페이스에 대해서만 동기화
+		reloadSync(map);
+
+		for (int i = 0; i < forRld.size(); i++) {
+			CommonCommand command = new CommonCommand("com.eactive.eai.agent.transformer.ReloadTransformCommand",
+					forRld.get(i));
+			agentUtilService.broadcast(command);
+		}
+		return null;
+
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=UPDATE")
+	private String update(HttpServletRequest request, HttpServletResponse response,
+			@RequestParam HashMap<String, Object> map, String transformData) throws Exception {
+
+		HashMap syncCnvsn = service.update(map, transformData);
+		List forRmv = (List) syncCnvsn.get("forRmv");
+		List forRld = (List) syncCnvsn.get("forRld");
+
+		reloadSync(map);
+		for (int i = 0; i < forRmv.size(); i++) {
+			CommonCommand command = new CommonCommand("com.eactive.eai.agent.transformer.RemoveTransformCommand",
+					forRmv.get(i));
+			agentUtilService.broadcast(command);
+		}
+		for (int i = 0; i < forRld.size(); i++) {
+			CommonCommand command = new CommonCommand("com.eactive.eai.agent.transformer.ReloadTransformCommand",
+					forRld.get(i));
+			agentUtilService.broadcast(command);
+		}
+		return null;
+
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=DELETE")
+	private String delete(HttpServletRequest request, HttpServletResponse response,
+			@RequestParam HashMap<String, Object> map, String eaiSvcName, String transformData) throws Exception {
+
+		Gson gson = new Gson();
+		HashMap[] list = gson.fromJson(transformData, HashMap[].class);
+
+		HashMap retMap = service.delete(eaiSvcName, transformData);
+
+		Boolean forSync = (Boolean) retMap.get("forSync");
+		List syncEaiSvcName = (List) retMap.get("syncEaiSvcName");
+
+		deleteSync(map);
+		// transform 삭제 동기화
+		if (forSync == true) {
+			for (int i = 0; i < list.length; i++) {
+				String cnvsnName = (String) list[i].get("cnvsnName");
+
+				CommonCommand command = new CommonCommand("com.eactive.eai.agent.transformer.RemoveTransformCommand",
+						cnvsnName);
+				agentUtilService.broadcast(command);
+			}
+			for (int i = 0, n = syncEaiSvcName.size(); i < n; i++) {
+				HashMap paramMap = new HashMap();
+				paramMap.put("eaiSvcName", syncEaiSvcName.get(i));
+				reloadSync(paramMap);
+
+			}
+		}
+		return null;
+
+	}
+
+	/**
+	 * @param request
+	 * @param response
+	 * @throws Exception
+	 */
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_DETAIL_COMBO")
+	public ModelAndView selectDetailCombo(HttpServletRequest request, HttpServletResponse response) throws Exception {
+
+		String userId = SessionManager.getUserId(request);
+		HashMap<String, Object> map = service.selectDetailCombo(userId);
+		ModelAndView modelAndView = new ModelAndView("jsonView", map);
+		return modelAndView;
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_LAYOUT")
+	public ResponseEntity<GridResponse<LayoutUI>> selectList(Pageable pageable, LayoutUISearch layoutUISearch) {
+
+		Page<LayoutUI> layoutUis = layoutservice.selectList(pageable, layoutUISearch);
+
+		return ResponseEntity.ok(new GridResponse<>(layoutUis));
+
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_LAYOUT_INIT_COMBO")
+	private ModelAndView selectList(HttpServletRequest request) throws Exception {
+		List<ComboVo> listInoutTypeCd = comboService.getFromCode("INOUT_TYPE");// EAI서버구분코드
+		Map resultMap = new HashMap();
+		resultMap.put("inoutTypeRows", listInoutTypeCd);
+
+		ModelAndView modelAndView = new ModelAndView("jsonView", resultMap);
+		return modelAndView;
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=LIST_INIT_COMBO")
+	public ModelAndView initCombo(HttpServletRequest request, HttpServletResponse response, String eaiSvcName)
+			throws Exception {
+
+		List<ComboVo> listFunction = comboService.getFromFunction();
+		List listTransform = transformManService.selectTransformForEaiSvcNameCombo(eaiSvcName);
+
+		Map resultMap = new HashMap();
+
+		resultMap.put("functionRows", listFunction);
+		resultMap.put("transformRows", listTransform);
+		ModelAndView modelAndView = new ModelAndView("jsonView", resultMap);
+		return modelAndView;
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=MAPPING")
+	private String mapping(HttpServletRequest request, HttpServletResponse response,
+			@RequestParam HashMap<String, Object> map, String gridData, String cnvsnName, String eaiSvcName)
+			throws Exception {
+
+		service.insertMapping(map, gridData, cnvsnName);
+
+		CommonCommand command = new CommonCommand("com.eactive.eai.agent.transformer.ReloadTransformCommand",
+				cnvsnName);
+		agentUtilService.broadcast(command);
+
+		return null;
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=UNMAPPING")
+	private String unmapping(HttpServletRequest request, HttpServletResponse response, String cnvsnName,
+			String eaiSvcName) throws Exception {
+
+		service.deleteMapping(cnvsnName);
+
+		CommonCommand command = new CommonCommand("com.eactive.eai.agent.transformer.RemoveTransformCommand",
+				cnvsnName);
+		agentUtilService.broadcast(command);
+
+		return null;
+
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=CLONE")
+	private String clone(HttpServletRequest request, HttpServletResponse response,
+			@RequestParam HashMap<String, Object> map, String transformData) throws Exception {
+
+		service.clone(map, transformData);
+
+		// 인터페이스에 대해서만 동기화
+		reloadSync(map);
+
+		return null;
+
+	}
+
+	/**
+	 * @param request
+	 * @param response
+	 * @throws Exception
+	 */
+
+	public void reloadSync(HashMap<String, Object> param) throws Exception {
+		logger.debug("--------------------------------------------------------------------------");
+		logger.info("- 동기화 처리 -------------------------------------------------------------");
+		StringBuffer result = new StringBuffer();
+
+		// 기존 정보 조회 및 확인
+		logger.debug("eaiSvcName : [" + param.get("eaiSvcName") + "]");
+
+//		result.append("-[내부표준메세지 초기화]-------------------");
+//		//HS04,HS05 내부표준전문
+//		String key = (String)param.get("bzwkSvcKeyName");
+//		if (key != null && !"".equals(key)){
+//			CommonCommand cmdHS = new CommonCommand("com.ext.eai.agent.stdmessage.ReloadSTDMessageCommand",key);
+//			agentUtilService.broadcast(cmdHS);
+//		}
+		result.append("---------------------------------------");
+
+		result.append("-[IF메세지 초기화]------------------------");
+		// HE01 EAI 메시지 공통부
+		String key = (String) param.get("eaiSvcName");
+		CommonCommand cmdHE01 = new CommonCommand("com.eactive.eai.agent.eaimessage.ReloadEAIMessageCommand", key);
+		;
+		agentUtilService.broadcast(cmdHE01);
+		result.append("---------------------------------------");
+
+		result.append("-[필드추출정보 초기화]---------------------");
+		// 메모리 정보 Reload
+		key = (String) param.get("eaiSvcName");
+		CommonCommand cmdFR03 = new CommonCommand("com.eactive.eai.agent.bizkey.ReloadBizKeyCommand", key);
+		;
+		agentUtilService.broadcast(cmdFR03);
+		logger.debug("--------------------------------------------------------------------------");
+		logger.info(result.toString());
+
+		/*
+		 * result.append("-[매핑정보 초기화]---------------------"); //메모리 정보 Reload key =
+		 * (String)param.get("cnvsnName"); CommonCommand cmdTR = new
+		 * CommonCommand("com.eactive.eai.agent.transformer.ReloadTransformCommand",key)
+		 * ; agentUtilService.broadcast(cmdTR); logger.debug(
+		 * "--------------------------------------------------------------------------")
+		 * ; logger.info(result.toString());
+		 */
+	}
+
+	public void deleteSync(HashMap<String, Object> param) throws Exception {
+		logger.debug("--------------------------------------------------------------------------");
+		logger.info("- 동기화 처리 -------------------------------------------------------------");
+		StringBuffer result = new StringBuffer();
+
+		// 기존 정보 조회 및 확인
+		logger.debug("eaiSvcName : [" + param.get("eaiSvcName") + "]");
+
+		result.append("-[내부표준메세지 초기화]-------------------");
+		// HS04,HS05 내부표준전문
+		String key = (String) param.get("bzwkSvcKeyName");
+		if (key != null && !"".equals(key)) {
+			CommonCommand cmdHS = new CommonCommand("com.eactive.eai.agent.stdmessage.RemoveSTDMessageCommand", key);
+			agentUtilService.broadcast(cmdHS);
+		}
+		result.append("---------------------------------------");
+
+		result.append("-[IF메세지 초기화]------------------------");
+		// HE01 EAI 메시지 공통부
+		key = (String) param.get("eaiSvcName");
+		CommonCommand cmdHE01 = new CommonCommand("com.eactive.eai.agent.eaimessage.RemoveEAIMessageCommand", key);
+		;
+		agentUtilService.broadcast(cmdHE01);
+		result.append("---------------------------------------");
+
+		result.append("-[필드추출정보 초기화]---------------------");
+		// 메모리 정보 Reload
+		key = (String) param.get("eaiSvcName");
+		CommonCommand cmdFR03 = new CommonCommand("com.eactive.eai.agent.bizkey.RemoveBizKeyCommand", key);
+		;
+		agentUtilService.broadcast(cmdFR03);
+		logger.debug("--------------------------------------------------------------------------");
+		logger.info(result.toString());
+
+		/*
+		 * result.append("-[매핑추출정보 초기화]---------------------"); //메모리 정보 Reload key =
+		 * (String)param.get("cnvsnName"); CommonCommand cmdTR = new
+		 * CommonCommand("com.eactive.eai.agent.transformer.RemoveTransformCommand",key)
+		 * ;; agentUtilService.broadcast(cmdTR); logger.debug(
+		 * "--------------------------------------------------------------------------")
+		 * ; logger.info(result.toString());
+		 */
+	}
+
+	@RequestMapping(value = "/onl/transaction/tracking/dbTrackingChartMan.json", params = "cmd=CHK_IF")
+	private String checkInterface(HttpServletRequest request, HttpServletResponse response, String eaiSvcName)
+			throws Exception {
+
+		String chk = service.checkInterface(eaiSvcName);
+
+		return chk;
+
+	}
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/trackingchart/TrackingChartDao.java

@@ -0,0 +1,98 @@
+package com.eactive.eai.rms.onl.transaction.trackingchart;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.stereotype.Repository;
+
+import com.eactive.eai.rms.common.base.SqlMapClientTemplateDao;
+
+/**
+* 1. 기능 : 코드정보를 관리하는 코드 정보 테이블에 대한 Data Access Object 이다. 
+*         업무데이터로 부터 아래와 같은 특정 필드를 추출하기 위한 어댑터 정보 테이블에
+*         대한 Data Access Object 이다.
+* 2. 처리 개요 :  코드 정보 테이블에 대한 Create, Read, Update, Delete 를 처리한다.
+*
+* 3. 주의사항
+*
+* @author  :
+* @version : v 1.0.0
+* @see : CodeManQuery.java
+* @since   :
+*/
+@Repository
+public class TrackingChartDao extends SqlMapClientTemplateDao {
+
+    /**
+     * Default Logger
+     */
+
+    
+	// CODE GROUP LIST
+    public List selectCodeGroupList(HashMap param) throws Exception {
+    	return template.queryForList("CodeMan.selectCodeGroupList", param);
+    }
+    public List<Map<String, Object>> selectPopList(HashMap param) throws Exception {
+    	return (List<Map<String, Object>>)template.queryForList("DbTrackingChart.selectSubList", param);
+    } 
+	public int selectPopListCount(HashMap<String, Object> param) throws Exception {
+
+		int totalcnt = (Integer)template.queryForObject("DbTrackingChart.selectSubListCount", param);
+
+    	return totalcnt;
+    }	  
+	public HashMap<String, Object>  selectDetail(String eaiSvcName) throws Exception {
+		HashMap<String, Object> param = new HashMap<String, Object>();
+		param.put("eaiSvcName", eaiSvcName);
+		
+     	List detailList  = template.queryForList("DbTrackingChart.selectDetail" , param);
+		HashMap detail = new HashMap();
+		String bzwkSvcKeyName = "";
+		if(detailList.size()>0){
+			for(int i=0; i<detailList.size(); i++){
+				detail = (HashMap)detailList.get(i);
+				if(i==0){
+					bzwkSvcKeyName+=detail.get("BZWKSVCKEYNAME");
+				}else{
+					bzwkSvcKeyName+=","+detail.get("BZWKSVCKEYNAME");
+				}
+				detail.put("BZWKSVCKEYNAME",bzwkSvcKeyName);
+			}
+			return detail;
+		}else{
+			return  (HashMap<String,Object>) template.queryForObject("DbTrackingChart.selectDetail" , param);
+		}
+			
+    }
+    public List<Map<String, Object>> selectSharedTrans(HashMap param) throws Exception {
+    	return (List<Map<String, Object>>)template.queryForList("DbTrackingChart.selectSharedTrans", param);
+    } 
+	
+	// Transform 
+	public void updateTransfromEaiSvcName(HashMap map) {
+        this.template.update("DbTrackingChart.updateTransfromEaiSvcName",map);
+    }   
+ 
+    public void insertTransform(HashMap map) {
+        this.template.insert("DbTrackingChart.insertTransform",map);
+    }  
+    
+    public void insertTransformSourceResult(HashMap map) {
+        this.template.insert("DbTrackingChart.insertTransformSourceResult",map);
+    }   
+    public void deleteTransform(HashMap map) {
+        this.template.delete("DbTrackingChart.deleteTransform",map);
+    }
+
+    public void deleteTransformSourceResult(HashMap map) {
+        this.template.delete("DbTrackingChart.deleteTransformSourceResult",map);
+    }
+    public void insertTransformItem(HashMap map) {
+        this.template.insert("DbTrackingChart.insertTransformItem",map);
+    }   
+    public void deleteTransformItem(HashMap map) {
+        this.template.delete("DbTrackingChart.deleteTransformItem",map);
+
+    }
+}

src/main/java/com/eactive/eai/rms/onl/transaction/trackingchart/TrackingChartService.java

@@ -0,0 +1,725 @@
+package com.eactive.eai.rms.onl.transaction.trackingchart;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+//import org.codehaus.jackson.map.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+import com.eactive.eai.rms.common.acl.user.BizDao;
+import com.eactive.eai.rms.common.base.OnlBaseService;
+import com.eactive.eai.rms.common.combo.ComboService;
+import com.eactive.eai.rms.common.combo.ComboVo;
+import com.eactive.eai.rms.common.util.StringUtils;
+import com.eactive.eai.rms.onl.common.exception.BizException;
+import com.eactive.eai.rms.onl.manage.adapter.adapter.AdapterDao;
+import com.eactive.eai.rms.onl.manage.rule.transform.TransformDao;
+import com.eactive.eai.rms.onl.transaction.extnl.InterfaceManService;
+import com.eactive.eai.rms.onl.transaction.extnl.ui.InterfaceUI;
+import com.google.gson.Gson;
+
+@Service("trackingChartService")
+public class TrackingChartService extends OnlBaseService {
+
+	@Autowired
+	@Qualifier("trackingChartDao")
+	private TrackingChartDao dao;
+
+	@Autowired
+	@Qualifier("transformDao")
+	private TransformDao transformDao;
+
+	@Autowired
+	@Qualifier("bizDao")
+	private BizDao bizDao;
+
+	@Autowired
+	@Qualifier("adapterDao")
+	private AdapterDao adapterDao;
+
+	@Autowired
+	private ComboService comboService;
+
+	@Autowired
+	private InterfaceManService interfaceManService;
+
+	// CODE GROUP LIST
+	public HashMap selectCodeGroupList(String searchName) throws Exception {
+		HashMap paramMap = new HashMap();
+		// 검색 조건
+		paramMap.put("searchName", searchName);
+
+		List list = dao.selectCodeGroupList(paramMap);
+		HashMap map = new HashMap();
+
+		map.put("list", list);
+		return map;
+	}
+
+	public HashMap selectPopList(int startNum, int endNum, String eaiSvcName) throws Exception {
+
+		HashMap<String, Object> paramMap = new HashMap<String, Object>();
+		paramMap.put("eaiSvcName", eaiSvcName);
+		// 전체 목록수 얻기
+		int totalCount = dao.selectPopListCount(paramMap);
+
+		paramMap.put("startNum", startNum);// 시작 record
+		paramMap.put("endNum", endNum);// 끝 record
+
+		List<Map<String, Object>> list = dao.selectPopList(paramMap);
+		HashMap<String, Object> map = new HashMap<String, Object>();
+
+		map.put("totalCount", totalCount);
+		map.put("list", list);
+
+		return map;
+	}
+
+	public HashMap<String, Object> selectDetail(String eaiSvcName) throws Exception {
+
+		HashMap<String, Object> detail = dao.selectDetail(eaiSvcName);
+
+		String cnvsnName = (String) detail.get("CHNGMSGIDNAME1");
+		String bascRspn = (String) detail.get("BASCRSPNSCHNGMSGIDNAME1");
+		String errRspn = (String) detail.get("ERRRSPNSCHNGMSGIDNAME1");
+
+		HashMap paramMap = new HashMap();
+		paramMap.put("cnvsnName", cnvsnName);
+		List transform1 = transformDao.selectTransformSourceResult(paramMap);
+
+		paramMap.put("cnvsnName", bascRspn);
+		List transform2 = transformDao.selectTransformSourceResult(paramMap);
+
+		paramMap.put("cnvsnName", errRspn);
+		List transform3 = transformDao.selectTransformSourceResult(paramMap);
+
+		List transform = new ArrayList();
+		transform.add(transform1);
+		transform.add(transform2);
+		transform.add(transform3);
+
+		HashMap<String, Object> map = new HashMap<String, Object>();
+
+		map.put("detail", detail);
+		map.put("transform", transform);
+
+		return map;
+
+	}
+
+	public HashMap selectAdapterCombo(HashMap paramMap) throws Exception {
+		List adapter = adapterDao.selectListCombo(paramMap);
+
+		HashMap map = new HashMap();
+
+		map.put("adapter", adapter);
+		return map;
+	}
+
+	public HashMap selectDetailCombo(String userId) throws Exception {
+		HashMap paramMap = new HashMap();
+		paramMap.put("userId", userId);
+
+		// 업무구분
+		List listBiz = bizDao.selectUserBizCodes(paramMap);
+
+		// 당타발구분
+		List<ComboVo> listIo = comboService.getFromCode("IO_TYPE");
+		// 전문요청구분
+		List<ComboVo> listReqRes = comboService.getFromCode("REQRES_TYPE");
+		// 송수신방법
+		List<ComboVo> listSyncAsync = comboService.getFromCode("SYNCASYNC_TYPE");
+
+		// 거래흐름(INBOUND);
+		paramMap = new HashMap();
+		paramMap.put("adptrIoDstcd", "IN");
+		List listFrom = adapterDao.selectListCombo(paramMap);
+		// 거래흐름(OUTBOUND);
+		paramMap = new HashMap();
+		paramMap.put("adptrIoDstcd", "OU");
+		List listTo = adapterDao.selectListCombo(paramMap);
+		// 거래흐름(ASBOUND);
+		paramMap = new HashMap();
+		paramMap.put("adptrIoDstcd", "OU");
+		paramMap.put("asyncDstCd", "As");
+		List listExt = adapterDao.selectListCombo(paramMap);
+
+		HashMap map = new HashMap();
+
+		map.put("bizList", listBiz);
+		map.put("ioList", listIo);
+		map.put("reqResList", listReqRes);
+		map.put("syncAsyncList", listSyncAsync);
+		map.put("fromList", listFrom);
+		map.put("toList", listTo);
+		map.put("extList", listExt);
+
+		return map;
+	}
+
+	public List insert(HashMap<String, Object> map, String transformData) throws Exception {
+
+		// interface insert;
+		// interfaceService.insert(map);
+		List<String> syncCnvsnForRld = new ArrayList(); // 재로딩
+
+		HashMap detail = dao.selectDetail((String) map.get("eaiSvcName"));
+		if (detail != null)
+			throw new BizException("중복된 인터페이스입니다.");
+		// 2.등록
+		ObjectMapper objectMapper = new ObjectMapper();
+		InterfaceUI interfaceUI = objectMapper.convertValue(map, InterfaceUI.class);
+
+		interfaceManService.createInterfaceJummun(interfaceUI);
+
+		Gson gson = new Gson();
+		HashMap[] list = gson.fromJson(transformData, HashMap[].class);
+
+		HashMap paramMap = new HashMap();
+		for (int i = 0; i < list.length; i++) {
+			String cnvsnName = (String) list[i].get("cnvsnName");
+			String cnvsnDesc = (String) list[i].get("cnvsnDesc");
+			String loutTarget = (String) list[i].get("loutTarget");
+			String loutSource = (String) list[i].get("loutSource");
+			String cnvsnType = null;
+			String chngEonot = null;
+
+			if (!"".equals(cnvsnName) && cnvsnName != null) {
+				chngEonot = "1";
+				cnvsnType = (String) list[i].get("cnvsnType");
+				/*
+				 * if("ASYN".equals((String)map.get("svcMotivUseDstcd")) ){ cnvsnType =
+				 * (String)list[i].get("cnvsnType"); }else{ cnvsnType =
+				 * cnvsnName.substring(cnvsnName.lastIndexOf("_")+1);
+				 * 
+				 * }
+				 */
+
+				paramMap = new HashMap();
+				paramMap.put("eaiSvcName", map.get("eaiSvcName"));
+				paramMap.put("cnvsnName", list[i].get("cnvsnName"));
+				paramMap.put("cnvsnType", cnvsnType);
+				paramMap.put("chngEonot", chngEonot);// 0.미사용 1.사용
+
+				// 1.EAI Message에 셋팅
+				dao.updateTransfromEaiSvcName(paramMap);
+
+				paramMap = new HashMap();
+
+				// 2. TR01,TR02 삭제 및 등록
+
+				paramMap.put("cnvsnName", cnvsnName);
+				paramMap.put("cnvsnDesc", cnvsnDesc);
+				paramMap.put("eaiSevrDstcd", map.get("eaiSevrDstcd"));
+				paramMap.put("useYn", 1);
+
+				dao.deleteTransform(paramMap);
+				dao.insertTransform(paramMap);
+
+				List oldLoutNames = transformDao.selectTransformSourceResult(paramMap);
+				String oldLoutSrc = null;
+				String oldLoutTgt = null;
+
+				// 2-1.SRC 등록
+				// String srcLayoutName
+				// =StringUtils.split((String)map.get("layoutMappingName"),",")[i];
+
+				paramMap.put("loutName", loutSource);
+				paramMap.put("sourcRsultDstcd", "SRC_LAYOUT");
+				dao.insertTransformSourceResult(paramMap);
+
+				// 2-2.TGT 등록
+				paramMap.put("loutName", loutTarget);
+				paramMap.put("sourcRsultDstcd", "TGT_LAYOUT");
+				dao.insertTransformSourceResult(paramMap);
+
+				for (int j = 0; j < oldLoutNames.size(); j++) {
+					HashMap t = (HashMap) oldLoutNames.get(j);
+					if ("SRC_LAYOUT".equals(t.get("SOURCRSULTDSTCD")))
+						oldLoutSrc = (String) t.get("LOUTNAME");
+					if ("TGT_LAYOUT".equals(t.get("SOURCRSULTDSTCD")))
+						oldLoutTgt = (String) t.get("LOUTNAME");
+
+				}
+
+				if (!loutSource.equals(oldLoutSrc) || !loutTarget.equals(oldLoutTgt)) {
+					paramMap = new HashMap();
+					paramMap.put("cnvsnName", cnvsnName);
+					dao.deleteTransformItem(paramMap);
+					// syncCnvsn.add(oldCnvsnName);
+
+				}
+				syncCnvsnForRld.add(cnvsnName);
+			}
+
+		}
+
+		return syncCnvsnForRld;
+
+	}
+
+	// CODE UPDATE
+	public HashMap update(HashMap<String, Object> map, String transformData) throws Exception {
+
+		List<String> syncCnvsnForRmv = new ArrayList(); // 삭제되는 cnvsnName 저장
+		List<String> syncCnvsnForRld = new ArrayList(); // 재로딩
+		Gson gson = new Gson();
+		HashMap[] list = gson.fromJson(transformData, HashMap[].class);
+		HashMap<String, Object> detail = dao.selectDetail((String) map.get("eaiSvcName"));
+
+		HashMap paramMap = new HashMap();
+
+		// Pre value 추출
+		String oldcnvsn = (String) detail.get("CHNGMSGIDNAME1");
+		String oldBasRspn = (String) detail.get("BASCRSPNSCHNGMSGIDNAME1");
+		String oldErrRspn = (String) detail.get("ERRRSPNSCHNGMSGIDNAME1");
+		if (oldcnvsn == null)
+			oldcnvsn = "";
+		if (oldBasRspn == null)
+			oldBasRspn = "";
+		if (oldErrRspn == null)
+			oldErrRspn = "";
+
+		List<String> oldcnvsnNames = new ArrayList();
+		oldcnvsnNames.add(oldcnvsn);
+		if (!"ASYN".equals((String) map.get("svcMotivUseDstcd")))
+			oldcnvsnNames.add(oldBasRspn);
+		oldcnvsnNames.add(oldErrRspn);
+
+		// 인터페이스 초기화 및 저장
+		ObjectMapper objectMapper = new ObjectMapper();
+		InterfaceUI interfaceUI = objectMapper.convertValue(map, InterfaceUI.class);
+		interfaceManService.createInterfaceJummun(interfaceUI);
+		// System.out.println("INTERFACE_UPDATED");
+		for (int i = 0; i < list.length; i++) { // Asyn 1~2 , Sync 1~3
+			String cnvsnName = StringUtils.getStringValue((String) list[i].get("cnvsnName"), "");
+			String oldCnvsnName = StringUtils.getStringValue((String) oldcnvsnNames.get(i), "");
+			String cnvsnDesc = (String) list[i].get("cnvsnDesc");
+			String loutTarget = (String) list[i].get("loutTarget");
+			String loutSource = (String) list[i].get("loutSource");
+
+			String cnvsnType = null;
+			String chngEonot = null;
+
+			if ("".equals(cnvsnName) || cnvsnName == null) {
+				chngEonot = "0";
+				cnvsnName = "";
+			} else {
+				chngEonot = "1";
+			}
+			cnvsnType = (String) list[i].get("cnvsnType");
+			/*
+			 * if("ASYN".equals((String)map.get("svcMotivUseDstcd")) ){ cnvsnType =
+			 * (String)list[i].get("cnvsnType"); }else{ if(cnvsnName == null ||
+			 * "".equals(cnvsnName)){ if("".equals(oldCnvsnName) || oldCnvsnName == null){
+			 * continue; }else{ cnvsnType =
+			 * oldCnvsnName.substring(oldCnvsnName.lastIndexOf("_")+1); } }else{ cnvsnType =
+			 * cnvsnName.substring(cnvsnName.lastIndexOf("_")+1); } }
+			 */
+
+			paramMap = new HashMap();
+			paramMap.put("eaiSvcName", map.get("eaiSvcName"));
+			paramMap.put("cnvsnName", cnvsnName);
+			paramMap.put("cnvsnType", cnvsnType);
+			paramMap.put("chngEonot", chngEonot);// 0.미사용 1.사용
+			paramMap.put("eaiSevrDstcd", map.get("eaiSevrDstcd"));
+			paramMap.put("useYn", 1);
+			// 1.EAI Message에 셋팅
+			if (cnvsnType != null && !"".equals(cnvsnType))
+				dao.updateTransfromEaiSvcName(paramMap);
+
+			// 2. TR01,TR02 삭제 및 등록
+			paramMap = new HashMap();
+			paramMap.put("searchCnvsnName", oldCnvsnName); // 기존
+			int cnt = transformDao.selectListCount(paramMap);
+			if (!cnvsnName.equals(oldCnvsnName))
+				cnt = cnt + 1; // 다르면 이미 HE02 업데이트로 cnt가 -1 된 상태이므로 아래 조건문 비교를 위해 +1
+			if ("".equals(oldCnvsnName))
+				cnt = 0; // oldCnvsnName이 ""이면 전체 조회가 되므로 Cnt 판별이 어려우므로 0으로 처리
+
+			boolean owned = oldCnvsnName.indexOf((String) map.get("eaiSvcName")) > -1 ? true : false;
+			if (cnt < 2)
+				owned = true; // cnt <2 조건은 own Data가 이미 삭제된 상태에서 처리대상 데이터가 유일하게 가지고 있는 데이터 이므로 조건에 포함
+
+			// owned는 삭제 처리에만 해당
+
+			if ("".equals(cnvsnName) || cnvsnName == null) { // 빈칸이면 삭제로 본다.
+				if (!"".equals(oldCnvsnName)) { // 기존 데이터가 있다면 // HE02에서 가져온 값 //TR01 또는 TR02의 값과 별개
+					if (owned == true) {
+						paramMap = new HashMap();
+						paramMap.put("cnvsnName", oldCnvsnName);
+						// 공유되는 변환코드 링크 끊기 To HE02
+						List<Map<String, Object>> sharedTrans = dao.selectSharedTrans(paramMap);
+
+						for (int j = 0, n = sharedTrans.size(); j < n; j++) {
+
+							Map m = sharedTrans.get(j);
+							// String mCnvsnName = (String)m.get("CNVSNNAME");
+							String mCnvsnType = (String) m.get("CNVSNTYPE");
+							String mEaiSvcName = (String) m.get("EAISVCNAME");
+
+							if (mCnvsnType != null && !"".equals(mCnvsnType)) {
+								HashMap mParam = new HashMap();
+								mParam.put("cnvsnName", "");
+								mParam.put("eaiSvcName", mEaiSvcName);
+								mParam.put("cnvsnType", mCnvsnType);
+								mParam.put("chngEonot", "0");// 0.미사용 1.사용
+								dao.updateTransfromEaiSvcName(mParam);
+							}
+						}
+
+						paramMap = new HashMap();
+						paramMap.put("cnvsnName", oldCnvsnName);
+
+						dao.deleteTransform(paramMap);
+						dao.deleteTransformSourceResult(paramMap);
+						dao.deleteTransformItem(paramMap);
+
+						syncCnvsnForRmv.add(oldCnvsnName);
+					}
+				}
+			} else {
+				if ("".equals(oldCnvsnName) || oldCnvsnName == null)
+					oldCnvsnName = cnvsnName;
+
+				if (owned || cnvsnName.equals(oldCnvsnName)) {
+					paramMap = new HashMap();
+					paramMap.put("cnvsnName", oldCnvsnName);
+					dao.deleteTransform(paramMap);
+
+				} else {
+					paramMap = new HashMap();
+					paramMap.put("cnvsnName", cnvsnName);
+					dao.deleteTransform(paramMap);
+				}
+
+				paramMap = new HashMap();
+				paramMap.put("cnvsnName", cnvsnName);
+				paramMap.put("cnvsnDesc", cnvsnDesc);
+				paramMap.put("eaiSevrDstcd", map.get("eaiSevrDstcd"));
+				paramMap.put("useYn", 1);
+
+				dao.insertTransform(paramMap);
+
+				// update 될 cnvsn DB 정보를 불러온다
+				List oldLoutNames = transformDao.selectTransformSourceResult(paramMap);
+				String oldLoutSrc = null;
+				String oldLoutTgt = null;
+
+				for (int j = 0; j < oldLoutNames.size(); j++) {
+					HashMap t = (HashMap) oldLoutNames.get(j);
+					if ("SRC_LAYOUT".equals(t.get("SOURCRSULTDSTCD")))
+						oldLoutSrc = (String) t.get("LOUTNAME");
+					if ("TGT_LAYOUT".equals(t.get("SOURCRSULTDSTCD")))
+						oldLoutTgt = (String) t.get("LOUTNAME");
+
+				}
+
+				// TR02 삭제
+				if (owned || cnvsnName.equals(oldCnvsnName)) {
+					paramMap = new HashMap();
+					paramMap.put("cnvsnName", oldCnvsnName);
+					dao.deleteTransformSourceResult(paramMap);
+				} else {
+					paramMap = new HashMap();
+					paramMap.put("cnvsnName", cnvsnName);
+					dao.deleteTransformSourceResult(paramMap);
+				}
+
+				paramMap = new HashMap();
+				paramMap.put("cnvsnName", cnvsnName);
+
+				// 2-1.SRC 등록
+				paramMap.put("loutName", loutSource);
+				paramMap.put("sourcRsultDstcd", "SRC_LAYOUT");
+				dao.insertTransformSourceResult(paramMap);
+
+				// 2-2.TGT 등록
+				paramMap.put("loutName", loutTarget);
+				paramMap.put("sourcRsultDstcd", "TGT_LAYOUT");
+				dao.insertTransformSourceResult(paramMap);
+
+				// 3. TR03 삭제
+				if (!cnvsnName.equals(oldCnvsnName) || !loutSource.equals(oldLoutSrc)
+						|| !loutTarget.equals(oldLoutTgt)) {
+					if (!"".equals(oldCnvsnName)) {
+						if (owned) {
+							paramMap = new HashMap();
+							paramMap.put("cnvsnName", oldCnvsnName);
+							dao.deleteTransformItem(paramMap);
+						}
+					}
+				}
+
+				if (owned) {
+					syncCnvsnForRmv.add(oldCnvsnName);
+				}
+				syncCnvsnForRld.add(cnvsnName);
+			}
+
+		} // end for loop
+
+		HashMap syncCnvsn = new HashMap();
+		syncCnvsn.put("forRmv", syncCnvsnForRmv);
+		syncCnvsn.put("forRld", syncCnvsnForRld);
+		return syncCnvsn;
+
+	}
+
+	// CODE DELETE
+	public HashMap delete(String eaiSvcName, String transformData) throws Exception {
+		List<String> syncEaiSvcName = new ArrayList();
+		boolean forSync = false;
+		// Gson gson = new Gson();
+		// HashMap[] list = gson.fromJson(transformData, HashMap[].class);
+
+		HashMap<String, Object> detail = dao.selectDetail(eaiSvcName);
+		// Pre value 추출
+		String oldcnvsn = (String) detail.get("CHNGMSGIDNAME1");
+		String oldBasRspn = (String) detail.get("BASCRSPNSCHNGMSGIDNAME1");
+		String oldErrRspn = (String) detail.get("ERRRSPNSCHNGMSGIDNAME1");
+		if (oldcnvsn == null)
+			oldcnvsn = "";
+		if (oldBasRspn == null)
+			oldBasRspn = "";
+		if (oldErrRspn == null)
+			oldErrRspn = "";
+
+		List<String> oldcnvsnNames = new ArrayList();
+		oldcnvsnNames.add(oldcnvsn);
+		oldcnvsnNames.add(oldBasRspn);
+		oldcnvsnNames.add(oldErrRspn);
+		try {
+			for (int i = 0; i < oldcnvsnNames.size(); i++) {
+				// String cnvsnName = (String)list[i].get("cnvsnName");
+				String cnvsnName = (String) oldcnvsnNames.get(i);
+				HashMap paramMap = new HashMap();
+				paramMap.put("searchCnvsnName", cnvsnName); // 기존
+				int cnt = transformDao.selectListCount(paramMap);
+
+				boolean owned = false;
+				if (cnvsnName.indexOf(eaiSvcName) > -1 || cnt < 2)
+					owned = true;
+
+				paramMap = new HashMap();
+				paramMap.put("cnvsnName", cnvsnName);
+
+				if (owned) {
+
+					// 공유되는 변환코드 삭제 To HE02
+					List<Map<String, Object>> sharedTrans = dao.selectSharedTrans(paramMap);
+
+					for (int j = 0, n = sharedTrans.size(); j < n; j++) {
+						Map m = sharedTrans.get(j);
+						// String mCnvsnName = (String)m.get("CNVSNNAME");
+						String mCnvsnType = (String) m.get("CNVSNTYPE");
+						String mEaiSvcName = (String) m.get("EAISVCNAME");
+
+						HashMap mParam = new HashMap();
+						mParam.put("cnvsnName", "");
+						mParam.put("eaiSvcName", mEaiSvcName);
+						mParam.put("cnvsnType", mCnvsnType);
+						mParam.put("chngEonot", "0");// 0.미사용 1.사용
+						dao.updateTransfromEaiSvcName(mParam);
+						syncEaiSvcName.add(mEaiSvcName);
+					}
+
+					// 1.delete transform //TR01 삭제
+					dao.deleteTransform(paramMap);
+					// 2.delete transform //TR02 삭제
+					dao.deleteTransformSourceResult(paramMap);
+					// 3.delete transform //TR03 삭제
+					dao.deleteTransformItem(paramMap);
+
+					// paramMap = new HashMap();
+
+					forSync = true;
+				}
+			}
+		} catch (Exception e) {
+
+			logger.error("CODE DELETE error", e);
+
+		}
+
+		// 4. 인터페이스 삭제
+		InterfaceUI interfaceUI = new InterfaceUI();
+		interfaceUI.setEaiSvcName(eaiSvcName);
+		interfaceManService.delete(interfaceUI);
+
+		HashMap retMap = new HashMap();
+		retMap.put("forSync", new Boolean(forSync));
+		retMap.put("syncEaiSvcName", syncEaiSvcName);
+		return retMap;
+
+	}
+
+	public void insertMapping(HashMap<String, Object> map, String gridData, String cnvsnName) throws Exception {
+
+		HashMap map1 = new HashMap();
+		map1.put("cnvsnName", map.get("cnvsnName"));
+		map1.put("cnvsnDesc", map.get("cnvsnDesc"));
+		// TR01
+		// ------------------------ INTERFACE 업데이트 시 자동업데이트 되므로 삭제 ---------//
+		// transformDao.deleteTransform(map1);
+		// transformDao.insert(map1);
+		// System.out.println(map1);
+		/*
+		 * //TR02 transformDao.deleteTransformSourceResult(map);
+		 * 
+		 * map1.put("loutName", map.get("srcLayout")); map1.put("sourcRsultDstcd",
+		 * "SRC_LAYOUT"); transformDao.insertTransformSourceResult(map1);
+		 * 
+		 * //2-2.TGT 등록 map1.put("loutName", map.get("tgtLayout"));
+		 * map1.put("sourcRsultDstcd", "TGT_LAYOUT");
+		 * transformDao.insertTransformSourceResult(map1);
+		 */
+
+		Gson gson = new Gson();
+		HashMap[] list = gson.fromJson(gridData, HashMap[].class);
+
+		HashMap<String, Object> paramMap = new HashMap();
+
+		paramMap.put("cnvsnName", cnvsnName);
+		dao.deleteTransformItem(paramMap);
+		for (int i = 0; i < list.length; i++) {
+			paramMap.put("cnvsnCmdName", list[i].get("CNVSNCMDNAME"));
+			paramMap.put("cnvsnRsultItemPathName", list[i].get("CNVSNRSULTITEMPATHNAME"));
+			paramMap.put("cnvsnItemBascVal", StringUtils.getStringValue(list[i].get("CNVSNITEMBASCVAL"), ""));
+			paramMap.put("cnvsnItemSerno", list[i].get("CNVSNITEMSERNO"));
+
+			dao.insertTransformItem(paramMap);
+		}
+
+	}
+
+	public void deleteMapping(String cnvsnName) throws Exception {
+		HashMap<String, Object> paramMap = new HashMap();
+
+		paramMap.put("cnvsnName", cnvsnName);
+		dao.deleteTransformItem(paramMap);
+
+	}
+
+	public void clone(HashMap<String, Object> map, String transformData) throws Exception {
+		String newEaiSvcName = (String) map.get("newEaiSvcName");
+		String newEaiTranName = newEaiSvcName.substring(0, newEaiSvcName.length() - 2);
+
+		map.put("eaiSvcName", newEaiSvcName);
+		map.put("eaiTranName", newEaiTranName);
+		map.put("bzwkSvcKeyName", newEaiTranName);
+		HashMap detail = dao.selectDetail((String) map.get("eaiSvcName"));
+		if (detail != null)
+			throw new Exception("중복된 인터페이스입니다.");
+		ObjectMapper objectMapper = new ObjectMapper();
+		InterfaceUI interfaceUI = objectMapper.convertValue(map, InterfaceUI.class);
+
+		// 2.등록
+		interfaceManService.createInterfaceJummun(interfaceUI);
+
+		Gson gson = new Gson();
+		HashMap[] list = gson.fromJson(transformData, HashMap[].class);
+
+		HashMap paramMap = new HashMap();
+		for (int i = 0; i < list.length; i++) {
+			String cnvsnName = (String) list[i].get("cnvsnName");
+			// String cnvsnDesc = (String)list[i].get("cnvsnDesc");
+			// String loutTarget = (String)list[i].get("loutTarget");
+			String cnvsnType = null;
+			String chngEonot = null;
+
+			if (!"".equals(cnvsnName) && cnvsnName != null) {
+				chngEonot = "1";
+				cnvsnType = (String) list[i].get("cnvsnType");
+				/*
+				 * if("ASYN".equals((String)map.get("svcMotivUseDstcd")) ){ cnvsnType =
+				 * (String)list[i].get("cnvsnType"); }else{ cnvsnType =
+				 * cnvsnName.substring(cnvsnName.lastIndexOf("_")+1);
+				 * 
+				 * }
+				 */
+
+				paramMap = new HashMap();
+				paramMap.put("eaiSvcName", map.get("eaiSvcName"));
+				paramMap.put("cnvsnName", list[i].get("cnvsnName"));
+				paramMap.put("cnvsnType", cnvsnType);
+				paramMap.put("chngEonot", chngEonot);// 0.미사용 1.사용
+
+				// 1.EAI Message에 셋팅
+				dao.updateTransfromEaiSvcName(paramMap);
+			}
+
+		}
+
+	}
+
+	public String checkInterface(String eaiSvcName) throws Exception {
+
+		HashMap<String, Object> paramMap = new HashMap();
+		paramMap.put("eaiSvcName", eaiSvcName);
+		int totalCount = dao.selectPopListCount(paramMap);
+
+		if (totalCount < 1)
+			return "N";
+		else
+			return "Y";
+
+	}
+
+	public List selectCntList(String transformData, String eaiSvcName) throws Exception {
+
+		Gson gson = new Gson();
+		HashMap[] list = gson.fromJson(transformData, HashMap[].class);
+		List mList = new ArrayList();
+		// List oList = new ArrayList();
+
+		HashMap<String, Object> detail = dao.selectDetail(eaiSvcName);
+		// Pre value 추출
+		String oldcnvsn = (String) detail.get("CHNGMSGIDNAME1");
+		String oldBasRspn = (String) detail.get("BASCRSPNSCHNGMSGIDNAME1");
+		String oldErrRspn = (String) detail.get("ERRRSPNSCHNGMSGIDNAME1");
+
+		if (oldcnvsn == null)
+			oldcnvsn = "";
+		if (oldBasRspn == null)
+			oldBasRspn = "";
+		if (oldErrRspn == null)
+			oldErrRspn = "";
+
+		List<String> oldcnvsnNames = new ArrayList();
+		oldcnvsnNames.add(oldcnvsn);
+		if (!"ASYN".equals((String) detail.get("svcMotivUseDstcd")))
+			oldcnvsnNames.add(oldBasRspn);
+		oldcnvsnNames.add(oldErrRspn);
+
+		// HashMap<String, Object> map =new HashMap<String, Object>() ;
+		for (int i = 0; i < list.length; i++) {
+			boolean owned = false;
+			if ("".equals(list[i].get("cnvsnName"))) // cnvsnName이 제거된다면
+				list[i].put("cnvsnName", (String) oldcnvsnNames.get(i)); // oldCnvsnName으로 조회
+
+			if (!"".equals(list[i].get("cnvsnName"))) {
+				String cnvsnName = (String) list[i].get("cnvsnName");
+				if (cnvsnName.indexOf(eaiSvcName) > 0)
+					owned = true;
+
+				HashMap paramMap = new HashMap();
+				paramMap.put("searchCnvsnName", cnvsnName);
+				int cnt = transformDao.selectListCount(paramMap);
+
+				if (cnt > 1 && owned == true) {
+					mList.add(cnvsnName);
+
+				}
+			}
+		}
+
+		return mList;
+
+	}
+}

src/main/java/com/eactive/eai/rms/onl/transaction/vo/ExternalInterfaceVo.java

@@ -0,0 +1,595 @@
+package com.eactive.eai.rms.onl.transaction.vo;
+
+import com.eactive.eai.rms.common.datasource.DataSourceContextHolder;
+import com.eactive.eai.rms.onl.common.vo.BaseForm;
+
+@SuppressWarnings("serial")
+public class ExternalInterfaceVo extends BaseForm {
+	
+	public static final int APPR_DELT = 1;// 삭제(Delete)
+	public static final int APPR_SAVE = 2;// 저장(Save)
+//	public static final int APPR_UPDT = 2;// 수정(Update)
+	public static final int APPR_REQT = 3;// 상신(reQuest) 
+	public static final int APPR_CNCL = 2;// 상신취소(Cancel)	// 상신취소하면 저장상태로 돌아감
+	public static final int APPR_EXNT = 5;// 검토중(Examination)
+	public static final int APPR_AGMT = 6;// 승인(Agreement)
+	public static final int APPR_RJCT = 7;// 반려(Reject)
+	
+	public static final String TITLE_01 = "영문명";
+	public static final String TITLE_02 = "시스템인터페이스코드";
+	public static final String TITLE_03 = "시스템인터페이스명";
+	public static final String TITLE_04 = "당발타발구분";
+	public static final String TITLE_05 = "전문요청구분";
+	public static final String TITLE_06 = "송수신방법";
+	public static final String TITLE_07 = "서비스ID";
+	public static final String TITLE_08 = "레이아웃매핑";
+	public static final String TITLE_09 = "전문추적관리필드";
+	public static final String TITLE_10 = "통전문관리필드";
+	public static final String TITLE_11 = "내외부구분";
+
+	public static final String FCR_BAS = "BASEFC";
+	public static final String FCR_C2R = "C2RFC";
+	public static final String FCR_B2B = "B2BFC";
+		
+	private int    prcssSeq;        // 처리이력번호
+	private int    svcGrpSeq;       // 그룹번호
+	private int    svcPssSeq;       // 시퀀스번호 
+	private int    apprStat;        // 승인상태      (저장(Save), 수정(Update), 삭제(Delete), 상신(reQuest), 상신취소(Cancel), 검토중(Examination), 승인(Agreement), 반려(Reject) )
+	private String eaiSvcCd;        // 서비스코드   (시스템인터페이스코드 + 당발일 겨우 LEVEL2 , 타발일경우 시스템인터페이스코드의 앞3자리 , + 요청(S),응답(R) + 내부(1),대외(2))
+	private String eaiBzwkDstcd;    // 업무구분   (Level2(영문명))
+	private String sysIFCode;       // 시스템인터페이스코드   (외부시스템(대외기관) : 대외채널업무구분코드(영문명3자리)+전문종별코드+업무구분코드, 내부시스템 : 수신시스템 Level2(영문명)+거래코드+거래코드상세구분)
+	private String sysIFName;       // 시스템인터페이스명   
+	private String oidpDv;          // 당발타발구분   (당발(취급) : O, 타발(개설) : I)
+	private String layoutReqDv;     // 전문요청구분   (요청 : S, 응답 : R)
+	private String inExtnalDv;      // 내외부구분   (내부 : I, 외부 : E)
+	private String sysNameFrom;     // 시스템(요청)   (내부시스템 : [업무시스템영문명]([업무시스템한글명]), 외부시스템 : [외부기관한글명])
+	private String sndRcvDvFrom;    // 송수신방법(요청)   (-동기방식(Sync), -비동기방식(ASync), -Batch, -기타(ETC))
+	private String prtclDvFrom;     // 프로토콜(요청)   (-SOCKET, -HTTP, -X.25, -Tmax, -기타(ETC))
+	private String sysNameRlay;     // 시스템(중계)   (EAI - 내부시스템간 연동, FEP - 대외기관 시스템 연동)
+	private String sndRcvDvRlay;    // 송수신방법(중계)   (-동기방식(Sync), -비동기방식(ASync), -Batch, -기타(ETC))
+	private String prtclDvRlay;     // 프로토콜(중계)   (-SOCKET, -HTTP, -X.25, -Tmax, -기타(ETC))
+	private String sysNameTo;       // 시스템(타겟)   
+	private int    dataOccuType;    // 데이터발생유형   (- “REALTIME”(0), - “BATCH”(1), - “기타”(2))
+	private String extnlIFCtnt;     // 비고   
+	private String ifSvcID;         // 서비스ID, (계정계 서비스ID)   
+	private String ifLayoutTypeCd;  // 처리결과수신서비스ID
+	private int    ifResSvcIDOffset;// 전문종별코드   (offset , field길이)
+	private int    ifResSvcIDFieldL;// 전문종별코드   (offset , field길이) 
+	private int    ifTxDvCdOffset;  // 거래구분코드   (offset , field길이) 
+	private int    ifTxDvCdFieldL;  // 거래구분코드   (offset , field길이) 
+	private String ifLayoutTrace;   // 전문추적관리필드 
+	private String pafiarInfoEmpid; // 요청자직원번호
+	private String userName;        // 요청자명
+	private String cphnNo;          // 요청자연락처
+	private String apprEmpid;       // 승인자직원번호
+	private String apprUserName;    // 승인자이름
+	private String apprCtnt;        // 승인의견/반려사유
+	private String prcssYMS;        // MMDDHH24MISSFF3)
+	
+	private String apprStatName;    // 승인상태명
+	private String startDate;
+	private String endDate;
+	
+	private String ifLayoutMappingName; // 레이아웃매핑명
+	private String ifLayoutTrace1;   // 전문추적관리필드 
+	private int    ifSvcIDOffset1;// 전문종별코드   (offset , field길이)
+	private int    ifSvcIDLength1;// 전문종별코드   (offset , field길이)
+	private String ifLayoutTrace2;   // 전문추적관리필드 
+	private int    ifSvcIDOffset2;// 전문종별코드   (offset , field길이)
+	private int    ifSvcIDLength2;// 전문종별코드   (offset , field길이)
+	
+	private String gstatSysAdptr;
+	private String psvSysAdptr;
+	private String asSysAdptr;
+	
+
+    public String getAsSysAdptr() {
+		return asSysAdptr;
+	}
+
+	public void setAsSysAdptr(String asSysAdptr) {
+		this.asSysAdptr = asSysAdptr;
+	}
+
+	private String createBy = "";
+    private String updateBy = "";
+    
+    //개발담당자, JB담당자 추가 // 2013.06.12
+    private String devEmpid = "";
+    private String jbEmpid = "";
+    private String deUserName = "";
+    private String jbUserName = "";
+    
+    //FlowCtrlRoutName
+    private String flowCtrlRoutName = "";
+    //FailOverYn
+    private boolean failover = false;
+
+    
+    public boolean isFailover() {
+		return failover;
+	}
+
+	public void setFailover(boolean failover) {
+		this.failover = failover;
+	}
+
+	public String getFlowCtrlRoutName() {
+		return flowCtrlRoutName;
+	}
+
+	public void setFlowCtrlRoutName(String flowCtrlRoutName) {
+		this.flowCtrlRoutName = flowCtrlRoutName;
+	}
+
+	public boolean isDevEmpid() {
+    	if( updateBy == null || "".equals(updateBy.trim()) ) return false;
+    	if( updateBy.startsWith("00") || updateBy.startsWith("98") ) return true; // 개발자인경우 true 리턴
+		return false;
+	}
+    
+    public String getDevEmpid() {
+		return devEmpid;
+	}
+
+	public void setDevEmpid(String devEmpid) {
+		this.devEmpid = devEmpid;
+	}
+
+	public String getJbEmpid() {
+		return jbEmpid;
+	}
+
+	public void setJbEmpid(String jbEmpid) {
+		this.jbEmpid = jbEmpid;
+	}
+
+	public String getDeUserName() {
+		return deUserName;
+	}
+
+	public void setDeUserName(String deUserName) {
+		this.deUserName = deUserName;
+	}
+
+	public String getJbUserName() {
+		return jbUserName;
+	}
+
+	public void setJbUserName(String jbUserName) {
+		this.jbUserName = jbUserName;
+	}
+
+	public String getCreateBy() {
+    	return createBy;
+    }
+
+    public String getUpdateBy() {
+    	return updateBy;
+    }
+    
+    public void setCreateBy(String createBy) {
+    	this.createBy = createBy;
+    }
+    
+    public void setUpdateBy(String updateBy) {
+    	this.updateBy = updateBy;
+    	if( isDevEmpid() && devEmpid == null ) devEmpid = updateBy;
+    	if( !isDevEmpid() && jbEmpid == null ) jbEmpid  = updateBy;
+    }
+	
+	public String getGstatSysAdptr() {
+		return gstatSysAdptr;
+	}
+
+	public void setGstatSysAdptr(String gstatSysAdptr) {
+		this.gstatSysAdptr = gstatSysAdptr;
+	}
+	
+	public String getPsvSysAdptr() {
+		return psvSysAdptr;
+	}
+
+	public void setPsvSysAdptr(String psvSysAdptr) {
+		this.psvSysAdptr = psvSysAdptr;
+	}
+	public String getIfLayoutMappingName() {
+		return ifLayoutMappingName;
+	}
+
+	public void setIfLayoutMappingName(String ifLayoutMappingName) {
+		this.ifLayoutMappingName = ifLayoutMappingName;
+	}
+
+	public String getIfLayoutTrace1() {
+		return ifLayoutTrace1;
+	}
+
+	public void setIfLayoutTrace1(String ifLayoutTrace1) {
+		this.ifLayoutTrace1 = ifLayoutTrace1;
+	}
+
+	public int getIfSvcIDOffset1() {
+		return ifSvcIDOffset1;
+	}
+
+	public void setIfSvcIDOffset1(int ifSvcIDOffset1) {
+		this.ifSvcIDOffset1 = ifSvcIDOffset1;
+	}
+
+	public int getIfSvcIDLength1() {
+		return ifSvcIDLength1;
+	}
+
+	public void setIfSvcIDLength1(int ifSvcIDLength1) {
+		this.ifSvcIDLength1 = ifSvcIDLength1;
+	}
+
+	public String getIfLayoutTrace2() {
+		return ifLayoutTrace2;
+	}
+
+	public void setIfLayoutTrace2(String ifLayoutTrace2) {
+		this.ifLayoutTrace2 = ifLayoutTrace2;
+	}
+
+	public int getIfSvcIDOffset2() {
+		return ifSvcIDOffset2;
+	}
+
+	public void setIfSvcIDOffset2(int ifSvcIDOffset2) {
+		this.ifSvcIDOffset2 = ifSvcIDOffset2;
+	}
+
+	public int getIfSvcIDLength2() {
+		return ifSvcIDLength2;
+	}
+
+	public void setIfSvcIDLength2(int ifSvcIDLength2) {
+		this.ifSvcIDLength2 = ifSvcIDLength2;
+	}
+
+	public int getPrcssSeq() {
+		return prcssSeq;
+	}
+
+	public void setPrcssSeq(int prcssSeq) {
+		this.prcssSeq = prcssSeq;
+	}
+
+	public int getSvcGrpSeq() {
+		return svcGrpSeq;
+	}
+
+	public void setSvcGrpSeq(int svcGrpSeq) {
+		this.svcGrpSeq = svcGrpSeq;
+	}
+
+	public int getSvcPssSeq() {
+		return svcPssSeq;
+	}
+
+	public void setSvcPssSeq(int svcPssSeq) {
+		this.svcPssSeq = svcPssSeq;
+	}
+
+	public int getApprStat() {
+		return apprStat;
+	}
+
+	public void setApprStat(int apprStat) {
+		this.apprStat = apprStat;
+	}
+
+	
+	public void setEaiSvcCd(String eaiSvcCd) {
+		this.eaiSvcCd = eaiSvcCd;
+	}
+
+	public String getEaiSvcCd() {
+		//시스템인터페이스코드 + 요청(S),응답(R) + 내부I(1),대외E(2)		
+		return sysIFCode + layoutReqDv + inExtnalDv;
+	}
+
+
+	public String getEaiBzwkDstcd() {
+		return eaiBzwkDstcd;
+	}
+
+	public void setEaiBzwkDstcd(String eaiBzwkDstcd) {
+		this.eaiBzwkDstcd = eaiBzwkDstcd;
+	}
+
+	public String getSysIFCode() {
+		return sysIFCode;
+	}
+
+	public void setSysIFCode(String sysIFCode) {
+		this.sysIFCode = sysIFCode;
+	}
+
+	public String getSysIFName() {
+		return sysIFName;
+	}
+
+	public void setSysIFName(String sysIFName) {
+		this.sysIFName = sysIFName;
+	}
+
+	public String getOidpDv() {
+		return oidpDv;
+	}
+
+	public void setOidpDv(String oidpDv) {
+		this.oidpDv = oidpDv;
+	}
+
+	public String getLayoutReqDv() {
+		return layoutReqDv;
+	}
+
+	public void setLayoutReqDv(String layoutReqDv) {
+		this.layoutReqDv = layoutReqDv;
+	}
+
+	public String getInExtnalDv() {
+		return inExtnalDv;
+	}
+
+	public void setInExtnalDv(String inExtnalDv) {
+		this.inExtnalDv = inExtnalDv;
+	}
+
+	public String getSysNameFrom() {
+		return sysNameFrom;
+	}
+
+	public void setSysNameFrom(String sysNameFrom) {
+		this.sysNameFrom = sysNameFrom;
+	}
+
+	public String getSndRcvDvFrom() {
+		return sndRcvDvFrom;
+	}
+
+	public void setSndRcvDvFrom(String sndRcvDvFrom) {
+		this.sndRcvDvFrom = sndRcvDvFrom;
+	}
+
+	public String getPrtclDvFrom() {
+		return prtclDvFrom;
+	}
+
+	public void setPrtclDvFrom(String prtclDvFrom) {
+		this.prtclDvFrom = prtclDvFrom;
+	}
+
+	public String getSysNameRlay() {
+		return sysNameRlay;
+	}
+
+	public void setSysNameRlay(String sysNameRlay) {
+		this.sysNameRlay = sysNameRlay;
+	}
+
+	public String getSndRcvDvRlay() {
+		return sndRcvDvRlay;
+	}
+
+	public void setSndRcvDvRlay(String sndRcvDvRlay) {
+		this.sndRcvDvRlay = sndRcvDvRlay;
+	}
+
+	public String getPrtclDvRlay() {
+		return prtclDvRlay;
+	}
+
+	public void setPrtclDvRlay(String prtclDvRlay) {
+		this.prtclDvRlay = prtclDvRlay;
+	}
+
+	public String getSysNameTo() {
+		return sysNameTo;
+	}
+
+	public void setSysNameTo(String sysNameTo) {
+		this.sysNameTo = sysNameTo;
+	}
+
+	public int getDataOccuType() {
+		return dataOccuType;
+	}
+
+	public void setDataOccuType(int dataOccuType) {
+		this.dataOccuType = dataOccuType;
+	}
+
+	public String getExtnlIFCtnt() {
+		return extnlIFCtnt;
+	}
+
+	public void setExtnlIFCtnt(String extnlIFCtnt) {
+		this.extnlIFCtnt = extnlIFCtnt;
+	}
+
+	public String getIfSvcID() {
+		return ifSvcID;
+	}
+
+	public void setIfSvcID(String ifSvcID) {
+		this.ifSvcID = ifSvcID;
+	}
+
+	public String getIfLayoutTypeCd() {
+		return ifLayoutTypeCd;
+	}
+
+	public void setIfLayoutTypeCd(String ifLayoutTypeCd) {
+		this.ifLayoutTypeCd = ifLayoutTypeCd;
+	}
+
+	public int getIfResSvcIDOffset() {
+		return ifResSvcIDOffset;
+	}
+	public void setIfResSvcIDOffset(int ifResSvcIDOffset) {
+		this.ifResSvcIDOffset = ifResSvcIDOffset;
+	}
+	public int getIfResSvcIDFieldL() {
+		return ifResSvcIDFieldL;
+	}
+	public void setIfResSvcIDFieldL(int ifResSvcIDFieldL) {
+		this.ifResSvcIDFieldL = ifResSvcIDFieldL;
+	}
+
+	public int getIfTxDvCdOffset() {
+		return ifTxDvCdOffset;
+	}
+	public void setIfTxDvCdOffset(int ifTxDvCdOffset) {
+		this.ifTxDvCdOffset = ifTxDvCdOffset;
+	}
+	public int getIfTxDvCdFieldL() {
+		return ifTxDvCdFieldL;
+	}
+	public void setIfTxDvCdFieldL(int ifTxDvCdFieldL) {
+		this.ifTxDvCdFieldL = ifTxDvCdFieldL;
+	}
+
+	public String getIfLayoutTrace() {
+		return ifLayoutTrace;
+	}
+
+	public void setIfLayoutTrace(String ifLayoutTrace) {
+		this.ifLayoutTrace = ifLayoutTrace;
+	}
+
+	public String getPafiarInfoEmpid() {
+		return pafiarInfoEmpid;
+	}
+
+	public void setPafiarInfoEmpid(String pafiarInfoEmpid) {
+		this.pafiarInfoEmpid = pafiarInfoEmpid;
+	}
+
+	public String getUserName() {
+		return userName;
+	}
+
+	public void setUserName(String userName) {
+		this.userName = userName;
+	}
+
+	public String getCphnNo() {
+		return cphnNo;
+	}
+
+	public void setCphnNo(String cphnNo) {
+		this.cphnNo = cphnNo;
+	}
+
+	public String getApprEmpid() {
+		return apprEmpid;
+	}
+
+	public void setApprEmpid(String apprEmpid) {
+		this.apprEmpid = apprEmpid;
+	}
+
+	public String getApprUserName() {
+		return apprUserName;
+	}
+
+	public void setApprUserName(String apprUserName) {
+		this.apprUserName = apprUserName;
+	}
+
+	public String getApprCtnt() {
+		return apprCtnt;
+	}
+
+	public void setApprCtnt(String apprCtnt) {
+		this.apprCtnt = apprCtnt;
+	}
+
+	public String getPrcssYMS() {
+		return prcssYMS;
+	}
+
+	public void setPrcssYMS(String prcssYMS) {
+		this.prcssYMS = prcssYMS;
+	}
+
+	public String getApprStatName() {
+		return apprStatName;
+	}
+
+	public void setApprStatName(String apprStatName) {
+		this.apprStatName = apprStatName;
+	}
+	public String getStartDate() {
+		return startDate;
+	}
+
+	public void setStartDate(String startDate) {
+		this.startDate = startDate;
+	}
+
+	public String getEndDate() {
+		return endDate;
+	}
+
+	public void setEndDate(String endDate) {
+		this.endDate = endDate;
+	}
+	
+	/* (non-Javadoc)
+     * @see com.eactive.eai.rms.manage.serviceinfo.vo.PersistentVo#getSchemaId()
+     */
+    public String getSchemaId() {
+        return DataSourceContextHolder.getDataSourceType().getSchema();
+    }
+
+	public String toString() {
+		
+		StringBuffer sb = new StringBuffer();
+		sb.append("[ExternalInterfaceVo]\n");
+		sb.append("PrcssSeq=["                  ).append(prcssSeq                  ).append("], ");
+		sb.append("SvcGrpSeq=["                 ).append(svcGrpSeq                 ).append("], ");
+		sb.append("SvcPssSeq=["                 ).append(svcPssSeq                 ).append("], ");
+		sb.append("ApprStat=["                  ).append(apprStat                  ).append("], ");
+		sb.append("EAISvcCd=["                  ).append(eaiSvcCd		           ).append("], ");
+		sb.append("EAIBzwkDstcd=["              ).append(eaiBzwkDstcd              ).append("], ");
+		sb.append("SysIFCode=["                 ).append(sysIFCode                 ).append("], ");
+		sb.append("SysIFName=["                 ).append(sysIFName                 ).append("], ");
+		sb.append("OidpDv=["                    ).append(oidpDv                    ).append("], ");
+		sb.append("LayoutReqDv=["               ).append(layoutReqDv               ).append("], ");
+		sb.append("InExtnalDv=["                ).append(inExtnalDv                ).append("], ");
+		sb.append("SndRcvDvFrom=["              ).append(sndRcvDvFrom              ).append("], ");
+		sb.append("DataOccuType=["              ).append(dataOccuType              ).append("], ");
+		sb.append("ExtnlIFCtnt=["               ).append(extnlIFCtnt               ).append("], ");
+		sb.append("IFSvcID=["                   ).append(ifSvcID                   ).append("], ");
+		sb.append("ifLayoutMappingName=["       ).append(ifLayoutMappingName       ).append("], ");
+		sb.append("ifLayoutTrace1=["            ).append(ifLayoutTrace1            ).append("], [").append(ifSvcIDOffset1).append("], [").append(ifSvcIDLength1).append("], ");
+		sb.append("ifLayoutTrace2=["            ).append(ifLayoutTrace2            ).append("], [").append(ifSvcIDOffset2  ).append("], [").append(ifSvcIDLength2).append("], ");
+		sb.append("gstatSysAdptr=["             ).append(gstatSysAdptr             ).append("], ");
+		sb.append("psvSysAdptr=["               ).append(psvSysAdptr               ).append("], ");
+		sb.append("IFLayoutTypeCd=["            ).append(ifLayoutTypeCd            ).append("], ");
+		sb.append("IFLayoutTrace=["             ).append(ifLayoutTrace             ).append("], ");
+		sb.append("PafiarInfoEmpid=["           ).append(pafiarInfoEmpid           ).append("], ");
+		sb.append("UserName=["                  ).append(userName                  ).append("], ");
+		sb.append("CphnNo=["                    ).append(cphnNo                    ).append("], ");
+		sb.append("SysNameFrom=["               ).append(sysNameFrom               ).append("], ");
+		sb.append("PrtclDvFrom=["               ).append(prtclDvFrom               ).append("], ");
+		sb.append("SysNameRlay=["               ).append(sysNameRlay               ).append("], ");
+		sb.append("SndRcvDvRlay=["              ).append(sndRcvDvRlay              ).append("], ");
+		sb.append("PrtclDvRlay=["               ).append(prtclDvRlay               ).append("], ");
+		sb.append("SysNameTo=["                 ).append(sysNameTo                 ).append("], ");
+		sb.append("IFResSvcID=["                ).append(ifResSvcIDOffset          ).append("], [").append(ifResSvcIDFieldL).append("], ");
+		sb.append("IFTxDvCd=["                  ).append(ifTxDvCdOffset            ).append("], [").append(ifTxDvCdFieldL  ).append("], ");		
+		sb.append("ApprEmpid=["                 ).append(apprEmpid                 ).append("], ");
+		sb.append("ApprUserName=["              ).append(apprUserName              ).append("], ");
+		sb.append("ApprCtnt=["                  ).append(apprCtnt                  ).append("], ");
+		sb.append("PrcssYMS=["                  ).append(prcssYMS                  ).append("]");
+		return sb.toString();
+	}
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/vo/InterfaceVo.java

@@ -0,0 +1,328 @@
+package com.eactive.eai.rms.onl.transaction.vo;
+
+import com.eactive.eai.rms.onl.common.vo.BaseForm;
+
+@SuppressWarnings("serial")
+public class InterfaceVo extends BaseForm {
+
+	private String bzwkSvcKeyName;      // 내부표준 key
+	private String eaiBzwkDstcd;        // 업무구분   (Level2(영문명))
+	private String eaiSvcName;          // 서비스코드   (시스템인터페이스코드 + 당발일 겨우 LEVEL2 , 타발일경우 시스템인터페이스코드의 앞3자리 , + 요청(S),응답(R) + 내부(1),대외(2))
+	private String eaiSvcDesc;          // 
+
+	private String eaiTranName;         // 
+	private String splizDmndDstcd;      // 
+
+	private String recvTranName;        // 
+	private String prcssRsultRecvTranNo;// 
+	private String inputGramId;         // 
+	private String svcMotivUseDstcd;    // 
+	private String layoutMappingName;   // 
+	private String bzwkFldName1;        // 
+	private String bzwkFldName2;        // 
+	private String fromName;            // 
+	private String toName;              // 
+	private String fromAdapter;         // 
+	private String toAdapter;           // 
+	private String sourceToAdapter;     // 
+	private String devUser;             // 
+	private String devUserName;         // 
+	private String bankUser;            // 
+	private String bankUserName;        // 
+	
+	private String createBy;            // 
+	private String updateBy;            // 
+
+	private String createByName;        // 
+	private String updateByName;        // 
+	
+	private String supplDelYn;          //
+	private String hdrCtrlDstcd;        //
+	private String HdrRefClsName;       //
+	
+	private String chnlGramCompartLen;
+	private String level4;
+	
+	private String result;          
+	private String resultMessage;
+
+    //FlowCtrlRoutName
+    private String flowCtrlRoutName = "";
+    //FailOverYn
+    private boolean failover = false;
+	
+	public String getEaiSvcName() {
+		//시스템인터페이스코드 + 요청(S),응답(R) 		
+		return eaiTranName + splizDmndDstcd ;
+	}
+	public void setEaiSvcName(String eaiSvcName) {
+		this.eaiSvcName = eaiSvcName;
+	}
+	public String getEaiBzwkDstcd() {
+		return eaiBzwkDstcd;
+	}
+
+	public void setEaiBzwkDstcd(String eaiBzwkDstcd) {
+		this.eaiBzwkDstcd = eaiBzwkDstcd;
+	}
+
+	public String getEaiTranName() {
+		return eaiTranName;
+	}
+
+	public void setEaiTranName(String eaiTranName) {
+		this.eaiTranName = eaiTranName;
+	}
+
+	public String getEaiSvcDesc() {
+		return eaiSvcDesc;
+	}
+
+	public void setEaiSvcDesc(String eaiSvcDesc) {
+		this.eaiSvcDesc = eaiSvcDesc;
+	}
+
+	public String getSplizDmndDstcd() {
+		return splizDmndDstcd;
+	}
+
+	public void setSplizDmndDstcd(String splizDmndDstcd) {
+		this.splizDmndDstcd = splizDmndDstcd;
+	}
+
+	public String getSvcMotivUseDstcd() {
+		return svcMotivUseDstcd;
+	}
+
+	public void setSvcMotivUseDstcd(String svcMotivUseDstcd) {
+		this.svcMotivUseDstcd = svcMotivUseDstcd;
+	}
+
+	public String getPrcssRsultRecvTranNo() {
+		return prcssRsultRecvTranNo;
+	}
+
+	public void setPrcssRsultRecvTranNo(String prcssRsultRecvTranNo) {
+		this.prcssRsultRecvTranNo = prcssRsultRecvTranNo;
+	}
+
+	public String getInputGramId() {
+		return inputGramId;
+	}
+
+	public void setInputGramId(String inputGramId) {
+		this.inputGramId = inputGramId;
+	}
+
+	public String getLayoutMappingName() {
+		return layoutMappingName;
+	}
+
+	public void setLayoutMappingName(String layoutMappingName) {
+		this.layoutMappingName = layoutMappingName;
+	}
+
+	public String getBzwkFldName1() {
+		return bzwkFldName1;
+	}
+
+	public void setBzwkFldName1(String bzwkFldName1) {
+		this.bzwkFldName1 = bzwkFldName1;
+	}
+
+	public String getBzwkFldName2() {
+		return bzwkFldName2;
+	}
+
+	public void setBzwkFldName2(String bzwkFldName2) {
+		this.bzwkFldName2 = bzwkFldName2;
+	}
+
+	public String getFromAdapter() {
+		return fromAdapter;
+	}
+
+	public void setFromAdapter(String fromAdapter) {
+		this.fromAdapter = fromAdapter;
+	}
+
+	public String getToAdapter() {
+		return toAdapter;
+	}
+
+	public void setToAdapter(String toAdapter) {
+		this.toAdapter = toAdapter;
+	}
+
+	public String getSourceToAdapter() {
+		return sourceToAdapter;
+	}
+
+	public void setSourceToAdapter(String sourceToAdapter) {
+		this.sourceToAdapter = sourceToAdapter;
+	}
+
+	public String getDevUser() {
+		return devUser;
+	}
+
+	public void setDevUser(String devUser) {
+		this.devUser = devUser;
+	}
+
+	public String getDevUserName() {
+		return devUserName;
+	}
+
+	public void setDevUserName(String devUserName) {
+		this.devUserName = devUserName;
+	}
+
+	public String getBankUser() {
+		return bankUser;
+	}
+
+	public void setBankUser(String bankUser) {
+		this.bankUser = bankUser;
+	}
+
+	public String getBankUserName() {
+		return bankUserName;
+	}
+
+	public void setBankUserName(String bankUserName) {
+		this.bankUserName = bankUserName;
+	}
+
+	public String getFlowCtrlRoutName() {
+		return flowCtrlRoutName;
+	}
+
+	public void setFlowCtrlRoutName(String flowCtrlRoutName) {
+		this.flowCtrlRoutName = flowCtrlRoutName;
+	}
+
+	public boolean isFailover() {
+		return failover;
+	}
+
+	public void setFailover(boolean failover) {
+		this.failover = failover;
+	}
+	public String getFromName() {
+		return fromName;
+	}
+	public void setFromName(String fromName) {
+		this.fromName = fromName;
+	}
+	public String getToName() {
+		return toName;
+	}
+	public void setToName(String toName) {
+		this.toName = toName;
+	}
+	public String getRecvTranName() {
+		return recvTranName;
+	}
+	public void setRecvTranName(String recvTranName) {
+		this.recvTranName = recvTranName;
+	}
+
+	public String getBzwkSvcKeyName() {
+		return bzwkSvcKeyName;
+	}
+	public void setBzwkSvcKeyName(String bzwkSvcKeyName) {
+		this.bzwkSvcKeyName = bzwkSvcKeyName;
+	}
+	public String getCreateBy() {
+		return createBy;
+	}
+	public void setCreateBy(String createBy) {
+		this.createBy = createBy;
+	}
+	public String getUpdateBy() {
+		return updateBy;
+	}
+	public void setUpdateBy(String updateBy) {
+		this.updateBy = updateBy;
+	}
+	public String getSupplDelYn() {
+		return supplDelYn;
+	}
+	public void setSupplDelYn(String supplDelYn) {
+		this.supplDelYn = supplDelYn;
+	}
+	public String getHdrCtrlDstcd() {
+		return hdrCtrlDstcd;
+	}
+	public void setHdrCtrlDstcd(String hdrCtrlDstcd) {
+		this.hdrCtrlDstcd = hdrCtrlDstcd;
+	}
+	public String getHdrRefClsName() {
+		return HdrRefClsName;
+	}
+	public void setHdrRefClsName(String hdrRefClsName) {
+		HdrRefClsName = hdrRefClsName;
+	}
+	public String getCreateByName() {
+		return createByName;
+	}
+	public void setCreateByName(String createByName) {
+		this.createByName = createByName;
+	}
+	public String getUpdateByName() {
+		return updateByName;
+	}
+	public void setUpdateByName(String updateByName) {
+		this.updateByName = updateByName;
+	}
+	@Override
+	public String toString() {
+		return "InterfaceVo [bzwkSvcKeyName=" + bzwkSvcKeyName
+				+ ", eaiBzwkDstcd=" + eaiBzwkDstcd + ", eaiSvcName="
+				+ eaiSvcName + ", eaiSvcDesc=" + eaiSvcDesc + ", eaiTranName="
+				+ eaiTranName + ", splizDmndDstcd=" + splizDmndDstcd
+				+ ", recvTranName=" + recvTranName + ", prcssRsultRecvTranNo="
+				+ prcssRsultRecvTranNo + ", inputGramId=" + inputGramId
+				+ ", svcMotivUseDstcd=" + svcMotivUseDstcd
+				+ ", layoutMappingName=" + layoutMappingName
+				+ ", bzwkFldName1=" + bzwkFldName1 + ", bzwkFldName2="
+				+ bzwkFldName2 + ", fromName=" + fromName + ", toName="
+				+ toName + ", fromAdapter=" + fromAdapter + ", toAdapter="
+				+ toAdapter + ", sourceToAdapter=" + sourceToAdapter
+				+ ", devUser=" + devUser + ", devUserName=" + devUserName
+				+ ", bankUser=" + bankUser + ", bankUserName=" + bankUserName
+				+ ", createBy=" + createBy + ", updateBy=" + updateBy
+				+ ", createByName=" + createByName + ", updateByName="
+				+ updateByName + ", supplDelYn=" + supplDelYn
+				+ ", hdrCtrlDstcd=" + hdrCtrlDstcd + ", HdrRefClsName="
+				+ HdrRefClsName + ", flowCtrlRoutName=" + flowCtrlRoutName
+				+ ", failover=" + failover + "]";
+	}
+	public String getResult() {
+		return result;
+	}
+	public void setResult(String result) {
+		this.result = result;
+	}
+	public String getResultMessage() {
+		return resultMessage;
+	}
+	public void setResultMessage(String resultMessage) {
+		this.resultMessage = resultMessage;
+	}
+	public String getChnlGramCompartLen() {
+		return chnlGramCompartLen;
+	}
+	public void setChnlGramCompartLen(String chnlGramCompartLen) {
+		this.chnlGramCompartLen = chnlGramCompartLen;
+	}
+	public String getLevel4() {
+		return level4;
+	}
+	public void setLevel4(String level4) {
+		this.level4 = level4;
+	}
+
+
+}

src/main/java/com/eactive/eai/rms/onl/transaction/vo/UserBzwkDstcd.java

@@ -0,0 +1,24 @@
+package com.eactive.eai.rms.onl.transaction.vo;
+
+import com.eactive.eai.rms.onl.common.vo.BaseForm;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class UserBzwkDstcd extends BaseForm {
+
+	private static final long serialVersionUID = 1L;
+
+	@JsonProperty("BZWKDSTICNAME")
+	private String eaiBzwkDstcd;
+
+	@JsonProperty("GROUPCOCD")
+	private String groupCoCd;
+
+	@JsonProperty("USEYN")
+	private String useYn;
+
+}