新版本

.gitattributes

+/mvnw text eol=lf
+*.cmd text eol=crlf

.gitignore

+HELP.md
+target/
+.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/

src/main/java/com/chenyang/nse/bussiness/commmon/A.java

+package com.chenyang.nse.bussiness.commmon;
+
+import com.chenyang.nse.bussiness.tools.io.FileTool;
+import java.io.File;
+
+public class A {
+   public static void main(String[] args) {
+      String path = (new FileTool()).getClassRoot() + File.separator + "fastsql_tl" + File.separator + "greemplumload.yml";
+      System.out.println(path);
+   }
+}

src/main/java/com/chenyang/nse/bussiness/controller/api/API.java

+package com.chenyang.nse.bussiness.controller.api;
+
+import com.chenyang.nse.bussiness.engine.infa.InfoProperty;
+import com.chenyang.nse.bussiness.entity.orm.table.core.TCoreDatasystem;
+import com.chenyang.nse.bussiness.entity.orm.table.core.desensitizationtask.DesensitizationMonitor;
+import com.chenyang.nse.bussiness.entity.orm.table.core.desensitizationtask.DesensitizationTable;
+import com.chenyang.nse.bussiness.entity.orm.table.core.desensitizationtask.Desensitizationsource;
+import com.chenyang.nse.bussiness.entity.orm.table.core.desensitizationtask.Desensitizationtarget;
+import com.chenyang.nse.bussiness.entity.orm.table.core.desensitizationtask.Desensitizationtask;
+import com.chenyang.nse.bussiness.service.core.DataSystemService;
+import com.chenyang.nse.bussiness.service.core.DesensitizationtaskService;
+import com.chenyang.nse.bussiness.service.redis.RedisService;
+import com.chenyang.nse.bussiness.thread.ExecuteParam;
+import com.chenyang.nse.bussiness.tools.jdbc.JdbcTool;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
+import java.math.BigInteger;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.UUID;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@Controller
+@RequestMapping({"/api"})
+public class API {
+   public static final String DB_pwc_FILE_batchwrite_DB = "DBtoDB,normal,batchwrite";
+   public static final String DB_batchread_FILE_pwc_DB = "DBtoDB,batchread,normal";
+   public static final String DB_batchread_FILE_pwc_FILE_batchwrite_DB = "DBtoDB,batchread,batchwrite";
+   public static final String DB_pwc_DB = "DBtoDB,normal,normal";
+   public static final String DB_pwc_FILE = "DBtoFILE,normal";
+   public static final String DB_batchread_FILE_pwc_FILE = "DBtoFILE,batchread";
+   public static final String FILE_pwc_FILE_batchwrite_DB = "FILEtoDB,batchwrite";
+   public static final String FILE_pwc_DB = "FILEtoDB,normal";
+   public static final String FILE_pwc_FILE = "FILEtoFILE";
+   public static final String HIVE_batchread_FILE_pwc_FILE_batchwrite_HIVE = "HIVEtoHIVE,batchread,batchwrite";
+   @Autowired
+   private DesensitizationtaskService desensitizationtaskService;
+   @Autowired
+   private DataSystemService dataSystemService;
+   @Autowired
+   private RedisService redisService;
+   private static final Logger logger = LoggerFactory.getLogger(API.class);
+
+   @RequestMapping({"/executetask"})
+   public void executeTask(HttpServletRequest request, HttpServletResponse response, String taskname) throws UnsupportedEncodingException {
+      System.out.println("==============通过任务名启动任务开始！==============");
+      System.out.println("--------------taskname=" + taskname + "--------------");
+      String encoding = getEncoding(taskname);
+      System.out.println("--------------encoding=" + encoding + "--------------");
+
+      try {
+         Map<String, Object> map = this.parse(request);
+         System.out.println("------------map=" + map);
+         Map<String, Object> mapParameter = (Map)map.get("parameter");
+         taskname = (String)mapParameter.get("taskname");
+         System.out.println("==============parameter taskname=" + taskname + "===============");
+         Desensitizationtask desensitizationtask = this.desensitizationtaskService.queryTaskByName(taskname, "");
+         PrintWriter writer = response.getWriter();
+         if (desensitizationtask == null) {
+            writer.print("Get the task exception, make sure the task name is correct!");
+            writer.flush();
+            writer.close();
+            return;
+         }
+
+         System.out.println("获取任务成功，即将开始执行脱敏!");
+         String taskid = desensitizationtask.getId();
+         Desensitizationsource desensitizationsource = this.desensitizationtaskService.querySourceInfo(taskid);
+         Desensitizationtarget desensitizationtarget = this.desensitizationtaskService.queryTargetById(taskid);
+         TCoreDatasystem tCoreDatasystemSource = new TCoreDatasystem();
+         TCoreDatasystem tCoreDatasystemTarget = new TCoreDatasystem();
+         if (desensitizationsource.getDatasourceid() != null && !"".equals(desensitizationsource.getDatasourceid())) {
+            tCoreDatasystemSource = this.dataSystemService.queryDataSystemById(desensitizationsource.getDatasourceid());
+         } else {
+            tCoreDatasystemSource.setDbtype("FILE");
+         }
+
+         if (desensitizationtarget.getDatasourceid() != null && !"".equals(desensitizationtarget.getDatasourceid())) {
+            tCoreDatasystemTarget = this.dataSystemService.queryDataSystemById(desensitizationtarget.getDatasourceid());
+         } else {
+            tCoreDatasystemTarget.setDbtype("FILE");
+         }
+
+         String type = JdbcTool.returnType(desensitizationsource.getExecution_type(), desensitizationtarget.getExecution_type(), desensitizationtask.getTasktype());
+         InfoProperty infoProperty = this.desensitizationtaskService.getInfoProperty();
+         long groupId = (new Date()).getTime();
+         ExecuteParam executeParam = new ExecuteParam();
+         executeParam.setSourceDataSystem(tCoreDatasystemSource);
+         executeParam.setTargetDataSystem(tCoreDatasystemTarget);
+         executeParam.setInfoProperty(infoProperty);
+         executeParam.setDataSourceId(desensitizationsource.getDatasourceid());
+         executeParam.setDataTargetId(desensitizationtarget.getDatasourceid());
+         executeParam.setFolderName(desensitizationtask.getFoldername());
+         executeParam.setSourceSchemaName(desensitizationsource.getDataschema());
+         executeParam.setTargetSchemaName(desensitizationtarget.getDataschema());
+         executeParam.setIsPrimary(desensitizationtarget.getIsprimary());
+         executeParam.setIsIndex(desensitizationtarget.getIsindex());
+         executeParam.setTaskid(taskid);
+         executeParam.setSourceFileDir(desensitizationsource.getSourcefiledir());
+         executeParam.setTaskNameReal(desensitizationtask.getTasknamereal());
+         executeParam.setSourcetype(desensitizationsource.getExecution_type());
+         executeParam.setTargettype(desensitizationtarget.getExecution_type());
+         executeParam.setLoadscripttype(desensitizationtarget.getLoadscripttype());
+         String taskType = JdbcTool.returnTaskType(desensitizationtask.getTasktype());
+         List<DesensitizationTable> tableList = this.desensitizationtaskService.queryTableList(taskid);
+         Map<String, String> tableMap = new HashMap();
+         StringBuilder batchInserSql = new StringBuilder();
+         List<String> list_table = JdbcTool.sql_insert_q(new DesensitizationMonitor());
+         list_table.add("id");
+         String sqlBase = JdbcTool.sql_insert_z(list_table, "desensitization_monitor");
+         batchInserSql.append(sqlBase);
+
+         for(DesensitizationTable desensitizationTable : tableList) {
+            String id = UUID.randomUUID().toString();
+            tableMap.put(desensitizationTable.getTablename(), id);
+            DesensitizationMonitor desensitizationMonitor = new DesensitizationMonitor();
+            desensitizationMonitor.setId(id);
+            desensitizationMonitor.setSourcename(desensitizationTable.getTablename());
+            desensitizationMonitor.setTargetname(desensitizationTable.getTablename());
+            desensitizationMonitor.setRunstatus(0);
+            desensitizationMonitor.setGroupid(new BigInteger(String.valueOf(groupId)));
+            desensitizationMonitor.setTaskid(taskid);
+            desensitizationMonitor.setTasktype(taskType);
+            batchInserSql.append(JdbcTool.sql_insert_h(desensitizationMonitor, list_table));
+         }
+
+         executeParam.setTableMap(tableMap);
+         this.desensitizationtaskService.saveDesensitizationMonitor(batchInserSql.deleteCharAt(batchInserSql.length() - 1));
+         switch (type) {
+            case "DBtoDB,normal,batchwrite":
+               this.desensitizationtaskService.executeDB_pwc_FILE_batchwrite_DB(executeParam);
+               break;
+            case "FILEtoDB,batchwrite":
+               this.desensitizationtaskService.executeFILE_pwc_FILE_batchwrite_DB(executeParam);
+               break;
+            case "DBtoDB,batchread,batchwrite":
+               this.desensitizationtaskService.executeDB_batchread_FILE_pwc_FILE_batchwrite_DB(executeParam);
+               break;
+            case "DBtoFILE,batchread":
+               this.desensitizationtaskService.executeDB_batchread_FILE_pwc_FILE(executeParam);
+               break;
+            case "DBtoDB,batchread,normal":
+               this.desensitizationtaskService.executeDB_batchread_FILE_pwc_DB(executeParam);
+               break;
+            default:
+               if (desensitizationtask.getTasktype().contains("HIVE")) {
+                  if ("oracledmp".equals(executeParam.getSourcetype())) {
+                     this.desensitizationtaskService.executeDB_batchread_FILE_pwc_FILE_batchwrite_DB(executeParam);
+                  } else {
+                     this.desensitizationtaskService.executeTask(executeParam);
+                  }
+               } else {
+                  this.desensitizationtaskService.executeTaskNormal(executeParam);
+               }
+         }
+
+         writer.print("Desensitization has been successfully initiated!");
+         writer.flush();
+         writer.close();
+      } catch (Exception e) {
+         System.out.println("==============通过任务名启动任务异常！==============");
+         e.printStackTrace();
+      }
+
+   }
+
+   @RequestMapping({"/requestFor"})
+   public void requestFor(HttpServletRequest request, HttpServletResponse response, String taskname) {
+      Runtime rn = Runtime.getRuntime();
+      System.out.println("taskname============================" + taskname);
+      String encoding1 = getEncoding(taskname);
+      System.out.println("encoding1----------------------------" + encoding1);
+
+      try {
+         String taskname2 = new String(taskname.getBytes(), "UTF-8");
+         String encoding2 = getEncoding(taskname2);
+         System.out.println("encoding2----------------------------" + encoding2);
+         Properties initProp = new Properties(System.getProperties());
+         System.out.println("当前系统编码:" + initProp.getProperty("file.encoding"));
+         System.out.println("当前系统语言:" + initProp.getProperty("user.language"));
+         Process process = rn.exec("/data/api/script/executetask.sh " + taskname2);
+         process.waitFor();
+      } catch (Exception e) {
+         e.printStackTrace();
+      }
+
+   }
+
+   @RequestMapping({"/test"})
+   public void test(HttpServletRequest request, HttpServletResponse response, String keyLike) {
+      logger.info("成功了。。。。");
+   }
+
+   protected Map<String, Object> parse(HttpServletRequest request) throws IOException {
+      request.setCharacterEncoding("UTF-8");
+      Map<String, Object> requestMap = new HashMap();
+      Map<String, Object> headerMap = new HashMap();
+      Enumeration<String> headerNames = request.getHeaderNames();
+
+      while(headerNames != null && headerNames.hasMoreElements()) {
+         String headerName = (String)headerNames.nextElement();
+         headerMap.put(headerName, request.getHeader(headerName));
+      }
+
+      if (!headerMap.isEmpty()) {
+         requestMap.put("header", headerMap);
+      }
+
+      Map<String, Object> parameterMap = new HashMap();
+      Enumeration<String> parameterNames = request.getParameterNames();
+
+      while(parameterNames != null && parameterNames.hasMoreElements()) {
+         String parameterName = (String)parameterNames.nextElement();
+         parameterMap.put(parameterName, request.getParameter(parameterName));
+      }
+
+      if (!parameterMap.isEmpty()) {
+         requestMap.put("parameter", parameterMap);
+      }
+
+      Map<String, Object> attributeMap = new HashMap();
+      Enumeration<String> requestAttributeNames = request.getAttributeNames();
+
+      while(requestAttributeNames != null && requestAttributeNames.hasMoreElements()) {
+         String attributeName = (String)requestAttributeNames.nextElement();
+         if (!attributeName.startsWith("org.springframework")) {
+            attributeMap.put(attributeName, request.getAttribute(attributeName));
+         }
+      }
+
+      if (!attributeMap.isEmpty()) {
+         requestMap.put("attribute", attributeMap);
+      }
+
+      requestMap.put("body", (new String(this.readBytes(request.getInputStream(), request.getContentLength()))).trim());
+      return requestMap;
+   }
+
+   protected byte[] readBytes(InputStream is, int contentLen) {
+      if (contentLen > 0) {
+         int readLen = 0;
+         int readLengthThisTime = 0;
+         byte[] message = new byte[contentLen];
+
+         try {
+            while(readLen != contentLen) {
+               readLengthThisTime = is.read(message, readLen, contentLen - readLen);
+               if (readLengthThisTime == -1) {
+                  break;
+               }
+
+               readLen += readLengthThisTime;
+            }
+
+            return message;
+         } catch (IOException e) {
+            e.printStackTrace();
+         }
+      }
+
+      return new byte[0];
+   }
+
+   public static String getEncoding(String str) {
+      String encode = "GB2312";
+
+      try {
+         if (str.equals(new String(str.getBytes(encode), encode))) {
+            return encode;
+         }
+      } catch (Exception exception) {
+         exception.printStackTrace();
+      }
+
+      encode = "ISO-8859-1";
+
+      try {
+         if (str.equals(new String(str.getBytes(encode), encode))) {
+            return encode;
+         }
+      } catch (Exception exception1) {
+         exception1.printStackTrace();
+      }
+
+      encode = "UTF-8";
+
+      try {
+         if (str.equals(new String(str.getBytes(encode), encode))) {
+            return encode;
+         }
+      } catch (Exception exception2) {
+         exception2.printStackTrace();
+      }
+
+      encode = "GBK";
+
+      try {
+         if (str.equals(new String(str.getBytes(encode), encode))) {
+            return encode;
+         }
+      } catch (Exception exception3) {
+         exception3.printStackTrace();
+      }
+
+      return null;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/controller/api/APIController.java

+package com.chenyang.nse.bussiness.controller.api;
+
+import com.alibaba.fastjson.JSONObject;
+import com.chenyang.nse.bussiness.commmon.json.RespHelper;
+import com.chenyang.nse.bussiness.commmon.json.Response;
+import com.chenyang.nse.bussiness.controller.restfulapi.tools.Base64Tool;
+import com.chenyang.nse.bussiness.entity.cache.LoginUser;
+import com.chenyang.nse.bussiness.entity.orm.table.core.TCoreDatasystem;
+import com.chenyang.nse.bussiness.entity.orm.table.core.dataproject.TCoreProjectFile;
+import com.chenyang.nse.bussiness.entity.orm.table.core.discovery.TcoreDiscoveryColumn;
+import com.chenyang.nse.bussiness.entity.vo.ComboboxVO;
+import com.chenyang.nse.bussiness.entity.vo.DBTableVO;
+import com.chenyang.nse.bussiness.entity.vo.api.ApiInfoObjectVO;
+import com.chenyang.nse.bussiness.service.core.DataSystemService;
+import com.chenyang.nse.bussiness.service.core.TdataDiscoveryService;
+import com.chenyang.nse.bussiness.tools.token.TokenUtil;
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+@Controller
+@RequestMapping({"/api"})
+public class APIController {
+   @Autowired
+   private TdataDiscoveryService tdataDiscoveryService;
+   @Autowired
+   private DataSystemService dataSystemService;
+
+   @RequestMapping
+   public String index(HttpServletRequest request, HttpServletResponse response, Model model) {
+      String ip = request.getLocalAddr();
+      model.addAttribute("ip", ip);
+      return "api/api";
+   }
+
+   @RequestMapping({"/viewapi"})
+   public String viewapi(HttpServletRequest request, HttpServletResponse response, Model model) {
+      String ip = request.getLocalAddr();
+      model.addAttribute("ip", ip);
+      return "api/viewapi";
+   }
+
+   @RequestMapping({"/querytaskById"})
+   @ResponseBody
+   public List<ComboboxVO> querytaskById(String taskid, HttpServletRequest request, HttpServletResponse response) {
+      List<ComboboxVO> rtlist = new ArrayList();
+      List<TCoreProjectFile> discoveryfileList = this.tdataDiscoveryService.queryDiscoveryFile(taskid);
+      Set<String> schemaSet = new HashSet();
+      schemaSet.add(((TCoreProjectFile)discoveryfileList.get(0)).getFilegroup());
+
+      for(String schema : schemaSet) {
+         rtlist.add(new ComboboxVO(schema, schema));
+      }
+
+      return rtlist;
+   }
+
+   @RequestMapping({"/queryfileById"})
+   @ResponseBody
+   public List<ComboboxVO> queryfileById(String taskid, HttpServletRequest request, HttpServletResponse response) {
+      List<ComboboxVO> rtlist = new ArrayList();
+      List<TCoreProjectFile> discoveryfileList = this.tdataDiscoveryService.queryDiscoveryFile(taskid);
+      Set<String> schemaSet = new HashSet();
+
+      for(int i = 0; i < discoveryfileList.size(); ++i) {
+         schemaSet.add(((TCoreProjectFile)discoveryfileList.get(i)).getFilestructure());
+      }
+
+      for(String schema : schemaSet) {
+         rtlist.add(new ComboboxVO(schema, schema));
+      }
+
+      return rtlist;
+   }
+
+   @RequestMapping({"/querySchemaById"})
+   @ResponseBody
+   public Response<List<ComboboxVO>> querySchemaById(@RequestBody Map<String, String> map, HttpServletRequest request, HttpServletResponse response) {
+      List<ComboboxVO> rtlist = new ArrayList();
+      String taskid = (String)map.get("taskid");
+      List<TcoreDiscoveryColumn> discoveryColumnList = this.tdataDiscoveryService.queryDiscoveryColumn(taskid);
+      Set<String> schemaSet = new HashSet();
+
+      for(int i = 0; i < discoveryColumnList.size(); ++i) {
+         schemaSet.add(((TcoreDiscoveryColumn)discoveryColumnList.get(i)).getTschema());
+      }
+
+      for(String schema : schemaSet) {
+         rtlist.add(new ComboboxVO(schema, schema));
+      }
+
+      return RespHelper.<List<ComboboxVO>>successResp(rtlist);
+   }
+
+   @RequestMapping({"/queryTableById"})
+   @ResponseBody
+   public Response<List<ComboboxVO>> queryTableById(@RequestBody Map<String, String> map, HttpServletRequest request, HttpServletResponse response) {
+      List<ComboboxVO> rtlist = new ArrayList();
+      String taskid = (String)map.get("taskid");
+      String schema = (String)map.get("schema");
+      List<TcoreDiscoveryColumn> discoveryColumnList = this.tdataDiscoveryService.queryDiscoveryColumn(taskid);
+
+      for(int i = 0; i < discoveryColumnList.size(); ++i) {
+         if (schema != null && schema.equals(((TcoreDiscoveryColumn)discoveryColumnList.get(i)).getTschema())) {
+            rtlist.add(new ComboboxVO(((TcoreDiscoveryColumn)discoveryColumnList.get(i)).getTablename(), ((TcoreDiscoveryColumn)discoveryColumnList.get(i)).getTablename()));
+         }
+      }
+
+      return RespHelper.<List<ComboboxVO>>successResp(rtlist);
+   }
+
+   @RequestMapping({"/queryDatabaseByProjectId"})
+   @ResponseBody
+   public Response<List<ComboboxVO>> queryDatabaseByProjectId(@RequestBody Map<String, String> map, HttpServletRequest request, HttpServletResponse response) {
+      List<ComboboxVO> rtlist = new ArrayList();
+      String projectId = (String)map.get("projectId");
+
+      for(TCoreDatasystem tCoreDatasystem : this.dataSystemService.querydatasourceds(projectId)) {
+         rtlist.add(new ComboboxVO(tCoreDatasystem.getId(), tCoreDatasystem.getSysname()));
+      }
+
+      return RespHelper.<List<ComboboxVO>>successResp(rtlist);
+   }
+
+   @RequestMapping({"/queryTableBySchema"})
+   @ResponseBody
+   public Response<List<ComboboxVO>> queryTableBySchema(@RequestBody Map<String, String> map, HttpServletRequest request, HttpServletResponse response) {
+      List<ComboboxVO> rtlist = new ArrayList();
+      String dataSystemId = (String)map.get("dataSystemId");
+      String schema = (String)map.get("schema");
+
+      for(DBTableVO dBTableVO : this.dataSystemService.queryTablename(dataSystemId, schema)) {
+         rtlist.add(new ComboboxVO(dBTableVO.getTablename(), dBTableVO.getTablename()));
+      }
+
+      return RespHelper.<List<ComboboxVO>>successResp(rtlist);
+   }
+
+   @RequestMapping({"/urltest"})
+   @ResponseBody
+   public Response<String> urltest(@RequestBody Map<String, String> map, HttpServletRequest request, HttpServletResponse response) {
+      String reStr = "";
+      String testurl = (String)map.get("testurl");
+      String requestway = (String)map.get("requestway");
+      String token = request.getHeader("token");
+
+      try {
+         reStr = load(testurl + "/test", requestway, token, (String)null);
+         return RespHelper.<String>successResp(new String(reStr.getBytes()));
+      } catch (Exception var12) {
+         Exception e = var12;
+         var12.printStackTrace();
+
+         try {
+            Map<String, Object> result = new HashMap();
+            result.put("code", "404");
+            result.put("msg", e.toString());
+            String message = JSONObject.toJSONString(result);
+            return RespHelper.<String>successResp(new String(message.getBytes(), "utf-8"));
+         } catch (UnsupportedEncodingException e1) {
+            e1.printStackTrace();
+            return null;
+         }
+      }
+   }
+
+   @RequestMapping({"/getAuthorization"})
+   @ResponseBody
+   public String getAuthorization(HttpServletRequest request, HttpServletResponse response) {
+      LoginUser loginUser = (LoginUser)request.getSession().getAttribute("loginUser");
+      String authorizationStr = loginUser.getTsysUser().getUsername() + ":" + loginUser.getTsysUser().getPassword();
+
+      try {
+         authorizationStr = Base64Tool.encryptBASE64(authorizationStr);
+      } catch (Exception e) {
+         e.printStackTrace();
+      }
+
+      return authorizationStr;
+   }
+
+   @RequestMapping({"/getUrlAndToken"})
+   @ResponseBody
+   public Response<Map<String, String>> getUrlAndToken(HttpServletRequest request, HttpServletResponse response, @RequestBody Map<String, String> params) {
+      Map<String, String> map = new HashMap();
+      String username = TokenUtil.getUserId(request.getHeader("token"));
+      String password = TokenUtil.getPassword(request.getHeader("token"));
+      map.put("token", TokenUtil.getNoDateToken(username, password));
+      String url = "";
+      String taskid = params.get("taskid") == null ? "" : (String)params.get("taskid");
+      String projectid = params.get("projectid") == null ? "" : (String)params.get("projectid");
+      String type = params.get("type") == null ? "" : (String)params.get("type");
+      String editionid = params.get("editionid") == null ? "" : (String)params.get("editionid");
+      if (type.equals("2")) {
+         url = "/api/tt/pd/" + projectid + "/td/" + taskid;
+      } else if (type.equals("3")) {
+         if (editionid == "") {
+            url = "/api/ft/se/0/pd/" + projectid + "/vn/" + taskid;
+         } else {
+            url = "/api/ft/se/0/pd/" + projectid + "/vn/" + editionid + "/td/" + taskid;
+         }
+      } else if (type.equals("4")) {
+         if (editionid == "") {
+            url = "/api/ft/se/2/pd/" + projectid + "/vn/" + taskid;
+         } else {
+            url = "/api/ft/se/2/pd/" + projectid + "/vn/" + editionid + "/td/" + taskid;
+         }
+      } else if (type.equals("5")) {
+         if (editionid == "") {
+            url = "/api/ft/se/1/pd/" + projectid + "/vn/" + taskid;
+         } else {
+            url = "/api/ft/se/1/pd/" + projectid + "/vn/" + editionid + "/td/" + taskid;
+         }
+      } else if (!type.equals("6") && !type.equals("7")) {
+         if (type.equals("8")) {
+            url = "/api/ay/pd/" + projectid + "/dd/" + editionid + "/td/" + taskid;
+         }
+      } else {
+         url = "/api/ay/dd/" + taskid;
+      }
+
+      map.put("url", url);
+      return RespHelper.<Map<String, String>>successResp(map);
+   }
+
+   public static String load(String url, String requestway, String validationstr, String query) throws Exception {
+      url = new String(url.getBytes("UTF-8"), "UTF-8");
+      URL restURL = new URL(url);
+      HttpURLConnection conn = (HttpURLConnection)restURL.openConnection();
+      conn.setRequestMethod(requestway.toUpperCase());
+      conn.setRequestProperty("token", validationstr);
+      conn.setConnectTimeout(30000);
+      conn.setReadTimeout(30000);
+      conn.setDoOutput(true);
+      conn.setDoInput(true);
+      conn.setAllowUserInteraction(true);
+      PrintStream ps = new PrintStream(conn.getOutputStream());
+      ps.print(query);
+      ps.close();
+      InputStream inputStream = conn.getInputStream();
+      InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
+      BufferedReader bReader = new BufferedReader(inputStreamReader);
+
+      String line;
+      String resultStr;
+      for(resultStr = ""; null != (line = bReader.readLine()); resultStr = resultStr + line) {
+      }
+
+      bReader.close();
+      conn.disconnect();
+      return resultStr;
+   }
+
+   @RequestMapping({"/saveApiInfo"})
+   @ResponseBody
+   public Response<String> saveApiInfo(@RequestBody ApiInfoObjectVO apiInfoObjectVO, HttpServletRequest request, HttpServletResponse response, Model model) {
+      String string = this.tdataDiscoveryService.saveApiInfo(apiInfoObjectVO);
+      return RespHelper.<String>successResp(string);
+   }
+
+   @RequestMapping({"/selectApiInfo"})
+   @ResponseBody
+   public Response<ApiInfoObjectVO> selectApiInfo(@RequestBody Map<String, String> map, HttpServletRequest request, HttpServletResponse response, Model model) {
+      String taskid = (String)map.get("taskid");
+      ApiInfoObjectVO selectApiInfo = this.tdataDiscoveryService.selectApiInfo(taskid);
+      return RespHelper.<ApiInfoObjectVO>successResp(selectApiInfo);
+   }
+
+   @RequestMapping({"/releaseByTreeId"})
+   @ResponseBody
+   public Response<String> releaseByTreeId(@RequestBody Map<String, String> map, HttpServletRequest request, HttpServletResponse response, Model model) {
+      String treeid = (String)map.get("treeid");
+      int count = this.tdataDiscoveryService.releaseByTreeId(treeid);
+      return count == 0 ? RespHelper.successResp("未保存不能发布") : RespHelper.successResp("发布成功");
+   }
+
+   @RequestMapping({"/releaseAll"})
+   @ResponseBody
+   public Response<String> releaseAll(HttpServletRequest request, HttpServletResponse response, Model model) {
+      int count = this.tdataDiscoveryService.releaseAll();
+      return RespHelper.<String>successResp("success");
+   }
+}

src/main/java/com/chenyang/nse/bussiness/controller/core/dataproject/AllDiscoveryTaskMonitorController.java

+package com.chenyang.nse.bussiness.controller.core.dataproject;
+
+import com.chenyang.nse.bussiness.entity.vo.DiscoveryMonitorVO;
+import com.chenyang.nse.bussiness.entity.vo.dataproject.TCoreDiscoveryTaskVO;
+import com.chenyang.nse.bussiness.service.core.dataproject.DiscoverytaskService;
+import java.util.ArrayList;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+@Controller
+@RequestMapping({"/core/discoverymonitorlog"})
+public class AllDiscoveryTaskMonitorController {
+   @Autowired
+   private DiscoverytaskService discoverytaskService;
+
+   @RequestMapping
+   public String index(HttpServletRequest request, HttpServletResponse response, Model model) {
+      return "core/dataproject/monitor/alldiscoverytask_monitor";
+   }
+
+   @RequestMapping({"/queryDiscoveryTask"})
+   @ResponseBody
+   public List<DiscoveryMonitorVO> queryDiscoveryTask(HttpServletRequest request, HttpServletResponse response, String projectid) {
+      return this.discoverytaskService.queryDiscoveryTaskForMonitor(projectid);
+   }
+
+   @ResponseBody
+   @RequestMapping({"/queryDetail"})
+   public List<TCoreDiscoveryTaskVO> queryDetail(String taskid, String discoverytype, String isDmpFlag) {
+      new ArrayList();
+      List list;
+      if (!"1".equals(discoverytype) && !"3".equals(discoverytype) && !"4".equals(discoverytype)) {
+         if ("1".equals(isDmpFlag)) {
+            list = this.discoverytaskService.queryDiscoveryTaskDetailforDmp(taskid);
+         } else {
+            list = this.discoverytaskService.queryDiscoveryTaskDetailforTxt(taskid);
+         }
+      } else {
+         list = this.discoverytaskService.queryDiscoveryTaskDetailforDB(taskid);
+      }
+
+      return list;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/controller/restfulapi/AccountabilityAPIController.java

+package com.chenyang.nse.bussiness.controller.restfulapi;
+
+import com.alibaba.fastjson.JSONObject;
+import com.chenyang.nse.bussiness.controller.restfulapi.entity.ResultAPIEnum;
+import com.chenyang.nse.bussiness.controller.restfulapi.tools.ApiTool;
+import com.chenyang.nse.bussiness.controller.restfulapi.tools.AuthorizationTool;
+import com.chenyang.nse.bussiness.dao.table.core.TCoreDatasystemDao;
+import com.chenyang.nse.bussiness.entity.orm.table.core.TCoreDatasystem;
+import com.chenyang.nse.bussiness.entity.orm.table.core.api.ApiInfoLog;
+import com.chenyang.nse.bussiness.entity.orm.table.core.duty.DutyTableInfo;
+import com.chenyang.nse.bussiness.entity.vo.api.AccountabilityVO;
+import com.chenyang.nse.bussiness.service.core.api.AccountabilityAPIService;
+import com.chenyang.nse.bussiness.service.core.api.ApiInfoLogService;
+import com.chenyang.nse.bussiness.tools.token.TokenUtil;
+import java.io.IOException;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.hibernate.criterion.Criterion;
+import org.hibernate.criterion.Restrictions;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+@Controller
+@RequestMapping({"/api/ay"})
+public class AccountabilityAPIController {
+   @Autowired
+   private AccountabilityAPIService accountabilityAPIService;
+   @Autowired
+   private TCoreDatasystemDao tCoreDatasystemDao;
+   @Autowired
+   private ApiInfoLogService apiInfoLogService;
+
+   @ResponseBody
+   @RequestMapping(
+      value = {"/dd/{datasystemid}", "/pd/{projectid}/dd/{datasystemid}/td/{taskid}"},
+      method = {RequestMethod.POST},
+      produces = {"text/json;charset=UTF-8"}
+   )
+   public String postAccountability(@PathVariable(value = "projectid",required = false) String projectid, @PathVariable("datasystemid") String datasystemid, @PathVariable(value = "taskid",required = false) String taskid, HttpServletRequest request) {
+      Map<String, Object> result = new HashMap();
+      result.put("code", ResultAPIEnum.RT_SUC_CODE_200_STR.getCode());
+      result.put("msg", ResultAPIEnum.RT_SUC_CODE_200_STR.getMsg());
+      String token = request.getHeader("token");
+      String cilentip = request.getRemoteAddr();
+      String reqUrl = "http://" + request.getServerName() + ":" + request.getServerPort() + request.getRequestURI();
+      boolean flag = TokenUtil.verify(token);
+      if (flag) {
+         Map<String, String> rvMap = AuthorizationTool.releaseVerification(reqUrl);
+         if ("0".equals(rvMap.get("code"))) {
+            TCoreDatasystem datasystem = (TCoreDatasystem)this.tCoreDatasystemDao.queryUnique(new Criterion[]{Restrictions.eq("id", datasystemid)});
+            if (null == datasystem) {
+               result.put("code", ResultAPIEnum.RT_ERROR_CODE_403_STR.getCode());
+               result.put("msg", ResultAPIEnum.RT_ERROR_CODE_403_STR.getMsg());
+            } else {
+               DutyTableInfo obj = new DutyTableInfo();
+               obj.setId(taskid);
+               obj.setProjectid(projectid);
+               obj.setDatasystemid(datasystemid);
+               List<AccountabilityVO> list = this.accountabilityAPIService.selectAccountabilityInfo(obj);
+               if (null != list && list.size() != 0) {
+                  List<Map<String, Object>> tdResultMapList = ApiTool.objectsToMaps(list);
+                  result.put("data", tdResultMapList);
+               } else {
+                  result.put("code", ResultAPIEnum.RT_ERROR_CODE_403_STR.getCode());
+                  result.put("msg", ResultAPIEnum.RT_ERROR_CODE_403_STR.getMsg());
+               }
+            }
+         } else {
+            result.put("code", ResultAPIEnum.RT_ERROR_CODE_431_STR.getCode());
+            result.put("msg", rvMap.get("msg"));
+         }
+      } else {
+         result.put("code", ResultAPIEnum.RT_ERROR_CODE_400_STR.getCode());
+         result.put("msg", "Invalid Request");
+      }
+
+      String message = JSONObject.toJSONString(result);
+      ApiInfoLog info = new ApiInfoLog();
+      info.setApitype("3");
+      info.setAuthorization(token);
+      info.setUsername(TokenUtil.getUserId(token));
+      info.setCalldatetime(new Date());
+      info.setCreatetime(new Date());
+      info.setRestatus(String.valueOf(result.get("code")));
+      info.setRemsg(String.valueOf(result.get("msg")));
+      info.setUrl(reqUrl);
+      info.setCilentip(cilentip);
+      this.apiInfoLogService.save(info);
+      System.out.println(message);
+      return message;
+   }
+
+   @ResponseBody
+   @RequestMapping(
+      value = {"/dd/{datasystemid}/test", "/pd/{projectid}/dd/{datasystemid}/td/{taskid}/test"},
+      method = {RequestMethod.POST},
+      produces = {"text/json;charset=UTF-8"}
+   )
+   public String postAccountabilityTest(@PathVariable(value = "projectid",required = false) String projectid, @PathVariable("datasystemid") String datasystemid, @PathVariable(value = "taskid",required = false) String taskid, HttpServletRequest request) {
+      Map<String, Object> result = new HashMap();
+      result.put("code", ResultAPIEnum.RT_SUC_CODE_200_STR.getCode());
+      result.put("msg", ResultAPIEnum.RT_SUC_CODE_200_STR.getMsg());
+      String token = request.getHeader("token");
+      String cilentip = request.getRemoteAddr();
+      (new StringBuilder()).append("http://").append(request.getServerName()).append(":").append(request.getServerPort()).append(request.getRequestURI()).toString();
+      boolean flag = TokenUtil.verify(token);
+      if (flag) {
+         TCoreDatasystem datasystem = (TCoreDatasystem)this.tCoreDatasystemDao.queryUnique(new Criterion[]{Restrictions.eq("id", datasystemid)});
+         if (null == datasystem) {
+            result.put("code", ResultAPIEnum.RT_ERROR_CODE_403_STR.getCode());
+            result.put("msg", ResultAPIEnum.RT_ERROR_CODE_403_STR.getMsg());
+         } else {
+            DutyTableInfo obj = new DutyTableInfo();
+            obj.setId(taskid);
+            obj.setProjectid(projectid);
+            obj.setDatasystemid(datasystemid);
+            List<AccountabilityVO> list = this.accountabilityAPIService.selectAccountabilityInfo(obj);
+            if (null != list && list.size() != 0) {
+               List<Map<String, Object>> tdResultMapList = ApiTool.objectsToMaps(list);
+               result.put("data", tdResultMapList);
+            } else {
+               result.put("code", ResultAPIEnum.RT_ERROR_CODE_403_STR.getCode());
+               result.put("msg", ResultAPIEnum.RT_ERROR_CODE_403_STR.getMsg());
+            }
+         }
+      } else {
+         result.put("code", ResultAPIEnum.RT_ERROR_CODE_400_STR.getCode());
+         result.put("msg", "Invalid Request");
+      }
+
+      String message = JSONObject.toJSONString(result);
+      return message;
+   }
+
+   @ResponseBody
+   @RequestMapping(
+      value = {"/dd/{datasystemid}", "/pd/{projectid}/dd/{datasystemid}/td/{taskid}"},
+      method = {RequestMethod.GET},
+      produces = {"text/json;charset=UTF-8"}
+   )
+   public String getAccountability(@PathVariable(value = "projectid",required = false) String projectid, @PathVariable("datasystemid") String datasystemid, @PathVariable(value = "taskid",required = false) String taskid, HttpServletRequest request, HttpServletResponse response) {
+      Map<String, Object> result = new HashMap();
+      result.put("code", ResultAPIEnum.RT_SUC_CODE_200_STR.getCode());
+      result.put("msg", ResultAPIEnum.RT_SUC_CODE_200_STR.getMsg());
+      String token = request.getHeader("token");
+      String cilentip = request.getRemoteAddr();
+      String reqUrl = "http://" + request.getServerName() + ":" + request.getServerPort() + request.getRequestURI();
+      if (!TokenUtil.verify(token)) {
+         response.setStatus(401);
+         response.setHeader("WWW-Authenticate", "Basic realm=\"My Application\"");
+         response.setContentType("text/html; charset=UTF-8");
+
+         try {
+            response.getWriter().print("HTTP STATUS -- 401!");
+            return null;
+         } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+         } finally {
+            ;
+         }
+      } else {
+         Map<String, String> rvMap = AuthorizationTool.releaseVerification(reqUrl);
+         if ("0".equals(rvMap.get("code"))) {
+            TCoreDatasystem datasystem = (TCoreDatasystem)this.tCoreDatasystemDao.queryUnique(new Criterion[]{Restrictions.eq("id", datasystemid)});
+            if (null == datasystem) {
+               result.put("code", ResultAPIEnum.RT_ERROR_CODE_403_STR.getCode());
+               result.put("msg", ResultAPIEnum.RT_ERROR_CODE_403_STR.getMsg());
+            } else {
+               DutyTableInfo obj = new DutyTableInfo();
+               obj.setId(taskid);
+               obj.setProjectid(projectid);
+               obj.setDatasystemid(datasystemid);
+               List<AccountabilityVO> list = this.accountabilityAPIService.selectAccountabilityInfo(obj);
+               if (null != list && list.size() != 0) {
+                  List<Map<String, Object>> tdResultMapList = ApiTool.objectsToMaps(list);
+                  result.put("data", tdResultMapList);
+               } else {
+                  result.put("code", ResultAPIEnum.RT_ERROR_CODE_403_STR.getCode());
+                  result.put("msg", ResultAPIEnum.RT_ERROR_CODE_403_STR.getMsg());
+               }
+            }
+         } else {
+            result.put("code", ResultAPIEnum.RT_ERROR_CODE_431_STR.getCode());
+            result.put("msg", rvMap.get("msg"));
+         }
+
+         String message = JSONObject.toJSONString(result);
+         ApiInfoLog info = new ApiInfoLog();
+         info.setApitype("3");
+         info.setAuthorization(token);
+         info.setUsername(TokenUtil.getUserId(token));
+         info.setCalldatetime(new Date());
+         info.setCreatetime(new Date());
+         info.setRestatus(String.valueOf(result.get("code")));
+         info.setRemsg(String.valueOf(result.get("msg")));
+         info.setUrl(reqUrl);
+         info.setCilentip(cilentip);
+         this.apiInfoLogService.save(info);
+         System.out.println(message);
+         return message;
+      }
+   }
+}

src/main/java/com/chenyang/nse/bussiness/controller/webApi/ApiController.java

+package com.chenyang.nse.bussiness.controller.webApi;
+
+import com.chenyang.nse.bussiness.annot.PassToken;
+import com.chenyang.nse.bussiness.ccoresdf.CcoreSDFUtil;
+import com.chenyang.nse.bussiness.entity.webApi.ApiCode;
+import com.chenyang.nse.bussiness.entity.webApi.DataParams;
+import com.chenyang.nse.bussiness.entity.webApi.DataParamsList;
+import com.chenyang.nse.bussiness.entity.webApi.Msg;
+import com.chenyang.nse.bussiness.service.webApi.WebApiService;
+import com.chenyang.nse.bussiness.service.webApi.business.SecretKeyCache;
+import com.chenyang.nse.bussiness.tools.encryption.EncProvider;
+import java.util.List;
+import java.util.Map;
+import org.apache.shiro.codec.Hex;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+@Controller
+@RequestMapping({"/data/api"})
+public class ApiController {
+   private static final Logger LOGGER = LoggerFactory.getLogger(ApiController.class);
+   @Autowired
+   private WebApiService service;
+
+   @PassToken
+   @RequestMapping(
+      value = {"/enc"},
+      method = {RequestMethod.POST},
+      produces = {"application/json;charset=utf-8"}
+   )
+   @ResponseBody
+   public Msg enc(@RequestBody DataParamsList data) {
+      List<DataParams> configs = data.getConfigs();
+      if (configs != null && configs.size() != 0) {
+         try {
+            return this.service.enc(data);
+         } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+            return Msg.error(ApiCode.other, e.getMessage());
+         }
+      } else {
+         return Msg.succed(configs);
+      }
+   }
+
+   @PassToken
+   @RequestMapping(
+      value = {"/dec"},
+      method = {RequestMethod.POST},
+      produces = {"application/json;charset=utf-8"}
+   )
+   @ResponseBody
+   public Msg dec(@RequestBody DataParamsList data) {
+      List<DataParams> configs = data.getConfigs();
+      if (configs != null && configs.size() != 0) {
+         try {
+            return this.service.dec(data);
+         } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+            return Msg.error(ApiCode.other, e.getMessage());
+         }
+      } else {
+         return Msg.succed(configs);
+      }
+   }
+
+   @PassToken
+   @RequestMapping(
+      value = {"/remote/invoke"},
+      method = {RequestMethod.POST},
+      produces = {"application/json;charset=utf-8"}
+   )
+   @ResponseBody
+   public String remoteEncDecInvoke(@RequestBody Map<String, String> params) {
+      String api = (String)params.get("api");
+      String key = (String)params.get("key");
+      String content = (String)params.get("content");
+      String isLike = (String)params.get("isLike");
+      String type = (String)params.get("type");
+      String project = (String)params.get("project");
+      String mode = (String)params.get("mode");
+      String fid = (String)params.get("fid");
+      String keepfirst = (String)params.get("keepfirst");
+      String encdigit = (String)params.get("encdigit");
+      String twoindex = (String)params.get("twoindex");
+      if (api != null && api.length() != 0) {
+         if (key != null && key.length() != 0) {
+            if (content != null && content.length() != 0) {
+               if (type != null && type.length() != 0) {
+                  if (mode != null && mode.equalsIgnoreCase("CCORESDF")) {
+                     if (project == null || project.length() == 0 || fid == null || fid.length() == 0) {
+                        return "{{ERR:加密卡加密解密缺少参数project|fid";
+                     }
+
+                     key = SecretKeyCache.instance().getPKey(project, fid);
+                  }
+
+                  try {
+                     if (api.equals("enc")) {
+                        return EncProvider.encryptEcb(type, key, content, isLike, keepfirst, encdigit, twoindex);
+                     } else {
+                        return EncProvider.decryptEcb(type, key, content, isLike, keepfirst, encdigit, twoindex);
+                     }
+                  } catch (Exception exception) {
+                     return "{{ERR:远程调用执行错误," + exception.toString();
+                  }
+               } else {
+                  return "{{ERR:远程调用参数type为空";
+               }
+            } else {
+               return content;
+            }
+         } else {
+            return "{{ERR:远程调用参数key为空";
+         }
+      } else {
+         return "{{ERR:远程调用参数api为空";
+      }
+   }
+
+   @PassToken
+   @RequestMapping(
+      value = {"/remote/queryCcoreSDFKey"},
+      method = {RequestMethod.POST},
+      produces = {"application/json;charset=utf-8"}
+   )
+   @ResponseBody
+   public String queryCcoreSDFKey(@RequestBody Map<String, String> params) {
+      String key = (String)params.get("key");
+      if (key != null && key.length() != 0) {
+         try {
+            if (null != key && !"".equals(key)) {
+               try {
+                  byte[] endData = Hex.decode(key);
+                  return CcoreSDFUtil.getDecrypt(endData);
+               } catch (Exception e) {
+                  e.printStackTrace();
+               }
+            }
+
+            return "{{ERR:远程调用执行错误,没有解密失败";
+         } catch (Exception exception) {
+            return "{{ERR:远程调用执行错误," + exception.toString();
+         }
+      } else {
+         return "{{ERR:远程调用参数key为空";
+      }
+   }
+}

src/main/java/com/chenyang/nse/bussiness/dao/table/core/api/AccountabilityAPIDao.java

+package com.chenyang.nse.bussiness.dao.table.core.api;
+
+import com.chenyang.nse.bussiness.dao.BaseDao;
+import com.chenyang.nse.bussiness.entity.vo.api.AccountabilityVO;
+import java.util.List;
+import org.hibernate.transform.Transformers;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class AccountabilityAPIDao extends BaseDao<AccountabilityVO, String> {
+   public List<AccountabilityVO> selectAccountabilityInfo(String datasystemid) {
+      String sql = "select duty_id,duty_name,duty_scope,duty_main,d.sysname FROM t_duty_person p JOIN t_core_datasystem d ON d.id = p.datasystemid WHERE datasystemid =:datasystemid ";
+      return this.getSession().createNativeQuery(sql).setParameter("datasystemid", datasystemid).setResultTransformer(Transformers.aliasToBean(AccountabilityVO.class)).getResultList();
+   }
+
+   public List<AccountabilityVO> selectAccountabilityInfo(String projectid, String datasystemid, String taskid) {
+      String sql = "SELECT schemaname ,tablename ,joinid,jointype FROM t_console_dutytableinfo d LEFT JOIN t_console_dutyjoininfo i ON i.dutytableid = d.id\r\nWHERE d.projectid = :projectid AND d.datasystemid = :datasystemid AND d.id=:taskid";
+      return this.getSession().createNativeQuery(sql).setParameter("projectid", projectid).setParameter("datasystemid", datasystemid).setParameter("taskid", taskid).setResultTransformer(Transformers.aliasToBean(AccountabilityVO.class)).getResultList();
+   }
+}

src/main/java/com/chenyang/nse/bussiness/dao/table/core/api/ApiHeaderParameterDao.java

+package com.chenyang.nse.bussiness.dao.table.core.api;
+
+import com.chenyang.nse.bussiness.dao.BaseDao;
+import com.chenyang.nse.bussiness.entity.orm.table.core.api.ApiHeaderParameter;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class ApiHeaderParameterDao extends BaseDao<ApiHeaderParameter, String> {
+}

src/main/java/com/chenyang/nse/bussiness/entity/orm/table/core/AAAA.java

+package com.chenyang.nse.bussiness.entity.orm.table.core;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(
+   name = "AAAA"
+)
+public class AAAA {
+   @Id
+   private Integer id;
+   @Column(
+      length = 255
+   )
+   private String key;
+
+   public Integer getId() {
+      return this.id;
+   }
+
+   public void setId(Integer id) {
+      this.id = id;
+   }
+
+   public String getKey() {
+      return this.key;
+   }
+
+   public void setKey(String key) {
+      this.key = key;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/entity/orm/table/core/api/ApiHeaderParameter.java

+package com.chenyang.nse.bussiness.entity.orm.table.core.api;
+
+import com.chenyang.nse.bussiness.entity.orm.table.TBaseEntity;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+@Entity
+@Table(
+   name = "api_header_parameter"
+)
+public class ApiHeaderParameter extends TBaseEntity {
+   private String parameterName;
+   private String parameterValue;
+   private String apiInfoId;
+
+   public String getParameterName() {
+      return this.parameterName;
+   }
+
+   public void setParameterName(String parameterName) {
+      this.parameterName = parameterName;
+   }
+
+   public String getParameterValue() {
+      return this.parameterValue;
+   }
+
+   public void setParameterValue(String parameterValue) {
+      this.parameterValue = parameterValue;
+   }
+
+   public String getApiInfoId() {
+      return this.apiInfoId;
+   }
+
+   public void setApiInfoId(String apiInfoId) {
+      this.apiInfoId = apiInfoId;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/entity/orm/table/core/api/ApiInfo.java

+package com.chenyang.nse.bussiness.entity.orm.table.core.api;
+
+import com.chenyang.nse.bussiness.entity.orm.table.TBaseEntity;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+@Entity
+@Table(
+   name = "api_info"
+)
+public class ApiInfo extends TBaseEntity {
+   private String url;
+   private String requestWay;
+   private String state;
+   private String headerParameterId;
+   private String sysParameterId;
+   private String taskId;
+   private String projectId;
+   private String apiType;
+
+   public String getUrl() {
+      return this.url;
+   }
+
+   public void setUrl(String url) {
+      this.url = url;
+   }
+
+   public String getRequestWay() {
+      return this.requestWay;
+   }
+
+   public void setRequestWay(String requestWay) {
+      this.requestWay = requestWay;
+   }
+
+   public String getState() {
+      return this.state;
+   }
+
+   public void setState(String state) {
+      this.state = state;
+   }
+
+   public String getHeaderParameterId() {
+      return this.headerParameterId;
+   }
+
+   public void setHeaderParameterId(String headerParameterId) {
+      this.headerParameterId = headerParameterId;
+   }
+
+   public String getSysParameterId() {
+      return this.sysParameterId;
+   }
+
+   public void setSysParameterId(String sysParameterId) {
+      this.sysParameterId = sysParameterId;
+   }
+
+   public String getTaskId() {
+      return this.taskId;
+   }
+
+   public void setTaskId(String taskId) {
+      this.taskId = taskId;
+   }
+
+   public String getProjectId() {
+      return this.projectId;
+   }
+
+   public void setProjectId(String projectId) {
+      this.projectId = projectId;
+   }
+
+   public String getApiType() {
+      return this.apiType;
+   }
+
+   public void setApiType(String apiType) {
+      this.apiType = apiType;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/entity/param/scheduler/AddSchedulerParam.java

+package com.chenyang.nse.bussiness.entity.param.scheduler;
+
+import java.util.List;
+
+public class AddSchedulerParam {
+   private String id;
+   private String srName;
+   private String rulesType;
+   private String rulesDay;
+   private String rulesHour;
+   private String rulesMinute;
+   private String rulesMonth;
+   private String rulesYear;
+   private String rulestime;
+   private String ruleValidity;
+   private String createTime;
+   private String projectid;
+   private String[] xzlist;
+   private String qx;
+   private String xloptions;
+   private String howtime;
+   private String timebox;
+   private List<SaveTaskParam> saveTask;
+
+   public String getQx() {
+      return this.qx;
+   }
+
+   public void setQx(String qx) {
+      this.qx = qx;
+   }
+
+   public String getXloptions() {
+      return this.xloptions;
+   }
+
+   public void setXloptions(String xloptions) {
+      this.xloptions = xloptions;
+   }
+
+   public String getHowtime() {
+      return this.howtime;
+   }
+
+   public void setHowtime(String howtime) {
+      this.howtime = howtime;
+   }
+
+   public String getTimebox() {
+      return this.timebox;
+   }
+
+   public void setTimebox(String timebox) {
+      this.timebox = timebox;
+   }
+
+   public String[] getXzlist() {
+      return this.xzlist;
+   }
+
+   public void setXzlist(String[] xzlist) {
+      this.xzlist = xzlist;
+   }
+
+   public String getRulestime() {
+      return this.rulestime;
+   }
+
+   public void setRulestime(String rulestime) {
+      this.rulestime = rulestime;
+   }
+
+   public String getProjectid() {
+      return this.projectid;
+   }
+
+   public void setProjectid(String projectid) {
+      this.projectid = projectid;
+   }
+
+   public String getId() {
+      return this.id;
+   }
+
+   public void setId(String id) {
+      this.id = id;
+   }
+
+   public String getSrName() {
+      return this.srName;
+   }
+
+   public void setSrName(String srName) {
+      this.srName = srName;
+   }
+
+   public String getRulesType() {
+      return this.rulesType;
+   }
+
+   public void setRulesType(String rulesType) {
+      this.rulesType = rulesType;
+   }
+
+   public String getRulesDay() {
+      return this.rulesDay;
+   }
+
+   public void setRulesDay(String rulesDay) {
+      this.rulesDay = rulesDay;
+   }
+
+   public String getRulesHour() {
+      return this.rulesHour;
+   }
+
+   public void setRulesHour(String rulesHour) {
+      this.rulesHour = rulesHour;
+   }
+
+   public String getRulesMinute() {
+      return this.rulesMinute;
+   }
+
+   public void setRulesMinute(String rulesMinute) {
+      this.rulesMinute = rulesMinute;
+   }
+
+   public List<SaveTaskParam> getSaveTask() {
+      return this.saveTask;
+   }
+
+   public void setSaveTask(List<SaveTaskParam> saveTask) {
+      this.saveTask = saveTask;
+   }
+
+   public String getRuleValidity() {
+      return this.ruleValidity;
+   }
+
+   public void setRuleValidity(String ruleValidity) {
+      this.ruleValidity = ruleValidity;
+   }
+
+   public String getCreateTime() {
+      return this.createTime;
+   }
+
+   public void setCreateTime(String createTime) {
+      this.createTime = createTime;
+   }
+
+   public String getRulesMonth() {
+      return this.rulesMonth;
+   }
+
+   public void setRulesMonth(String rulesMonth) {
+      this.rulesMonth = rulesMonth;
+   }
+
+   public String getRulesYear() {
+      return this.rulesYear;
+   }
+
+   public void setRulesYear(String rulesYear) {
+      this.rulesYear = rulesYear;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/entity/vo/api/AccountabilityVO.java

+package com.chenyang.nse.bussiness.entity.vo.api;
+
+public class AccountabilityVO {
+   private String duty_id;
+   private String duty_name;
+   private String duty_scope;
+   private String duty_main;
+   private String tablename;
+   private String schemaname;
+   private String sysname;
+   private String joinid;
+   private String jointype;
+
+   public String getTablename() {
+      return this.tablename;
+   }
+
+   public void setTablename(String tablename) {
+      this.tablename = tablename;
+   }
+
+   public String getSchemaname() {
+      return this.schemaname;
+   }
+
+   public void setSchemaname(String schemaname) {
+      this.schemaname = schemaname;
+   }
+
+   public String getSysname() {
+      return this.sysname;
+   }
+
+   public void setSysname(String sysname) {
+      this.sysname = sysname;
+   }
+
+   public String getJoinid() {
+      return this.joinid;
+   }
+
+   public void setJoinid(String joinid) {
+      this.joinid = joinid;
+   }
+
+   public String getJointype() {
+      return this.jointype;
+   }
+
+   public void setJointype(String jointype) {
+      this.jointype = jointype;
+   }
+
+   public String getDuty_id() {
+      return this.duty_id;
+   }
+
+   public void setDuty_id(String duty_id) {
+      this.duty_id = duty_id;
+   }
+
+   public String getDuty_name() {
+      return this.duty_name;
+   }
+
+   public void setDuty_name(String duty_name) {
+      this.duty_name = duty_name;
+   }
+
+   public String getDuty_scope() {
+      return this.duty_scope;
+   }
+
+   public void setDuty_scope(String duty_scope) {
+      this.duty_scope = duty_scope;
+   }
+
+   public String getDuty_main() {
+      return this.duty_main;
+   }
+
+   public void setDuty_main(String duty_main) {
+      this.duty_main = duty_main;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/entity/vo/auditlog/AccessPojo.java

+package com.chenyang.nse.bussiness.entity.vo.auditlog;
+
+import java.util.List;
+
+public class AccessPojo {
+   private String type;
+   private String datetime;
+   private String username;
+   private String schema;
+   private List<String> tags;
+   private List<String> tables;
+   private Long records;
+   private String action;
+   private String sql;
+   private String sqltype;
+   private List<String> fileds;
+
+   public String getDatetime() {
+      return this.datetime;
+   }
+
+   public void setDatetime(String datetime) {
+      this.datetime = datetime;
+   }
+
+   public String getUsername() {
+      return this.username;
+   }
+
+   public void setUsername(String username) {
+      this.username = username;
+   }
+
+   public String getSchema() {
+      return this.schema;
+   }
+
+   public void setSchema(String schema) {
+      this.schema = schema;
+   }
+
+   public List<String> getTags() {
+      return this.tags;
+   }
+
+   public void setTags(List<String> tags) {
+      this.tags = tags;
+   }
+
+   public List<String> getTables() {
+      return this.tables;
+   }
+
+   public void setTables(List<String> tables) {
+      this.tables = tables;
+   }
+
+   public Long getRecords() {
+      return this.records;
+   }
+
+   public void setRecords(Long records) {
+      this.records = records;
+   }
+
+   public String getAction() {
+      return this.action;
+   }
+
+   public void setAction(String action) {
+      this.action = action;
+   }
+
+   public String getSql() {
+      return this.sql;
+   }
+
+   public void setSql(String sql) {
+      this.sql = sql;
+   }
+
+   public List<String> getFileds() {
+      return this.fileds;
+   }
+
+   public void setFileds(List<String> fileds) {
+      this.fileds = fileds;
+   }
+
+   public String getType() {
+      return this.type;
+   }
+
+   public void setType(String type) {
+      this.type = type;
+   }
+
+   public String getSqltype() {
+      return this.sqltype;
+   }
+
+   public void setSqltype(String sqltype) {
+      this.sqltype = sqltype;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/entity/webApi/ApiCode.java

+package com.chenyang.nse.bussiness.entity.webApi;
+
+public enum ApiCode {
+   ok("0", ""),
+   invaliadConfig("10", "无效的配置信息"),
+   encFailed("20", "加密失败%s"),
+   decFailed("30", "解密失败%s"),
+   dataOverflow("40", "超过数据处理上线,传入的数据量为:%s"),
+   unconfig("50", "未配置加密信息:%s"),
+   other("999", "其它未知异常:%s");
+
+   private String code;
+   private String text;
+
+   public String getCode() {
+      return this.code;
+   }
+
+   public String getText() {
+      return this.text;
+   }
+
+   private ApiCode(String code, String text) {
+      this.code = code;
+      this.text = text;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/kms/controller/AccessTokenController.java

+package com.chenyang.nse.bussiness.kms.controller;
+
+import com.chenyang.nse.bussiness.kms.service.KmsService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping({"kms"})
+public class AccessTokenController {
+   protected Logger logger = LoggerFactory.getLogger(this.getClass());
+   @Autowired
+   protected KmsService kmsService;
+
+   @RequestMapping({"accesstoken"})
+   public String accessToken() throws Exception {
+      return this.kmsService.obtainAccessToken(this.kmsService.obtainChallengeCode());
+   }
+}

src/main/java/com/chenyang/nse/bussiness/odbc/ApiHandler.java

+package com.chenyang.nse.bussiness.odbc;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.chenyang.nse.bussiness.odbc.business.OdbcApi;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import java.nio.charset.StandardCharsets;
+
+public class ApiHandler extends ChannelInboundHandlerAdapter {
+   public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+      ByteBuf byteBuf = (ByteBuf)msg;
+      byte[] buffer = new byte[byteBuf.readableBytes()];
+      byteBuf.readBytes(buffer);
+      Object response = OdbcApi.service(buffer);
+      String json = "{}";
+      if (response != null) {
+         if (response instanceof String) {
+            json = (String)response;
+         } else {
+            ObjectMapper mapper = new ObjectMapper();
+            json = mapper.writeValueAsString(response);
+         }
+      }
+
+      json = json + "\n\n";
+      byte[] jsonBuf = json.getBytes(StandardCharsets.UTF_8);
+      ByteBuf buf = Unpooled.wrappedBuffer(jsonBuf);
+      ctx.writeAndFlush(buf);
+      buf.clear();
+   }
+}

src/main/java/com/chenyang/nse/bussiness/service/core/AllwaysMonitorService.java

+package com.chenyang.nse.bussiness.service.core;
+
+import com.chenyang.nse.bussiness.engine.infa.InfoProperty;
+import com.chenyang.nse.bussiness.engine.infa.basic.webservice.SessionBean;
+import com.chenyang.nse.bussiness.entity.orm.table.core.TCoreImporttask;
+import com.chenyang.nse.bussiness.entity.orm.table.core.masking.TCoreMaskingTask;
+import com.chenyang.nse.bussiness.entity.orm.table.core.masking.TCoreSyncKeyindex;
+import com.chenyang.nse.bussiness.entity.orm.table.core.maskingself.TCoreMaskingselfTask;
+import java.sql.Connection;
+import java.util.List;
+import java.util.Map;
+
+public interface AllwaysMonitorService {
+   SessionBean getLog(String taskid);
+
+   SessionBean getTime(String taskid);
+
+   boolean stopwork(String taskid, String wfname);
+
+   boolean recoverywork(String taskid, String wfname);
+
+   SessionBean getLogForTaskMapping(TCoreMaskingTask task, InfoProperty engine, String name);
+
+   SessionBean getLogForImpMapping(TCoreMaskingTask task, InfoProperty engine, TCoreImporttask timptask);
+
+   TCoreImporttask getImpTask(TCoreMaskingTask task);
+
+   SessionBean getLogForSelfTaskMapping(TCoreMaskingselfTask task, InfoProperty engine, String name);
+
+   SessionBean getRunid(TCoreMaskingTask task, InfoProperty engine, String name);
+
+   Connection getConnectionByDataSystemId(String datasystemid);
+
+   List<Map<String, String>> getSyncPrimary(String taskid, String sourcename, String targetname);
+
+   List<Map<String, String>> getSyncIndex(String taskid, String sourcename, String targetname);
+
+   TCoreSyncKeyindex getSyncKeyIndex(String taskid, String sourcename);
+
+   SessionBean getSessionLog(TCoreMaskingTask task, String wfname, InfoProperty engine);
+}

src/main/java/com/chenyang/nse/bussiness/service/core/ApiDirectoryService.java

+package com.chenyang.nse.bussiness.service.core;
+
+import com.chenyang.nse.bussiness.entity.vo.api.DiscoverApiDirectoryVO;
+import java.util.List;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional
+public interface ApiDirectoryService {
+   List<DiscoverApiDirectoryVO> getDiscoverApiDirectory(String projectid, String editionid);
+
+   List<DiscoverApiDirectoryVO> getSortApiDirectory(String projectid, String editionid);
+
+   List<DiscoverApiDirectoryVO> getLevelApiDirectory(String projectid, String editionid);
+
+   List<DiscoverApiDirectoryVO> getComplianceApiDirectory(String projectid, String editionid);
+
+   List<DiscoverApiDirectoryVO> getDesensitizationApiDirectory(String projectid, String editionid);
+
+   List<DiscoverApiDirectoryVO> getAccountabilityApiDirectory(String projectid, String editionid);
+}

src/main/java/com/chenyang/nse/bussiness/service/core/api/AccountabilityAPIService.java

+package com.chenyang.nse.bussiness.service.core.api;
+
+import com.chenyang.nse.bussiness.entity.orm.table.core.duty.DutyTableInfo;
+import com.chenyang.nse.bussiness.entity.vo.api.AccountabilityVO;
+import java.util.List;
+
+public interface AccountabilityAPIService {
+   List<AccountabilityVO> selectAccountabilityInfo(DutyTableInfo obj);
+}

src/main/java/com/chenyang/nse/bussiness/service/core/api/ApiHeaderParameterService.java

+package com.chenyang.nse.bussiness.service.core.api;
+
+import com.chenyang.nse.bussiness.entity.orm.table.core.api.ApiHeaderParameter;
+import java.util.List;
+
+public interface ApiHeaderParameterService {
+   List<ApiHeaderParameter> querylist();
+}

src/main/java/com/chenyang/nse/bussiness/service/core/api/impl/AccountabilityAPIServiceImpl.java

+package com.chenyang.nse.bussiness.service.core.api.impl;
+
+import com.chenyang.nse.bussiness.dao.table.core.api.AccountabilityAPIDao;
+import com.chenyang.nse.bussiness.entity.orm.table.core.duty.DutyTableInfo;
+import com.chenyang.nse.bussiness.entity.vo.api.AccountabilityVO;
+import com.chenyang.nse.bussiness.service.core.api.AccountabilityAPIService;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AccountabilityAPIServiceImpl implements AccountabilityAPIService {
+   @Autowired
+   private AccountabilityAPIDao accountabilityAPIDao;
+
+   public List<AccountabilityVO> selectAccountabilityInfo(DutyTableInfo obj) {
+      return obj.getProjectid() == null ? this.accountabilityAPIDao.selectAccountabilityInfo(obj.getDatasystemid()) : this.accountabilityAPIDao.selectAccountabilityInfo(obj.getProjectid(), obj.getDatasystemid(), obj.getId());
+   }
+}

src/main/java/com/chenyang/nse/bussiness/service/core/api/impl/ApiHeaderParameterServiceImpl.java

+package com.chenyang.nse.bussiness.service.core.api.impl;
+
+import com.chenyang.nse.bussiness.dao.table.core.api.ApiHeaderParameterDao;
+import com.chenyang.nse.bussiness.entity.orm.table.core.api.ApiHeaderParameter;
+import com.chenyang.nse.bussiness.service.core.api.ApiHeaderParameterService;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional
+public class ApiHeaderParameterServiceImpl implements ApiHeaderParameterService {
+   @Autowired
+   private ApiHeaderParameterDao apiHeaderParameterDao;
+
+   public List<ApiHeaderParameter> querylist() {
+      List<ApiHeaderParameter> list = this.apiHeaderParameterDao.queryAll();
+      return list;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/service/core/impl/AllwaysMonitorServiceImpl.java

+package com.chenyang.nse.bussiness.service.core.impl;
+
+import com.chenyang.nse.bussiness.commmon.ApplicationConstants;
+import com.chenyang.nse.bussiness.dao.core.EngineDao;
+import com.chenyang.nse.bussiness.dao.table.core.TCoreDatasystemDao;
+import com.chenyang.nse.bussiness.dao.table.core.TCoreEngineDao;
+import com.chenyang.nse.bussiness.dao.table.core.TCoreImporttaskDao;
+import com.chenyang.nse.bussiness.dao.table.core.TCoreMaskingtaskDao;
+import com.chenyang.nse.bussiness.dao.table.core.masking.TCoreMaskingTableDao;
+import com.chenyang.nse.bussiness.dao.table.core.masking.TCoreMaskingTablecolumnDao;
+import com.chenyang.nse.bussiness.dao.table.core.masking.TCoreSyncKeyindexDao;
+import com.chenyang.nse.bussiness.engine.infa.InfoProperty;
+import com.chenyang.nse.bussiness.engine.infa.basic.webservice.LoginWebService;
+import com.chenyang.nse.bussiness.engine.infa.basic.webservice.LogoutWebService;
+import com.chenyang.nse.bussiness.engine.infa.basic.webservice.MultiGetSessionLogWebService;
+import com.chenyang.nse.bussiness.engine.infa.basic.webservice.MultiGetSessionStatisticsWebService;
+import com.chenyang.nse.bussiness.engine.infa.basic.webservice.MultiGetSessionTimeWebService;
+import com.chenyang.nse.bussiness.engine.infa.basic.webservice.MultiGetWorkflowLogWebService;
+import com.chenyang.nse.bussiness.engine.infa.basic.webservice.SessionBean;
+import com.chenyang.nse.bussiness.engine.infa.powercenter961.pubtool.InfoExecUtil;
+import com.chenyang.nse.bussiness.entity.db.IndexInfo;
+import com.chenyang.nse.bussiness.entity.db.PrimaryKeyInfo;
+import com.chenyang.nse.bussiness.entity.orm.table.core.TCoreDatasystem;
+import com.chenyang.nse.bussiness.entity.orm.table.core.TCoreEngine;
+import com.chenyang.nse.bussiness.entity.orm.table.core.TCoreImporttask;
+import com.chenyang.nse.bussiness.entity.orm.table.core.masking.TCoreMaskingTable;
+import com.chenyang.nse.bussiness.entity.orm.table.core.masking.TCoreMaskingTablecolumn;
+import com.chenyang.nse.bussiness.entity.orm.table.core.masking.TCoreMaskingTask;
+import com.chenyang.nse.bussiness.entity.orm.table.core.masking.TCoreSyncKeyindex;
+import com.chenyang.nse.bussiness.entity.orm.table.core.maskingself.TCoreMaskingselfTask;
+import com.chenyang.nse.bussiness.enumeration.EdbType;
+import com.chenyang.nse.bussiness.enumeration.EmaskingDirection;
+import com.chenyang.nse.bussiness.service.core.AllwaysMonitorService;
+import com.chenyang.nse.bussiness.service.core.MaskingTaskService;
+import com.chenyang.nse.bussiness.tools.jdbc.JdbcTool;
+import com.chenyang.nse.bussiness.tools.object.ObjectTool;
+import com.chenyang.nse.bussiness.tools.string.AesTool;
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.hibernate.criterion.Criterion;
+import org.hibernate.criterion.Restrictions;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AllwaysMonitorServiceImpl implements AllwaysMonitorService {
+   @Autowired
+   private TCoreMaskingtaskDao tCoreMaskingtaskDao;
+   @Autowired
+   private TCoreEngineDao tCoreEngineDao;
+   @Autowired
+   private EngineDao engineDao;
+   @Autowired
+   private MaskingTaskService maskingTaskService;
+   @Autowired
+   private TCoreImporttaskDao tCoreImporttaskDao;
+   @Autowired
+   private TCoreMaskingTableDao tCoreMaskingTableDao;
+   @Autowired
+   private TCoreDatasystemDao tCoreDatasystemDao;
+   @Autowired
+   private TCoreMaskingTablecolumnDao tCoreMaskingTablecolumnDao;
+   @Autowired
+   private TCoreSyncKeyindexDao tCoreSyncKeyindexDao;
+
+   public SessionBean getLog(String taskid) {
+      TCoreMaskingTask task = (TCoreMaskingTask)this.tCoreMaskingtaskDao.get(taskid);
+      TCoreEngine tengine = (TCoreEngine)this.tCoreEngineDao.get(task.getEngineid());
+      Map<String, Object> map = this.engineDao.queryEnginePropertyKeyValue(tengine.getId());
+      InfoProperty engine = (InfoProperty)ObjectTool.getObjectByMap(InfoProperty.class, map);
+      SessionBean se = new SessionBean();
+      return se;
+   }
+
+   public SessionBean getTime(String taskid) {
+      return null;
+   }
+
+   public SessionBean getLogForImpMapping(TCoreMaskingTask task, InfoProperty engine, TCoreImporttask timptask) {
+      SessionBean se = new SessionBean();
+
+      try {
+         String sessionID = LoginWebService.returnStatus(engine);
+         se = MultiGetSessionStatisticsWebService.returnStatus(sessionID, engine.getDomainname(), engine.getInteservicename(), timptask.getWfname(), timptask.getMpname(), timptask.getSename(), task.getFdname());
+         se.setTask_name(task.getTaskname());
+         SessionBean sb1 = MultiGetSessionTimeWebService.returnStatus(sessionID, engine.getDomainname(), engine.getInteservicename(), timptask.getWfname(), timptask.getMpname(), timptask.getSename(), task.getFdname());
+         se.setStart_time(sb1.getStart_time());
+         se.setEnd_time(sb1.getEnd_time());
+         LogoutWebService.returnStatus(sessionID, engine);
+      } catch (Exception var7) {
+         se.setStatus("SUCCEED");
+      }
+
+      return se;
+   }
+
+   public SessionBean getLogForTaskMapping(TCoreMaskingTask task, InfoProperty engine, String name) {
+      SessionBean se = new SessionBean();
+
+      try {
+         String sessionID = LoginWebService.returnStatus(engine);
+         se = MultiGetSessionStatisticsWebService.returnStatus(sessionID, engine, "wf_" + name, "mp_" + name, task.getFdname());
+         SessionBean sb1 = MultiGetSessionTimeWebService.returnStatus(sessionID, engine, "wf_" + name, "mp_" + name, task.getFdname());
+         se.setStart_time(sb1.getStart_time());
+         se.setEnd_time(sb1.getEnd_time());
+         LogoutWebService.returnStatus(sessionID, engine);
+      } catch (Exception var7) {
+         se.setStatus("SUCCEED");
+      }
+
+      return se;
+   }
+
+   public SessionBean getSessionLog(TCoreMaskingTask task, String wfname, InfoProperty engine) {
+      SessionBean se = new SessionBean();
+
+      try {
+         String sessionID = LoginWebService.returnStatus(engine);
+         String selog = MultiGetSessionLogWebService.returnStatus(sessionID, engine, "wf_" + wfname, "mp_" + wfname, task.getFdname());
+         se.setSe_log(selog);
+         LogoutWebService.returnStatus(sessionID, engine);
+      } catch (Exception var7) {
+         se.setStatus("SUCCEED");
+      }
+
+      return se;
+   }
+
+   public SessionBean getRunid(TCoreMaskingTask task, InfoProperty engine, String name) {
+      SessionBean se = new SessionBean();
+
+      try {
+         String sessionID = LoginWebService.returnStatus(engine);
+         se = MultiGetSessionStatisticsWebService.returnStatus(sessionID, engine, "wf_" + name, "mp_" + name, task.getFdname());
+         LogoutWebService.returnStatus(sessionID, engine);
+      } catch (Exception var6) {
+         se.setStatus("SUCCEED");
+      }
+
+      return se;
+   }
+
+   public SessionBean getLogForSelfTaskMapping(TCoreMaskingselfTask task, InfoProperty engine, String name) {
+      SessionBean se = new SessionBean();
+
+      try {
+         String sessionID = LoginWebService.returnStatus(engine);
+         se = MultiGetSessionStatisticsWebService.returnStatus(sessionID, engine, "wf_" + name, "mp_" + name, task.getFdname());
+         String selog = MultiGetSessionLogWebService.returnStatus(sessionID, engine, "wf_" + name, "mp_" + name, task.getFdname());
+         se.setSe_log(selog);
+         String wflog = MultiGetWorkflowLogWebService.returnStatus(sessionID, engine, "wf_" + name, "mp_" + name, task.getFdname(), se.getWf_run_id());
+         se.setWf_log(wflog);
+         SessionBean sb1 = MultiGetSessionTimeWebService.returnStatus(sessionID, engine, "wf_" + name, "mp_" + name, task.getFdname());
+         se.setStart_time(sb1.getStart_time());
+         se.setEnd_time(sb1.getEnd_time());
+         LogoutWebService.returnStatus(sessionID, engine);
+      } catch (Exception var9) {
+         se.setStatus("SUCCEED");
+      }
+
+      return se;
+   }
+
+   public boolean stopwork(String taskid, String wfname) {
+      TCoreMaskingTask task = (TCoreMaskingTask)this.tCoreMaskingtaskDao.get(taskid);
+      TCoreEngine tengine = (TCoreEngine)this.tCoreEngineDao.get(task.getEngineid());
+      Map<String, Object> map = this.engineDao.queryEnginePropertyKeyValue(tengine.getId());
+      InfoProperty engine = (InfoProperty)ObjectTool.getObjectByMap(InfoProperty.class, map);
+
+      try {
+         InfoExecUtil.executStopWorkflow(ApplicationConstants.pmcmd_path, engine.getInteservicename(), engine.getUsername(), engine.getPassword(), task.getFdname(), wfname);
+      } catch (Exception e) {
+         e.printStackTrace();
+      }
+
+      return true;
+   }
+
+   public boolean recoverywork(String taskid, String wfname) {
+      TCoreMaskingTask task = (TCoreMaskingTask)this.tCoreMaskingtaskDao.get(taskid);
+      TCoreEngine tengine = (TCoreEngine)this.tCoreEngineDao.get(task.getEngineid());
+      Map<String, Object> map = this.engineDao.queryEnginePropertyKeyValue(tengine.getId());
+      InfoProperty engine = (InfoProperty)ObjectTool.getObjectByMap(InfoProperty.class, map);
+
+      try {
+         InfoExecUtil.executStopWorkflow(ApplicationConstants.pmcmd_path, engine.getInteservicename(), engine.getUsername(), engine.getPassword(), task.getFdname(), wfname);
+      } catch (Exception e) {
+         e.printStackTrace();
+      }
+
+      return true;
+   }
+
+   public TCoreImporttask getImpTask(TCoreMaskingTask task) {
+      new TCoreImporttask();
+      TCoreImporttask imptask = (TCoreImporttask)this.tCoreImporttaskDao.queryUnique(new Criterion[]{Restrictions.eq("taskname", task.getTaskname())});
+      return imptask;
+   }
+
+   public Connection getConnectionByDataSystemId(String datasystemid) {
+      TCoreDatasystem datasystem = (TCoreDatasystem)this.tCoreDatasystemDao.get(datasystemid);
+      String dbcode = datasystem.getDbtype();
+      String ip = datasystem.getDbip();
+      String port = datasystem.getDbport();
+      String servername = datasystem.getDbservername();
+      String server = datasystem.getServername();
+      String url = "";
+      switch (datasystem.getDbtype()) {
+         case "INFORMIX":
+            url = EdbType.getUrlByEdbcode(dbcode, ip, port, servername, server);
+            break;
+         default:
+            url = EdbType.getUrlByEdbcode(dbcode, ip, port, servername);
+      }
+
+      String username = datasystem.getUsername();
+      String password = AesTool.decrypt(datasystem.getPassword(), "ghca");
+      String driver = EdbType.getEdbTypeByDbcode(dbcode).getDbdriver();
+      Connection conn = JdbcTool.getConnection(driver, url, username, password);
+      return conn;
+   }
+
+   public List<Map<String, String>> getSyncPrimary(String taskid, String sourcename, String targetname) {
+      List<Map<String, String>> list = new ArrayList();
+      List<TCoreMaskingTable> slist = this.tCoreMaskingTableDao.queryAll(new Criterion[]{Restrictions.eq("datadirection", EmaskingDirection.DATA_SOURCE.getFlag()), Restrictions.eq("taskid", taskid), Restrictions.eq("tablename", sourcename)});
+      if (slist.isEmpty()) {
+         return null;
+      } else {
+         List<TCoreMaskingTablecolumn> sclist = this.tCoreMaskingTablecolumnDao.queryAll(new Criterion[]{Restrictions.eq("tableid", ((TCoreMaskingTable)slist.get(0)).getId())});
+         Connection sconn = this.getConnectionByDataSystemId(((TCoreMaskingTable)slist.get(0)).getDatasystemid());
+         List<String> sprimarykey = PrimaryKeyInfo.getPrimaryKeyList(sconn, ((TCoreMaskingTable)slist.get(0)).getDbschema(), ((TCoreMaskingTable)slist.get(0)).getTablename());
+         JdbcTool.closeConnection(sconn);
+         if (sprimarykey != null && !sprimarykey.isEmpty()) {
+            List<Map<String, String>> splist = new ArrayList();
+
+            for(String str : sprimarykey) {
+               for(TCoreMaskingTablecolumn t : sclist) {
+                  if (str.equals(t.getColumnname())) {
+                     Map<String, String> smap = new HashMap();
+                     smap.put("columnname", str);
+                     smap.put("mappingkey", t.getMappingkey());
+                     splist.add(smap);
+                     break;
+                  }
+               }
+            }
+
+            List<TCoreMaskingTable> tlist = this.tCoreMaskingTableDao.queryAll(new Criterion[]{Restrictions.eq("datadirection", EmaskingDirection.DATA_TARGET.getFlag()), Restrictions.eq("taskid", taskid), Restrictions.eq("tablename", targetname)});
+            Connection tconn = this.getConnectionByDataSystemId(((TCoreMaskingTable)tlist.get(0)).getDatasystemid());
+            List<String> tprimarykey = PrimaryKeyInfo.getPrimaryKeyList(tconn, ((TCoreMaskingTable)tlist.get(0)).getDbschema(), ((TCoreMaskingTable)tlist.get(0)).getTablename());
+            JdbcTool.closeConnection(tconn);
+            if (tprimarykey != null && !tprimarykey.isEmpty()) {
+               for(Map<String, String> item : splist) {
+                  Map<String, String> map = new HashMap();
+                  List<TCoreMaskingTablecolumn> tclist = this.tCoreMaskingTablecolumnDao.queryAll(new Criterion[]{Restrictions.eq("mappingkey", item.get("mappingkey"))});
+                  Boolean b = tprimarykey.contains(((TCoreMaskingTablecolumn)tclist.get(0)).getColumnname());
+                  map.put("name", item.get("columnname"));
+                  map.put("state", b.toString());
+                  list.add(map);
+               }
+
+               return list;
+            } else {
+               for(String str : sprimarykey) {
+                  Map<String, String> map = new HashMap();
+                  map.put("name", str);
+                  map.put("state", "false");
+                  list.add(map);
+               }
+
+               return list;
+            }
+         } else {
+            return null;
+         }
+      }
+   }
+
+   public List<Map<String, String>> getSyncIndex(String taskid, String sourcename, String targetname) {
+      List<Map<String, String>> list = new ArrayList();
+      List<TCoreMaskingTable> slist = this.tCoreMaskingTableDao.queryAll(new Criterion[]{Restrictions.eq("datadirection", EmaskingDirection.DATA_SOURCE.getFlag()), Restrictions.eq("taskid", taskid), Restrictions.eq("tablename", sourcename)});
+      if (slist.isEmpty()) {
+         return null;
+      } else {
+         List<TCoreMaskingTablecolumn> sclist = this.tCoreMaskingTablecolumnDao.queryAll(new Criterion[]{Restrictions.eq("tableid", ((TCoreMaskingTable)slist.get(0)).getId())});
+         Connection sconn = this.getConnectionByDataSystemId(((TCoreMaskingTable)slist.get(0)).getDatasystemid());
+         List<String> sindex = IndexInfo.getIndexInfoList(sconn, ((TCoreMaskingTable)slist.get(0)).getDbschema(), ((TCoreMaskingTable)slist.get(0)).getTablename());
+         JdbcTool.closeConnection(sconn);
+         if (sindex != null && !sindex.isEmpty()) {
+            List<Map<String, String>> splist = new ArrayList();
+
+            for(String str : sindex) {
+               for(TCoreMaskingTablecolumn t : sclist) {
+                  if (str.equals(t.getColumnname())) {
+                     Map<String, String> smap = new HashMap();
+                     smap.put("columnname", str);
+                     smap.put("mappingkey", t.getMappingkey());
+                     splist.add(smap);
+                     break;
+                  }
+               }
+            }
+
+            List<TCoreMaskingTable> tlist = this.tCoreMaskingTableDao.queryAll(new Criterion[]{Restrictions.eq("datadirection", EmaskingDirection.DATA_TARGET.getFlag()), Restrictions.eq("taskid", taskid), Restrictions.eq("tablename", targetname)});
+            Connection tconn = this.getConnectionByDataSystemId(((TCoreMaskingTable)tlist.get(0)).getDatasystemid());
+            List<String> tindex = IndexInfo.getIndexInfoList(tconn, ((TCoreMaskingTable)tlist.get(0)).getDbschema(), ((TCoreMaskingTable)tlist.get(0)).getTablename());
+            JdbcTool.closeConnection(tconn);
+            if (tindex != null && !tindex.isEmpty()) {
+               for(Map<String, String> item : splist) {
+                  Map<String, String> map = new HashMap();
+                  List<TCoreMaskingTablecolumn> tclist = this.tCoreMaskingTablecolumnDao.queryAll(new Criterion[]{Restrictions.eq("mappingkey", item.get("mappingkey"))});
+                  Boolean b = tindex.contains(((TCoreMaskingTablecolumn)tclist.get(0)).getColumnname());
+                  map.put("name", item.get("columnname"));
+                  map.put("state", b.toString());
+                  list.add(map);
+               }
+
+               return list;
+            } else {
+               for(String str : sindex) {
+                  Map<String, String> map = new HashMap();
+                  map.put("name", str);
+                  map.put("state", "false");
+                  list.add(map);
+               }
+
+               return list;
+            }
+         } else {
+            return null;
+         }
+      }
+   }
+
+   public TCoreSyncKeyindex getSyncKeyIndex(String taskid, String sourcename) {
+      TCoreSyncKeyindex tCoreSyncKeyindex = (TCoreSyncKeyindex)this.tCoreSyncKeyindexDao.queryUnique(new Criterion[]{Restrictions.eq("taskid", taskid), Restrictions.eq("tasktableid", sourcename)});
+      return tCoreSyncKeyindex;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/service/core/impl/ApiDirectoryServiceImpl.java

+package com.chenyang.nse.bussiness.service.core.impl;
+
+import com.chenyang.nse.bussiness.dao.core.ComplianceDirectoryDao;
+import com.chenyang.nse.bussiness.dao.core.DataScopeDao;
+import com.chenyang.nse.bussiness.dao.core.ProEditionScopeDao;
+import com.chenyang.nse.bussiness.dao.core.SensitiveLevelDao;
+import com.chenyang.nse.bussiness.dao.table.core.dataproject.TCoreDataAreaDao;
+import com.chenyang.nse.bussiness.dao.table.core.duty.DutyTableInfoDao;
+import com.chenyang.nse.bussiness.dao.table.core.masking.TCoreMaskingRuleinfoDao;
+import com.chenyang.nse.bussiness.entity.orm.table.core.dataproject.TCoreDataArea;
+import com.chenyang.nse.bussiness.entity.orm.table.core.dataproject.TCoreDataProject;
+import com.chenyang.nse.bussiness.entity.orm.table.core.discovery.TcoreDiscoveryTask;
+import com.chenyang.nse.bussiness.entity.orm.table.core.duty.DutyTableInfo;
+import com.chenyang.nse.bussiness.entity.orm.table.core.masking.TCoreMaskingRuleinfo;
+import com.chenyang.nse.bussiness.entity.orm.table.core.scopeproject.TProEditionScope;
+import com.chenyang.nse.bussiness.entity.vo.api.DiscoverApiDirectoryVO;
+import com.chenyang.nse.bussiness.entity.vo.dataproject.DatasystemProjectdatasourceVO;
+import com.chenyang.nse.bussiness.service.core.ApiDirectoryService;
+import com.chenyang.nse.bussiness.service.core.DataScopeService;
+import com.chenyang.nse.bussiness.service.core.SensitiveLevelService;
+import com.chenyang.nse.bussiness.service.core.TdataDiscoveryService;
+import com.chenyang.nse.bussiness.service.core.TdataProjectService;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.apache.commons.lang3.StringUtils;
+import org.hibernate.criterion.Criterion;
+import org.hibernate.criterion.Restrictions;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional
+public class ApiDirectoryServiceImpl implements ApiDirectoryService {
+   @Autowired
+   private TdataProjectService tdataProjectService;
+   @Autowired
+   private TdataDiscoveryService tdataDiscoveryService;
+   @Autowired
+   private DataScopeService dataScopeService;
+   @Autowired
+   private DataScopeDao dataScopeDao;
+   @Autowired
+   private TCoreDataAreaDao tCoreDataAreaDao;
+   @Autowired
+   private ProEditionScopeDao proEditionScopeDao;
+   @Autowired
+   private TCoreMaskingRuleinfoDao TCoreMaskingRuleinfoDao;
+   @Autowired
+   private SensitiveLevelService sensitiveLevelService;
+   @Autowired
+   private SensitiveLevelDao sensitiveLevelDao;
+   @Autowired
+   private ComplianceDirectoryDao complianceDirectoryDao;
+   @Autowired
+   private DutyTableInfoDao dutyTableInfoDao;
+
+   public List<DiscoverApiDirectoryVO> getDiscoverApiDirectory(String projectid, String editionid) {
+      List<DiscoverApiDirectoryVO> trees = new ArrayList();
+      List<TCoreDataProject> list = this.tdataProjectService.selectDataProject();
+
+      List<TCoreDataProject> listNew = (List)list.stream().filter((e) -> e.getId().equals(projectid) && e.getEdition_id().equals(editionid)).collect(Collectors.toList());
+      for(TCoreDataProject tCoreDataProject : listNew) {
+         DiscoverApiDirectoryVO discoverApiDirectoryVO = new DiscoverApiDirectoryVO();
+         discoverApiDirectoryVO.setId(tCoreDataProject.getId());
+         discoverApiDirectoryVO.setText(tCoreDataProject.getProject());
+         List<TcoreDiscoveryTask> taskList = this.tdataDiscoveryService.queryDiscoverytasklistByProjectId(tCoreDataProject.getId());
+         List<DiscoverApiDirectoryVO> childrenList = new ArrayList();
+
+         for(TcoreDiscoveryTask tcoreDiscoveryTask : taskList) {
+            DiscoverApiDirectoryVO discoverApiDirectoryChildren = new DiscoverApiDirectoryVO();
+            discoverApiDirectoryChildren.setId(tcoreDiscoveryTask.getId());
+            discoverApiDirectoryChildren.setProjectId(projectid);
+            discoverApiDirectoryChildren.setText(tcoreDiscoveryTask.getTname());
+            discoverApiDirectoryChildren.setFa_tid(tCoreDataProject.getId());
+            if ("2".equals(tcoreDiscoveryTask.getDiscoverytype())) {
+               if (StringUtils.isNotBlank(tcoreDiscoveryTask.getIsdmpflag())) {
+                  discoverApiDirectoryChildren.setType("21");
+               } else {
+                  discoverApiDirectoryChildren.setType("22");
+               }
+            } else {
+               discoverApiDirectoryChildren.setType("2");
+            }
+
+            childrenList.add(discoverApiDirectoryChildren);
+         }
+
+         if (childrenList.size() > 0) {
+            discoverApiDirectoryVO.setState("closed");
+         }
+
+         discoverApiDirectoryVO.setChildren(childrenList);
+         trees.add(discoverApiDirectoryVO);
+      }
+
+      return trees;
+   }
+
+   private List<DiscoverApiDirectoryVO> buildTree(List<DiscoverApiDirectoryVO> list, String parentId) {
+      List<DiscoverApiDirectoryVO> trees = new ArrayList();
+
+      for(DiscoverApiDirectoryVO entity : list) {
+         String menuId = entity.getId();
+         String pid = entity.getFa_tid();
+         if (parentId.equals(pid)) {
+            List<DiscoverApiDirectoryVO> menuLists = this.buildTree(list, menuId);
+            entity.setChildren(menuLists);
+            trees.add(entity);
+         }
+      }
+
+      return trees;
+   }
+
+   public List<DiscoverApiDirectoryVO> getSortApiDirectory(String projectid, String editionid) {
+      List<DiscoverApiDirectoryVO> trees = new ArrayList();
+      List<TCoreDataProject> list = this.tdataProjectService.selectDataProject();
+
+      List<TCoreDataProject> listNew = (List)list.stream().filter((e) -> e.getId().equals(projectid) && e.getEdition_id().equals(editionid)).collect(Collectors.toList());
+      for(TCoreDataProject tCoreDataProject : listNew) {
+         DiscoverApiDirectoryVO discoverApiDirectoryVO = new DiscoverApiDirectoryVO();
+         discoverApiDirectoryVO.setId(tCoreDataProject.getId());
+         discoverApiDirectoryVO.setText(tCoreDataProject.getProject());
+         List<TProEditionScope> tProEditionScopeList = this.dataScopeService.geteditionlistByEditionId(editionid);
+         List<DiscoverApiDirectoryVO> projectChildrenList = new ArrayList();
+
+         for(TProEditionScope tProEditionScope : tProEditionScopeList) {
+            DiscoverApiDirectoryVO versionApiDirectoryVO = new DiscoverApiDirectoryVO();
+            versionApiDirectoryVO.setId(tProEditionScope.getId());
+            versionApiDirectoryVO.setText(tProEditionScope.getEdition_name());
+            versionApiDirectoryVO.setFa_tid(tCoreDataProject.getId());
+            List<DiscoverApiDirectoryVO> sortlist = this.dataScopeDao.getDataScopeDirectory(tProEditionScope.getId());
+            List<DiscoverApiDirectoryVO> levellist = this.sensitiveLevelDao.getLevelDirectory(editionid);
+            List<DiscoverApiDirectoryVO> compliancelist = this.complianceDirectoryDao.getComplianceDirectory(tCoreDataProject.getEdition_id());
+            versionApiDirectoryVO.setChildren(this.getFLFJAPIList(sortlist, levellist, compliancelist, editionid, projectid));
+            projectChildrenList.add(versionApiDirectoryVO);
+         }
+
+         if (projectChildrenList.size() > 0) {
+            discoverApiDirectoryVO.setState("closed");
+         }
+
+         discoverApiDirectoryVO.setChildren(projectChildrenList);
+         trees.add(discoverApiDirectoryVO);
+      }
+
+      return trees;
+   }
+
+   private List<DiscoverApiDirectoryVO> getFLFJAPIList(List<DiscoverApiDirectoryVO> sortlist, List<DiscoverApiDirectoryVO> levellist, List<DiscoverApiDirectoryVO> compliancelist, String editionid, String projectid) {
+      List<DiscoverApiDirectoryVO> resultList = new ArrayList();
+      DiscoverApiDirectoryVO flVO = new DiscoverApiDirectoryVO();
+
+      for(DiscoverApiDirectoryVO vo1 : sortlist) {
+         vo1.setProjectId(projectid);
+      }
+
+      flVO.setFa_tid(editionid);
+      flVO.setText("分类API");
+      flVO.setChildren(this.buildTree(sortlist, "全部"));
+      DiscoverApiDirectoryVO fjVO = new DiscoverApiDirectoryVO();
+
+      for(DiscoverApiDirectoryVO vo2 : levellist) {
+         vo2.setProjectId(projectid);
+      }
+
+      fjVO.setFa_tid(editionid);
+      fjVO.setText("分级API");
+      fjVO.setProjectId(projectid);
+      fjVO.setChildren(this.buildTree(levellist, "全部"));
+      DiscoverApiDirectoryVO hgVO = new DiscoverApiDirectoryVO();
+
+      for(DiscoverApiDirectoryVO vo3 : compliancelist) {
+         vo3.setProjectId(projectid);
+      }
+
+      hgVO.setFa_tid(editionid);
+      hgVO.setText("合规API");
+      hgVO.setProjectId(projectid);
+      hgVO.setChildren(this.buildTree(compliancelist, "全部"));
+      resultList.add(flVO);
+      resultList.add(fjVO);
+      resultList.add(hgVO);
+      return resultList;
+   }
+
+   public List<DiscoverApiDirectoryVO> getLevelApiDirectory(String projectid, String editionid) {
+      List<DiscoverApiDirectoryVO> trees = new ArrayList();
+      List<TCoreDataProject> list = this.tdataProjectService.selectDataProject();
+
+      List<TCoreDataProject> listNew = (List)list.stream().filter((e) -> e.getId().equals(projectid) && e.getEdition_id().equals(editionid)).collect(Collectors.toList());
+      for(TCoreDataProject tCoreDataProject : listNew) {
+         DiscoverApiDirectoryVO discoverApiDirectoryVO = new DiscoverApiDirectoryVO();
+         discoverApiDirectoryVO.setId(tCoreDataProject.getId());
+         discoverApiDirectoryVO.setText(tCoreDataProject.getProject());
+         List<DiscoverApiDirectoryVO> projectChildrenList = new ArrayList();
+         TProEditionScope tProEditionLevel = (TProEditionScope)this.proEditionScopeDao.queryUnique(new Criterion[]{Restrictions.eq("id", editionid)});
+         DiscoverApiDirectoryVO versionApiDirectoryVO = new DiscoverApiDirectoryVO();
+         versionApiDirectoryVO.setId(tProEditionLevel.getId());
+         versionApiDirectoryVO.setText(tProEditionLevel.getEdition_name());
+         versionApiDirectoryVO.setFa_tid(tCoreDataProject.getId());
+         versionApiDirectoryVO.setType("4");
+         versionApiDirectoryVO.setProjectId(tCoreDataProject.getId());
+         List<DiscoverApiDirectoryVO> levellist = this.sensitiveLevelDao.getLevelDirectory(tProEditionLevel.getId());
+         versionApiDirectoryVO.setChildren(this.buildTree(levellist, "全部"));
+         projectChildrenList.add(versionApiDirectoryVO);
+         if (projectChildrenList.size() > 0) {
+            discoverApiDirectoryVO.setState("closed");
+         }
+
+         discoverApiDirectoryVO.setChildren(projectChildrenList);
+         trees.add(discoverApiDirectoryVO);
+      }
+
+      return trees;
+   }
+
+   public List<DiscoverApiDirectoryVO> getComplianceApiDirectory(String projectid, String editionid) {
+      List<DiscoverApiDirectoryVO> trees = new ArrayList();
+      List<TCoreDataProject> list = this.tdataProjectService.selectDataProject();
+
+      List<TCoreDataProject> listNew = (List)list.stream().filter((e) -> e.getId().equals(projectid) && e.getEdition_id().equals(editionid)).collect(Collectors.toList());
+      for(TCoreDataProject tCoreDataProject : listNew) {
+         DiscoverApiDirectoryVO discoverApiDirectoryVO = new DiscoverApiDirectoryVO();
+         discoverApiDirectoryVO.setId(tCoreDataProject.getId());
+         discoverApiDirectoryVO.setText(tCoreDataProject.getProject());
+         discoverApiDirectoryVO.setProjectId(tCoreDataProject.getId());
+         List<DiscoverApiDirectoryVO> compliancelist = this.complianceDirectoryDao.getComplianceDirectory(tCoreDataProject.getEdition_id());
+         discoverApiDirectoryVO.setChildren(this.buildTree(compliancelist, "全部"));
+         trees.add(discoverApiDirectoryVO);
+      }
+
+      return trees;
+   }
+
+   public List<DiscoverApiDirectoryVO> getDesensitizationApiDirectory(String projectid, String editionid) {
+      List<DiscoverApiDirectoryVO> trees = new ArrayList();
+      List<TCoreDataArea> tCoreDataAreaList = this.tCoreDataAreaDao.queryAll();
+      if (tCoreDataAreaList != null) {
+         for(TCoreDataArea tCoreDataArea : tCoreDataAreaList) {
+            DiscoverApiDirectoryVO discoverApiDirectoryVO = new DiscoverApiDirectoryVO();
+            discoverApiDirectoryVO.setId(tCoreDataArea.getId());
+            discoverApiDirectoryVO.setText(tCoreDataArea.getDataarea());
+            List<TCoreMaskingRuleinfo> tCoreMaskingRuleinfoList = this.TCoreMaskingRuleinfoDao.queryAll(new Criterion[]{Restrictions.eq("dataarea_id", tCoreDataArea.getId())});
+            List<DiscoverApiDirectoryVO> childrenList = new ArrayList();
+
+            for(TCoreMaskingRuleinfo tCoreMaskingRuleinfo : tCoreMaskingRuleinfoList) {
+               DiscoverApiDirectoryVO discoverApiDirectoryChildren = new DiscoverApiDirectoryVO();
+               discoverApiDirectoryChildren.setId(tCoreMaskingRuleinfo.getId());
+               discoverApiDirectoryChildren.setText(tCoreMaskingRuleinfo.getName());
+               discoverApiDirectoryChildren.setFa_tid(tCoreDataArea.getId());
+               discoverApiDirectoryChildren.setMappletname(tCoreMaskingRuleinfo.getMappletname());
+               childrenList.add(discoverApiDirectoryChildren);
+            }
+
+            if (childrenList.size() > 0) {
+               discoverApiDirectoryVO.setState("closed");
+            }
+
+            discoverApiDirectoryVO.setType("6");
+            discoverApiDirectoryVO.setChildren(childrenList);
+            trees.add(discoverApiDirectoryVO);
+         }
+      }
+
+      return trees;
+   }
+
+   public List<DiscoverApiDirectoryVO> getAccountabilityApiDirectory(String projectid, String editionid) {
+      List<DiscoverApiDirectoryVO> trees = new ArrayList();
+      List<DatasystemProjectdatasourceVO> dataSourceList = this.tdataProjectService.queryDatasystemByProId(projectid);
+      if (dataSourceList != null) {
+         for(DatasystemProjectdatasourceVO vo : dataSourceList) {
+            DiscoverApiDirectoryVO discoverApiDirectoryVO = new DiscoverApiDirectoryVO();
+            discoverApiDirectoryVO.setId(vo.getTid());
+            discoverApiDirectoryVO.setText(vo.getSysname());
+            List<DutyTableInfo> schemalist = this.dutyTableInfoDao.querySchemaList(projectid, vo.getTid());
+            List<DiscoverApiDirectoryVO> childrenList = new ArrayList();
+
+            for(DutyTableInfo dutyTableInfo : schemalist) {
+               DiscoverApiDirectoryVO discoverApiDirectoryChildren = new DiscoverApiDirectoryVO();
+               discoverApiDirectoryChildren.setId(vo.getTid());
+               discoverApiDirectoryChildren.setText(dutyTableInfo.getSchemaname());
+               discoverApiDirectoryChildren.setType("7");
+               discoverApiDirectoryChildren.setProjectId(projectid);
+               List<DutyTableInfo> tablelist = this.dutyTableInfoDao.queryTableList(projectid, vo.getTid(), dutyTableInfo.getSchemaname());
+               List<DiscoverApiDirectoryVO> sonList = new ArrayList();
+
+               for(DutyTableInfo d : tablelist) {
+                  DiscoverApiDirectoryVO discoverApiDirectoryChildrenSon = new DiscoverApiDirectoryVO();
+                  discoverApiDirectoryChildrenSon.setId(d.getId());
+                  discoverApiDirectoryChildrenSon.setProjectId(projectid);
+                  discoverApiDirectoryChildrenSon.setEdition_id(vo.getTid());
+                  discoverApiDirectoryChildrenSon.setText(d.getTablename());
+                  discoverApiDirectoryChildrenSon.setType("8");
+                  discoverApiDirectoryChildrenSon.setProjectId(projectid);
+                  sonList.add(discoverApiDirectoryChildrenSon);
+               }
+
+               discoverApiDirectoryChildren.setChildren(sonList);
+               childrenList.add(discoverApiDirectoryChildren);
+            }
+
+            if (childrenList.size() > 0) {
+               discoverApiDirectoryVO.setState("closed");
+            }
+
+            discoverApiDirectoryVO.setType("6");
+            discoverApiDirectoryVO.setProjectId(projectid);
+            discoverApiDirectoryVO.setChildren(childrenList);
+            trees.add(discoverApiDirectoryVO);
+         }
+      }
+
+      return trees;
+   }
+}

src/main/java/com/chenyang/nse/bussiness/tools/encryption/AesEncryptUtils.java

+package com.chenyang.nse.bussiness.tools.encryption;
+
+import com.chenyang.nse.bussiness.config.PropertiesLoaderUtils;
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.security.Security;
+import java.util.Properties;
+import javax.crypto.Cipher;
+import javax.crypto.KeyGenerator;
+import javax.crypto.spec.GCMParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.lang3.StringUtils;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
+import org.bouncycastle.util.encoders.Hex;
+
+public class AesEncryptUtils {
+   private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";
+   private static final String ENCRYPT_ALGO = "AES/GCM/NoPadding";
+   private static final String ALGORITHM_NAME = "AES";
+   public static final int DEF_KEY_SIZE = 128;
+   public static final int DEF_KEY_SIZE_256 = 256;
+   public static final int DEF_KEY_SIZE_192 = 192;
+   public static final byte[] IV = new byte[]{-80, 104, -85, -96, -31, -90, 1, 120, 35, 121, 26, 41};
+   private static final String ENCODING = "UTF-8";
+   private static Properties properties;
+   private static String ENCRYPT_LIKE_SPLIT;
+   private static final String ENCRYPT_LIKE_OPEN = "1";
+
+   public static String encrypt_ecb(String encryptKey, String paramStr, String isLike, String keepfirst, String encdigit, String twoindex) throws Exception {
+      KeyGenerator kgen = KeyGenerator.getInstance("AES");
+      kgen.init(128);
+      Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+      byte[] keyData = ByteUtils.fromHexString(encryptKey);
+      cipher.init(1, new SecretKeySpec(keyData, "AES"));
+      String prefix = null;
+      String enc = paramStr;
+      String suffix = null;
+      if (!StringUtils.isBlank(keepfirst)) {
+         if (!"0".equals(keepfirst) && !"1".equals(keepfirst)) {
+            if (!"2".equals(keepfirst)) {
+               return paramStr;
+            }
+
+            int first = 0;
+            if (StringUtils.isNotBlank(encdigit)) {
+               first = Integer.parseInt(encdigit);
+            }
+
+            int last = 0;
+            if (StringUtils.isNotBlank(twoindex)) {
+               last = Integer.parseInt(twoindex);
+            }
+
+            if (first + last >= paramStr.length() || first >= paramStr.length() || last >= paramStr.length()) {
+               return paramStr;
+            }
+
+            prefix = paramStr.substring(0, first);
+            enc = paramStr.substring(first, paramStr.length() - last);
+            suffix = paramStr.substring(paramStr.length() - last);
+         } else if (StringUtils.isNotBlank(encdigit)) {
+            if (Integer.parseInt(encdigit) >= paramStr.length()) {
+               return paramStr;
+            }
+
+            if (Integer.parseInt(encdigit) != 0) {
+               if ("0".equals(keepfirst)) {
+                  prefix = paramStr.substring(0, Integer.parseInt(encdigit));
+                  enc = paramStr.substring(Integer.parseInt(encdigit));
+               } else if ("1".equals(keepfirst)) {
+                  enc = paramStr.substring(0, paramStr.length() - Integer.parseInt(encdigit));
+                  suffix = paramStr.substring(paramStr.length() - Integer.parseInt(encdigit));
+               }
+            }
+         }
+      }
+
+      String encResult;
+      if ("1".equals(isLike)) {
+         StringBuilder sb = new StringBuilder();
+
+         for(int i = 0; i < enc.length(); ++i) {
+            char c = enc.charAt(i);
+            byte[] srcData = (c + "").getBytes("UTF-8");
+            byte[] b = cipher.doFinal(srcData);
+            String s = Base64.encodeBase64String(b);
+            sb.append(s).append(ENCRYPT_LIKE_SPLIT);
+         }
+
+         encResult = sb.deleteCharAt(sb.length() - 1).toString();
+      } else {
+         byte[] b = cipher.doFinal(enc.getBytes("UTF-8"));
+         encResult = Base64.encodeBase64String(b);
+      }
+
+      if ("0".equals(keepfirst) && null != prefix) {
+         encResult = prefix + encResult;
+      } else if ("1".equals(keepfirst) && null != suffix) {
+         encResult = encResult + suffix;
+      } else if ("2".equals(keepfirst)) {
+         if (null != prefix) {
+            encResult = prefix + encResult;
+         }
+
+         if (null != suffix) {
+            encResult = encResult + suffix;
+         }
+      }
+
+      return encResult;
+   }
+
+   public static String encrypt(String encryptKey, String paramStr, String isLike, String keepfirst, String encdigit, String twoindex) throws Exception {
+      byte[] keyBytes = Hex.decode(encryptKey);
+      String prefix = null;
+      String enc = paramStr;
+      String suffix = null;
+      if (!StringUtils.isBlank(keepfirst)) {
+         if (!"0".equals(keepfirst) && !"1".equals(keepfirst)) {
+            if (!"2".equals(keepfirst)) {
+               return paramStr;
+            }
+
+            int first = 0;
+            if (StringUtils.isNotBlank(encdigit)) {
+               first = Integer.parseInt(encdigit);
+            }
+
+            int last = 0;
+            if (StringUtils.isNotBlank(twoindex)) {
+               last = Integer.parseInt(twoindex);
+            }
+
+            if (first + last >= paramStr.length() || first >= paramStr.length() || last >= paramStr.length()) {
+               return paramStr;
+            }
+
+            prefix = paramStr.substring(0, first);
+            enc = paramStr.substring(first, paramStr.length() - last);
+            suffix = paramStr.substring(paramStr.length() - last);
+         } else if (StringUtils.isNotBlank(encdigit)) {
+            if (Integer.parseInt(encdigit) >= paramStr.length()) {
+               return paramStr;
+            }
+
+            if (Integer.parseInt(encdigit) != 0) {
+               if ("0".equals(keepfirst)) {
+                  prefix = paramStr.substring(0, Integer.parseInt(encdigit));
+                  enc = paramStr.substring(Integer.parseInt(encdigit));
+               } else if ("1".equals(keepfirst)) {
+                  enc = paramStr.substring(0, paramStr.length() - Integer.parseInt(encdigit));
+                  suffix = paramStr.substring(paramStr.length() - Integer.parseInt(encdigit));
+               }
+            }
+         }
+      }
+
+      String encResult;
+      if ("1".equals(isLike)) {
+         StringBuilder sb = new StringBuilder();
+
+         for(int i = 0; i < enc.length(); ++i) {
+            char c = enc.charAt(i);
+            byte[] srcData = (c + "").getBytes("UTF-8");
+            SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
+            Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
+            cipher.init(1, keySpec, new GCMParameterSpec(128, IV));
+            byte[] ciphertext = cipher.doFinal(srcData);
+            String s = Hex.toHexString(ciphertext);
+            sb.append(s).append(ENCRYPT_LIKE_SPLIT);
+         }
+
+         encResult = sb.deleteCharAt(sb.length() - 1).toString();
+      } else {
+         byte[] srcData = enc.getBytes("UTF-8");
+         SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
+         Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
+         cipher.init(1, keySpec, new GCMParameterSpec(128, IV));
+         byte[] ciphertext = cipher.doFinal(srcData);
+         encResult = Hex.toHexString(ciphertext);
+      }
+
+      if ("0".equals(keepfirst) && null != prefix) {
+         encResult = prefix + encResult;
+      } else if ("1".equals(keepfirst) && null != suffix) {
+         encResult = encResult + suffix;
+      } else if ("2".equals(keepfirst)) {
+         if (null != prefix) {
+            encResult = prefix + encResult;
+         }
+
+         if (null != suffix) {
+            encResult = encResult + suffix;
+         }
+      }
+
+      return encResult;
+   }
+
+   public static String decrypt_ecb(String decryptKey, String paramStr, String isLike, String keepfirst, String encdigit, String twoindex) throws Exception {
+      KeyGenerator kgen = KeyGenerator.getInstance("AES");
+      kgen.init(128);
+      Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+      byte[] keyData = ByteUtils.fromHexString(decryptKey);
+      cipher.init(2, new SecretKeySpec(keyData, "AES"));
+      String prefix = null;
+      String enc = paramStr;
+      String suffix = null;
+      if (!StringUtils.isBlank(keepfirst)) {
+         if (!"0".equals(keepfirst) && !"1".equals(keepfirst)) {
+            if ("2".equals(keepfirst)) {
+               int first = 0;
+               if (StringUtils.isNotBlank(encdigit)) {
+                  first = Integer.parseInt(encdigit);
+               }
+
+               int last = 0;
+               if (StringUtils.isNotBlank(twoindex)) {
+                  last = Integer.parseInt(twoindex);
+               }
+
+               if (first + last >= paramStr.length() || first >= paramStr.length() || last >= paramStr.length()) {
+                  return paramStr;
+               }
+
+               prefix = paramStr.substring(0, first);
+               enc = paramStr.substring(first, paramStr.length() - last);
+               suffix = paramStr.substring(paramStr.length() - last);
+            }
+         } else if (StringUtils.isNotBlank(encdigit)) {
+            if (Integer.parseInt(encdigit) >= paramStr.length()) {
+               return paramStr;
+            }
+
+            if (Integer.parseInt(encdigit) != 0) {
+               if ("0".equals(keepfirst)) {
+                  prefix = paramStr.substring(0, Integer.parseInt(encdigit));
+                  enc = paramStr.substring(Integer.parseInt(encdigit));
+               } else if ("1".equals(keepfirst)) {
+                  enc = paramStr.substring(0, paramStr.length() - Integer.parseInt(encdigit));
+                  suffix = paramStr.substring(paramStr.length() - Integer.parseInt(encdigit));
+               }
+            }
+         }
+      }
+
+      String encResult;
+      if ("1".equals(isLike)) {
+         StringBuilder sb = new StringBuilder();
+         String[] split = enc.split(ENCRYPT_LIKE_SPLIT);
+
+         for(String s : split) {
+            try {
+               byte[] encryptBytes = Base64.decodeBase64(s);
+               byte[] decryptBytes = cipher.doFinal(encryptBytes);
+               sb.append(new String(decryptBytes));
+            } catch (Exception e) {
+               e.printStackTrace();
+            }
+         }
+
+         encResult = sb.toString();
+      } else {
+         byte[] encryptBytes = Base64.decodeBase64(enc);
+         byte[] decryptBytes = cipher.doFinal(encryptBytes);
+         encResult = new String(decryptBytes);
+      }
+
+      if ("0".equals(keepfirst) && null != prefix) {
+         encResult = prefix + encResult;
+      } else if ("1".equals(keepfirst) && null != suffix) {
+         encResult = encResult + suffix;
+      } else if ("2".equals(keepfirst)) {
+         if (null != prefix) {
+            encResult = prefix + encResult;
+         }
+
+         if (null != suffix) {
+            encResult = encResult + suffix;
+         }
+      }
+
+      return encResult;
+   }
+
+   public static String decrypt(String decryptKey, String paramStr, String isLike, String keepfirst, String encdigit, String twoindex) throws Exception {
+      byte[] keyBytes = Hex.decode(decryptKey);
+      String prefix = null;
+      String enc = paramStr;
+      String suffix = null;
+      if (!StringUtils.isBlank(keepfirst)) {
+         if (!"0".equals(keepfirst) && !"1".equals(keepfirst)) {
+            if ("2".equals(keepfirst)) {
+               int first = 0;
+               if (StringUtils.isNotBlank(encdigit)) {
+                  first = Integer.parseInt(encdigit);
+               }
+
+               int last = 0;
+               if (StringUtils.isNotBlank(twoindex)) {
+                  last = Integer.parseInt(twoindex);
+               }
+
+               if (first + last >= paramStr.length() || first >= paramStr.length() || last >= paramStr.length()) {
+                  return paramStr;
+               }
+
+               prefix = paramStr.substring(0, first);
+               enc = paramStr.substring(first, paramStr.length() - last);
+               suffix = paramStr.substring(paramStr.length() - last);
+            }
+         } else if (StringUtils.isNotBlank(encdigit)) {
+            if (Integer.parseInt(encdigit) >= paramStr.length()) {
+               return paramStr;
+            }
+
+            if (Integer.parseInt(encdigit) != 0) {
+               if ("0".equals(keepfirst)) {
+                  prefix = paramStr.substring(0, Integer.parseInt(encdigit));
+                  enc = paramStr.substring(Integer.parseInt(encdigit));
+               } else if ("1".equals(keepfirst)) {
+                  enc = paramStr.substring(0, paramStr.length() - Integer.parseInt(encdigit));
+                  suffix = paramStr.substring(paramStr.length() - Integer.parseInt(encdigit));
+               }
+            }
+         }
+      }
+
+      String encResult;
+      if ("1".equals(isLike)) {
+         StringBuilder sb = new StringBuilder();
+         String[] split = enc.split(ENCRYPT_LIKE_SPLIT);
+
+         for(String s : split) {
+            try {
+               byte[] encryptBytes = Hex.decode(s);
+               SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
+               Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
+               cipher.init(2, keySpec, new GCMParameterSpec(128, IV));
+               byte[] decryptedData = cipher.doFinal(encryptBytes);
+               sb.append(new String(decryptedData, "UTF-8"));
+            } catch (Exception e) {
+               e.printStackTrace();
+            }
+         }
+
+         encResult = sb.toString();
+      } else {
+         byte[] encryptBytes = Hex.decode(enc);
+         SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
+         Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
+         cipher.init(2, keySpec, new GCMParameterSpec(128, IV));
+         byte[] decryptedData = cipher.doFinal(encryptBytes);
+         encResult = new String(decryptedData, "UTF-8");
+      }
+
+      if ("0".equals(keepfirst) && null != prefix) {
+         encResult = prefix + encResult;
+      } else if ("1".equals(keepfirst) && null != suffix) {
+         encResult = encResult + suffix;
+      } else if ("2".equals(keepfirst)) {
+         if (null != prefix) {
+            encResult = prefix + encResult;
+         }
+
+         if (null != suffix) {
+            encResult = encResult + suffix;
+         }
+      }
+
+      return encResult;
+   }
+
+   public static String generaKey() throws Exception {
+      return Hex.toHexString(generaKey(128));
+   }
+
+   public static String generaKeyTwo() throws Exception {
+      return Hex.toHexString(generaKey(256));
+   }
+
+   public static String generaKeyThree() throws Exception {
+      return Hex.toHexString(generaKey(192));
+   }
+
+   public static byte[] generaKey(int keySize) throws Exception {
+      KeyGenerator kg = KeyGenerator.getInstance("AES");
+      kg.init(keySize, new SecureRandom());
+      return kg.generateKey().getEncoded();
+   }
+
+   public static void main(String[] args) throws Exception {
+      String key = generaKeyThree();
+      System.out.println(key);
+      String data = "111_aaaaaaaaaaaaa";
+      System.out.println(data);
+      String encrypt = encrypt(key, data, "1", "0", "3", (String)null);
+      System.out.println(encrypt);
+      String decrypt = decrypt(key, encrypt, "1", "0", "3", (String)null);
+      System.out.println(decrypt);
+      System.out.println(data.equals(decrypt));
+   }
+
+   static {
+      try {
+         properties = PropertiesLoaderUtils.loadAllProperties("config.properties");
+         ENCRYPT_LIKE_SPLIT = properties.get("encryption.like.split").toString();
+      } catch (IOException e) {
+         e.printStackTrace();
+      }
+
+      Security.addProvider(new BouncyCastleProvider());
+   }
+}

src/main/java/com/chenyang/nse/bussiness/tools/string/AesTool.java

+package com.chenyang.nse.bussiness.tools.string;
+
+import com.chenyang.nse.bussiness.tools.encryption.EncProvider;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import javax.crypto.BadPaddingException;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+
+public class AesTool {
+   private static final String PASSWORD_SM4_KEY = "D1439845B4270773520B1B2B269A4383";
+
+   public static String encrypt(String content, String password) {
+      try {
+         return EncProvider.encryptEcb("SM4", "D1439845B4270773520B1B2B269A4383", content, "0", (String)null, (String)null, (String)null);
+      } catch (Exception e) {
+         e.printStackTrace();
+         return null;
+      }
+   }
+
+   public static String decrypt(String content, String password) {
+      try {
+         return EncProvider.decryptEcb("SM4", "D1439845B4270773520B1B2B269A4383", content, "0", (String)null, (String)null, (String)null);
+      } catch (NoSuchAlgorithmException e) {
+         e.printStackTrace();
+      } catch (NoSuchPaddingException e) {
+         e.printStackTrace();
+      } catch (InvalidKeyException e) {
+         e.printStackTrace();
+      } catch (IllegalBlockSizeException e) {
+         e.printStackTrace();
+      } catch (BadPaddingException e) {
+         e.printStackTrace();
+      } catch (Exception e) {
+         e.printStackTrace();
+      }
+
+      return null;
+   }
+
+   public static String parseByte2HexStr(byte[] buf) {
+      StringBuffer sb = new StringBuffer();
+
+      for(int i = 0; i < buf.length; ++i) {
+         String hex = Integer.toHexString(buf[i] & 255);
+         if (hex.length() == 1) {
+            hex = '0' + hex;
+         }
+
+         sb.append(hex.toUpperCase());
+      }
+
+      return sb.toString();
+   }
+
+   public static byte[] parseHexStr2Byte(String hexStr) {
+      if (hexStr.length() < 1) {
+         return null;
+      } else {
+         byte[] result = new byte[hexStr.length() / 2];
+
+         for(int i = 0; i < hexStr.length() / 2; ++i) {
+            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
+            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
+            result[i] = (byte)(high * 16 + low);
+         }
+
+         return result;
+      }
+   }
+
+   public static void main(String[] args) {
+      String content = "mydata";
+      String password = "ghca";
+      System.out.println("加密之前：" + content);
+      String encrypt = encrypt(content, password);
+      System.out.println("加密后的内容：" + encrypt);
+      System.out.println("加密后字符串长度：" + encrypt.length());
+      String decrypt = decrypt(encrypt, password);
+      System.out.println("解密后的内容：" + new String(decrypt));
+   }
+}

src/main/java/com/chenyang/nse/bussiness/tools/xml/xmlclass/AddToc.java

+package com.chenyang.nse.bussiness.tools.xml.xmlclass;
+
+import com.spire.doc.Document;
+import com.spire.doc.FileFormat;
+import com.spire.doc.documents.HorizontalAlignment;
+import com.spire.doc.documents.Paragraph;
+import com.spire.doc.fields.TableOfContent;
+import com.spire.doc.fields.TextRange;
+import java.awt.Color;
+
+public class AddToc {
+   public static void AddToc(String path) {
+      Document doc = new Document(path);
+      Paragraph parainserted = new Paragraph(doc);
+      TextRange tr = parainserted.appendText("目 录");
+      tr.getCharacterFormat().setBold(true);
+      tr.getCharacterFormat().setTextColor(Color.gray);
+      doc.getSections().get(0).getParagraphs().insert(0, parainserted);
+      parainserted.getFormat().setHorizontalAlignment(HorizontalAlignment.Center);
+      new TableOfContent(doc, "{\\o \"1-3\" \\h \\z \\u}");
+      doc.getSections().get(0).getParagraphs().get(0).appendTOC(1, 3);
+      doc.updateTableOfContents();
+      doc.saveToFile(path, FileFormat.Docx_2010);
+   }
+}

src/main/java/com/chenyang/nse/bussiness/tools/xml/xmlclass/product/Address.java

+package com.chenyang.nse.bussiness.tools.xml.xmlclass.product;
+
+public class Address {
+   private String host;
+   private String port;
+
+   public String getHost() {
+      return this.host;
+   }
+
+   public void setHost(String host) {
+      this.host = host;
+   }
+
+   public String getPort() {
+      return this.port;
+   }
+
+   public void setPort(String port) {
+      this.port = port;
+   }
+}