From 925f4ef66b66424b11650474be90c5f24a8a5da4 Mon Sep 17 00:00:00 2001 From: "1437892690@qq.com" <1437892690@qq.com> Date: Sat, 7 Dec 2024 21:35:08 +0800 Subject: [PATCH] =?UTF-8?q?[=E5=8A=9F=E8=83=BD]=20IT=E6=9C=8D=E5=8A=A1-?= =?UTF-8?q?=E5=B7=A5=E5=8D=95=E6=95=B0=E6=8D=AE=E5=AF=BC=E5=85=A5=E5=AF=BC?= =?UTF-8?q?=E5=87=BA=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 关联 #[1306696935243776]IT服务-工单数据导入导出优化 http://192.168.0.96:8090/demo/rdm.html#/story-detail/939050947543040/939050947543042/1306696935243776 --- .../processtask/ExportProcessTaskDataApi.java | 152 ++++++++++++++++-- .../processtask/ImportProcessTaskDataApi.java | 132 +++++++++++++++ .../dao/mapper/ProcessTaskDataMapper.java | 4 + .../dao/mapper/ProcessTaskDataMapper.xml | 11 ++ 4 files changed, 284 insertions(+), 15 deletions(-) create mode 100644 src/main/java/neatlogic/module/process/api/processtask/ImportProcessTaskDataApi.java diff --git a/src/main/java/neatlogic/module/process/api/processtask/ExportProcessTaskDataApi.java b/src/main/java/neatlogic/module/process/api/processtask/ExportProcessTaskDataApi.java index fe37081b8..11e263f8f 100644 --- a/src/main/java/neatlogic/module/process/api/processtask/ExportProcessTaskDataApi.java +++ b/src/main/java/neatlogic/module/process/api/processtask/ExportProcessTaskDataApi.java @@ -1,5 +1,6 @@ package neatlogic.module.process.api.processtask; +import com.alibaba.fastjson.JSONObject; import neatlogic.framework.auth.core.AuthAction; import neatlogic.framework.common.constvalue.ApiParamType; import neatlogic.framework.process.auth.PROCESS_BASE; @@ -8,8 +9,8 @@ import neatlogic.framework.restful.constvalue.OperationTypeEnum; import neatlogic.framework.restful.core.privateapi.PrivateBinaryStreamApiComponentBase; import neatlogic.framework.util.FileUtil; import neatlogic.module.process.dao.mapper.ProcessTaskDataMapper; -import com.alibaba.fastjson.JSONObject; import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.MapUtils; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -18,6 +19,8 @@ import org.springframework.stereotype.Component; import javax.annotation.Resource; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; +import java.sql.Timestamp; +import java.text.SimpleDateFormat; import java.util.*; import java.util.zip.ZipEntry; import java.util.zip.ZipOutputStream; @@ -80,6 +83,10 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas if (processtask == null) { return resultObj; } + Map processtask_config = new HashMap<>(); + processtask_config.put("hash", processtask.remove("hash")); + processtask_config.put("config", processtask.remove("config")); + put(resultObj, "processtask_config", processtask_config); put(resultObj, "processtask", processtask); sql = "SELECT * FROM `process` WHERE `uuid` = '" + processtask.get("process_uuid") + "'"; @@ -122,6 +129,26 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas sql = "SELECT * FROM `channel_relation_isusepreowner` WHERE `source` = '" + channelUuid + "'"; List> channel_relation_isusepreowner = processTaskDataMapper.getList(sql); put(resultObj, "channel_relation_isusepreowner", channel_relation_isusepreowner); + + if (channel != null) { + sql = "SELECT * FROM `catalog` WHERE `uuid` = '" + channel.get("parent_uuid") + "'"; + Map catalog = processTaskDataMapper.getOne(sql); + if (catalog != null) { + sql = "SELECT * FROM `catalog` WHERE `lft` <= " + catalog.get("lft") + " AND `rht` >= " + catalog.get("rht"); + List catalogUuidList = new ArrayList<>(); + List> catalogList = processTaskDataMapper.getList(sql); + for (Map map : catalogList) { + catalogUuidList.add((String) map.get("uuid")); + } + if (CollectionUtils.isNotEmpty(catalogUuidList)) { + String catalogUuidListStr = String.join("','", catalogUuidList); + sql = "SELECT * FROM `catalog_authority` WHERE `catalog_uuid` IN ('" + catalogUuidListStr + "')"; + List> catalog_authority = processTaskDataMapper.getList(sql); + put(resultObj, "catalog_authority", catalog_authority); + } + put(resultObj, "catalog", catalogList); + } + } } { // 指派处理人 @@ -157,6 +184,18 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas // 工单表单配置信息 String sql = "SELECT a.*, b.* FROM `processtask_form` a LEFT JOIN `processtask_form_content` b ON b.`hash` = a.`form_content_hash` WHERE a.`processtask_id` = " + processTaskId; List> processtask_form = processTaskDataMapper.getList(sql); + List> processtask_form_content = new ArrayList<>(); + for (Map map : processtask_form) { + Object hash = map.remove("hash"); + Object content = map.remove("content"); + if (hash != null && content != null) { + Map newMap = new HashMap<>(); + newMap.put("hash", hash); + newMap.put("content", content); + processtask_form_content.add(newMap); + } + } + put(resultObj, "processtask_form_content", processtask_form_content); put(resultObj, "processtask_form", processtask_form); } { @@ -225,14 +264,29 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas } { // 评分 - String sql = "SELECT a.*, b.* FROM `processtask_score_content` a LEFT JOIN `processtask_content` b ON b.`hash` = a.`content_hash` WHERE a.`processtask_id` = " + processTaskId; + String sql = "SELECT * FROM `processtask_score_content` WHERE `processtask_id` = " + processTaskId; List> processtask_score_content = processTaskDataMapper.getList(sql); + for (Map map : processtask_score_content) { + addNotNullElement(contentHashSet, map.get("content_hash")); + } put(resultObj, "processtask_score_content", processtask_score_content); } { // 评分模板 String sql = "SELECT a.*, b.* FROM `processtask_score_template` a LEFT JOIN `processtask_score_template_config` b ON b.`hash` = a.`config_hash` WHERE a.`processtask_id` = " + processTaskId; List> processtask_score_template = processTaskDataMapper.getList(sql); + List> processtask_score_template_config = new ArrayList<>(); + for (Map map : processtask_score_template) { + Object hash = map.remove("hash"); + Object config = map.remove("config"); + if (hash != null && config != null) { + Map newMap = new HashMap<>(); + newMap.put("hash", hash); + newMap.put("config", config); + processtask_score_template_config.add(newMap); + } + } + put(resultObj, "processtask_score_template_config", processtask_score_template_config); put(resultObj, "processtask_score_template", processtask_score_template); } { @@ -280,14 +334,24 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas // 步骤列表 String sql = "SELECT a.*, b.* FROM `processtask_step` a LEFT JOIN `processtask_step_config` b ON b.`hash` = a.`config_hash` WHERE a.`processtask_id` = " + processTaskId; List> processtask_step = processTaskDataMapper.getList(sql); - put(resultObj, "processtask_step", processtask_step); + List> processtask_step_config = new ArrayList<>(); List stepIdList = new ArrayList<>(); for (Map map : processtask_step) { Object id = map.get("id"); if (id != null) { stepIdList.add(id.toString()); } + Object hash = map.remove("hash"); + Object config = map.remove("config"); + if (hash != null && config != null) { + Map newMap = new HashMap<>(); + newMap.put("hash", hash); + newMap.put("config", config); + processtask_step_config.add(newMap); + } } + put(resultObj, "processtask_step_config", processtask_step_config); + put(resultObj, "processtask_step", processtask_step); if (CollectionUtils.isNotEmpty(stepIdList)) { String stepIdListStr = String.join(",", stepIdList); sql = "SELECT * FROM `processtask_step_timeaudit` WHERE `processtask_step_id` IN (" + stepIdListStr + ")"; @@ -339,8 +403,11 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas } { // 步骤回复内容 - String sql = "SELECT a.*, b.* FROM `processtask_step_content` a LEFT JOIN `processtask_content` b ON b.`hash` = a.`content_hash` WHERE a.`processtask_id` = " + processTaskId; + String sql = "SELECT * FROM `processtask_step_content` WHERE `processtask_id` = " + processTaskId; List> processtask_step_content = processTaskDataMapper.getList(sql); + for (Map map : processtask_step_content) { + addNotNullElement(contentHashSet, map.get("content_hash")); + } put(resultObj, "processtask_step_content", processtask_step_content); } { @@ -426,8 +493,11 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas } { //步骤提醒信息 - String sql = "SELECT a.*, b.* FROM `processtask_step_remind` a LEFT JOIN `processtask_content` b ON b.`hash` = a.`content_hash` WHERE a.`processtask_id` = " + processTaskId; + String sql = "SELECT * FROM `processtask_step_remind` WHERE `processtask_id` = " + processTaskId; List> processtask_step_remind = processTaskDataMapper.getList(sql); + for (Map map : processtask_step_remind) { + addNotNullElement(contentHashSet, map.get("content_hash")); + } put(resultObj, "processtask_step_remind", processtask_step_remind); } { @@ -474,15 +544,16 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas } { //子任务 - String sql = "SELECT a.*, b.* FROM `processtask_step_task` a LEFT JOIN `processtask_content` b ON b.`hash` = a.`content_hash` WHERE a.`processtask_id` = " + processTaskId; + String sql = "SELECT * FROM `processtask_step_task` WHERE `processtask_id` = " + processTaskId; List> processtask_step_task = processTaskDataMapper.getList(sql); - put(resultObj, "processtask_step_task", processtask_step_task); List taskIdList = new ArrayList<>(); List taskConfigIdList = new ArrayList<>(); for (Map map : processtask_step_task) { taskIdList.add(map.get("id").toString()); taskConfigIdList.add(map.get("task_config_id").toString()); + addNotNullElement(contentHashSet, map.get("content_hash")); } + put(resultObj, "processtask_step_task", processtask_step_task); if (CollectionUtils.isNotEmpty(taskIdList)) { String taskIdListStr = String.join(",", taskIdList); sql = "SELECT * FROM `processtask_step_task_user` WHERE `processtask_step_task_id` IN (" + taskIdListStr + ")"; @@ -502,8 +573,11 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas fileIdSet.add(fileId.toString()); } } - sql = "SELECT a.*, b.* FROM `processtask_step_task_user_content` a LEFT JOIN `processtask_content` b ON b.`hash` = a.`content_hash` WHERE a.`processtask_step_task_id` IN (" + taskIdListStr + ")"; + sql = "SELECT * FROM `processtask_step_task_user_content` WHERE `processtask_step_task_id` IN (" + taskIdListStr + ")"; List> processtask_step_task_user_content = processTaskDataMapper.getList(sql); + for (Map map : processtask_step_task_user_content) { + addNotNullElement(contentHashSet, map.get("content_hash")); + } put(resultObj, "processtask_step_task_user_content", processtask_step_task_user_content); } if (CollectionUtils.isNotEmpty(taskConfigIdList)) { @@ -524,6 +598,7 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas changeIdSet.add(map.get("change_id").toString()); } if (CollectionUtils.isNotEmpty(changeIdSet)) { + Set changeContentHashSet = new HashSet<>(); String changeIdSetStr = String.join(",", changeIdSet); sql = "SELECT * FROM `change` WHERE `id` IN (" + changeIdSetStr + ")"; List> change = processTaskDataMapper.getList(sql); @@ -537,8 +612,11 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas List> change_change_template = processTaskDataMapper.getList(sql); put(resultObj, "change_change_template", change_change_template); - sql = "SELECT a.*, b.* FROM `change_description` a LEFT JOIN `change_content` b ON b.`hash` = a.`content_hash` WHERE a.`change_id` IN (" + changeIdSetStr + ")"; + sql = "SELECT * FROM `change_description` WHERE `change_id` IN (" + changeIdSetStr + ")"; List> change_description = processTaskDataMapper.getList(sql); + for (Map map : change_description) { + addNotNullElement(changeContentHashSet, map.get("content_hash")); + } put(resultObj, "change_description", change_description); sql = "SELECT * FROM `change_file` WHERE `change_id` IN (" + changeIdSetStr + ")"; @@ -554,12 +632,18 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas List> change_step = processTaskDataMapper.getList(sql); put(resultObj, "change_step", change_step); - sql = "SELECT a.*, b.* FROM `change_step_content` a LEFT JOIN `change_content` b ON b.`hash` = a.`content_hash` WHERE a.`change_id` IN (" + changeIdSetStr + ")"; + sql = "SELECT * FROM `change_step_content` WHERE `change_id` IN (" + changeIdSetStr + ")"; List> change_step_content = processTaskDataMapper.getList(sql); + for (Map map : change_step_content) { + addNotNullElement(changeContentHashSet, map.get("content_hash")); + } put(resultObj, "change_step_content", change_step_content); - sql = "SELECT a.*, b.* FROM `change_step_comment` a LEFT JOIN `change_content` b ON b.`hash` = a.`content_hash` WHERE a.`change_id` IN (" + changeIdSetStr + ")"; + sql = "SELECT * FROM `change_step_comment` WHERE `change_id` IN (" + changeIdSetStr + ")"; List> change_step_comment = processTaskDataMapper.getList(sql); + for (Map map : change_step_comment) { + addNotNullElement(changeContentHashSet, map.get("content_hash")); + } put(resultObj, "change_step_comment", change_step_comment); sql = "SELECT * FROM `change_step_file` WHERE `change_id` IN (" + changeIdSetStr + ")"; @@ -587,6 +671,13 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas sql = "SELECT * FROM `change_auto_start` WHERE `change_id` IN (" + changeIdSetStr + ")"; List> change_auto_start = processTaskDataMapper.getList(sql); put(resultObj, "change_auto_start", change_auto_start); + + if (CollectionUtils.isNotEmpty(changeContentHashSet)) { + String contentHashSetStr = String.join("','", changeContentHashSet); + sql = "SELECT * FROM `change_content` WHERE `hash` IN ('" + contentHashSetStr + "')"; + List> change_content = processTaskDataMapper.getList(sql); + put(resultObj, "change_content", change_content); + } } } @@ -644,11 +735,42 @@ public class ExportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBas set.add(obj); } - private void put(Map map, String key, Object value) { - if (map.containsKey(key)) { - ((ArrayList) map.computeIfAbsent("repeatKey", e -> new ArrayList())).add(key); + private void put(JSONObject resultObj, String key, Map map) { + if (resultObj.containsKey(key)) { + ((ArrayList) resultObj.computeIfAbsent("repeatKey", e -> new ArrayList())).add(key); + return; + } + parseDate(map); + resultObj.put(key, map); + } + + private void put(JSONObject resultObj, String key, List> list) { + if (resultObj.containsKey(key)) { + ((ArrayList) resultObj.computeIfAbsent("repeatKey", e -> new ArrayList())).add(key); return; } - map.put(key, value); + parseDate(list); + resultObj.put(key, list); + } + + private void parseDate(Map map) { + if (MapUtils.isNotEmpty(map)) { + Map dateMap = new HashMap<>(); + for (Map.Entry entry : map.entrySet()) { + Object value = entry.getValue(); + if (value instanceof Timestamp) { + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); + dateMap.put(entry.getKey(), simpleDateFormat.format((Timestamp) value)); + } + } + map.putAll(dateMap); + } + } + private void parseDate(List> list) { + if (CollectionUtils.isNotEmpty(list)) { + for (Map map : list) { + parseDate(map); + } + } } } diff --git a/src/main/java/neatlogic/module/process/api/processtask/ImportProcessTaskDataApi.java b/src/main/java/neatlogic/module/process/api/processtask/ImportProcessTaskDataApi.java new file mode 100644 index 000000000..7e2542ffa --- /dev/null +++ b/src/main/java/neatlogic/module/process/api/processtask/ImportProcessTaskDataApi.java @@ -0,0 +1,132 @@ +package neatlogic.module.process.api.processtask; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import neatlogic.framework.auth.core.AuthAction; +import neatlogic.framework.common.constvalue.ApiParamType; +import neatlogic.framework.common.util.FileUtil; +import neatlogic.framework.exception.file.FileNotFoundException; +import neatlogic.framework.file.dao.mapper.FileMapper; +import neatlogic.framework.file.dto.FileVo; +import neatlogic.framework.process.auth.PROCESS_BASE; +import neatlogic.framework.restful.annotation.*; +import neatlogic.framework.restful.constvalue.OperationTypeEnum; +import neatlogic.framework.restful.core.privateapi.PrivateBinaryStreamApiComponentBase; +import neatlogic.module.process.dao.mapper.ProcessTaskDataMapper; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.MapUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; +import org.springframework.transaction.annotation.Transactional; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; + +@Transactional +@Component +@AuthAction(action = PROCESS_BASE.class) +@OperationType(type = OperationTypeEnum.SEARCH) +public class ImportProcessTaskDataApi extends PrivateBinaryStreamApiComponentBase { + private final static Logger logger = LoggerFactory.getLogger(ImportProcessTaskDataApi.class); + + @Resource + private ProcessTaskDataMapper processTaskDataMapper; + + @Resource + private FileMapper fileMapper; + + @Override + public String getToken() { + return "processtask/data/import"; + } + + @Override + public String getName() { + return "导入工单相关表数据"; + } + + @Override + public String getConfig() { + return null; + } + + @Input({ + @Param(name = "fileId", type = ApiParamType.LONG, isRequired = true, desc = "common.fileid") + }) + @Output({}) + @Description(desc = "导入工单相关表数据") + @Override + public Object myDoService(JSONObject paramObj, HttpServletRequest request, HttpServletResponse response) throws Exception { + Long fileId = paramObj.getLong("fileId"); + FileVo fileVo = fileMapper.getFileById(fileId); + if (fileVo == null) { + throw new FileNotFoundException(fileId); + } + byte[] buf = new byte[1024]; + try (ZipInputStream zipIs = new ZipInputStream(FileUtil.getData(fileVo.getPath())); + ByteArrayOutputStream out = new ByteArrayOutputStream() + ) { + ZipEntry zipEntry = null; + while ((zipEntry = zipIs.getNextEntry()) != null) { + if (zipEntry.isDirectory()) { + continue; + } + out.reset(); + if (zipEntry.getName().endsWith(".json")) { + int len; + while ((len = zipIs.read(buf)) != -1) { + out.write(buf, 0, len); + } + JSONObject jsonObject = JSONObject.parseObject(new String(out.toByteArray(), StandardCharsets.UTF_8)); + if (MapUtils.isNotEmpty(jsonObject)) { + for (Map.Entry entry : jsonObject.entrySet()) { + String tableName = entry.getKey(); + Object value = entry.getValue(); + if (value != null) { + if (value instanceof JSONObject) { + JSONObject valueObject = (JSONObject) value; + if (MapUtils.isNotEmpty(valueObject)) { + List columnNameList = new ArrayList<>(); + List columnValueList = new ArrayList<>(); + for (Map.Entry entry1 : valueObject.entrySet()) { + columnNameList.add(entry1.getKey()); + columnValueList.add(entry1.getValue()); + } + processTaskDataMapper.insertOne(tableName, columnNameList, columnValueList); + } + } else if (value instanceof JSONArray) { + JSONArray valueArray = (JSONArray) value; + if (CollectionUtils.isNotEmpty(valueArray)) { + for (int i = 0; i < valueArray.size(); i++) { + JSONObject valueObject = valueArray.getJSONObject(i); + List columnNameList = new ArrayList<>(); + List columnValueList = new ArrayList<>(); + for (Map.Entry entry1 : valueObject.entrySet()) { + columnNameList.add(entry1.getKey()); + columnValueList.add(entry1.getValue()); + } + processTaskDataMapper.insertOne(tableName, columnNameList, columnValueList); + } + } + } + } + } + } + } + } + } catch (IOException e) { + logger.error(e.getMessage(), e); + } + return null; + } +} diff --git a/src/main/java/neatlogic/module/process/dao/mapper/ProcessTaskDataMapper.java b/src/main/java/neatlogic/module/process/dao/mapper/ProcessTaskDataMapper.java index 057675fcd..728370c31 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/ProcessTaskDataMapper.java +++ b/src/main/java/neatlogic/module/process/dao/mapper/ProcessTaskDataMapper.java @@ -1,5 +1,7 @@ package neatlogic.module.process.dao.mapper; +import org.apache.ibatis.annotations.Param; + import java.util.List; import java.util.Map; @@ -9,4 +11,6 @@ public interface ProcessTaskDataMapper { List> getList(String sql); Long getLong(String sql); + + int insertOne(@Param("tableName") String tableName, @Param("columnNameList") List columnNameList, @Param("columnValueList") List columnValueList); } diff --git a/src/main/java/neatlogic/module/process/dao/mapper/ProcessTaskDataMapper.xml b/src/main/java/neatlogic/module/process/dao/mapper/ProcessTaskDataMapper.xml index 6f69bba2c..aaf9044fc 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/ProcessTaskDataMapper.xml +++ b/src/main/java/neatlogic/module/process/dao/mapper/ProcessTaskDataMapper.xml @@ -27,4 +27,15 @@ along with this program. If not, see .--> + + + insert ignore into ${tableName} + + `${columnName}` + + values + + #{columnValue} + + \ No newline at end of file -- Gitee