diff --git a/src/main/java/neatlogic/module/cmdb/process/audithandler/handler/CmdbSyncSuccessMessageAuditHandler.java b/src/main/java/neatlogic/module/cmdb/process/audithandler/handler/CmdbSyncSuccessMessageAuditHandler.java new file mode 100644 index 0000000000000000000000000000000000000000..7f860b1b6ba9234a90778bf407c8c244d54f9af7 --- /dev/null +++ b/src/main/java/neatlogic/module/cmdb/process/audithandler/handler/CmdbSyncSuccessMessageAuditHandler.java @@ -0,0 +1,52 @@ +package neatlogic.module.cmdb.process.audithandler.handler; + +import com.alibaba.fastjson.JSONObject; +import neatlogic.framework.cmdb.dto.transaction.TransactionVo; +import neatlogic.framework.process.audithandler.core.IProcessTaskStepAuditDetailHandler; +import neatlogic.framework.process.dto.ProcessTaskStepAuditDetailVo; +import neatlogic.framework.util.TableResultUtil; +import neatlogic.module.cmdb.dao.mapper.transaction.TransactionMapper; +import neatlogic.module.cmdb.process.constvalue.CmdbAuditDetailType; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.StringUtils; +import org.springframework.stereotype.Component; + +import javax.annotation.Resource; +import java.util.List; + +@Component +public class CmdbSyncSuccessMessageAuditHandler implements IProcessTaskStepAuditDetailHandler { + + @Resource + private TransactionMapper transactionMapper; + + @Override + public String getType() { + return CmdbAuditDetailType.CMDBSYNCMESSAGE.getValue(); + } + + @Override + public int handle(ProcessTaskStepAuditDetailVo processTaskStepAuditDetailVo) { + String newContent = processTaskStepAuditDetailVo.getNewContent(); + if (StringUtils.isBlank(newContent)) { + return 0; + } + Long transactionGroupId; + try { + transactionGroupId = Long.valueOf(newContent); + } catch (Exception e) { + return 1; + } + if (transactionGroupId == null) { + return 0; + } + TransactionVo transactionVo = new TransactionVo(); + transactionVo.setTransactionGroupId(transactionGroupId); + List transactionList = transactionMapper.searchTransaction(transactionVo); + if (CollectionUtils.isEmpty(transactionList)) { + return 0; + } + processTaskStepAuditDetailVo.setNewContent(JSONObject.toJSONString(TableResultUtil.getResult(transactionList))); + return 1; + } +} diff --git a/src/main/java/neatlogic/module/cmdb/process/constvalue/CmdbAuditDetailType.java b/src/main/java/neatlogic/module/cmdb/process/constvalue/CmdbAuditDetailType.java new file mode 100644 index 0000000000000000000000000000000000000000..559ae3c7819504adf83acaaf34d9302b18abb007 --- /dev/null +++ b/src/main/java/neatlogic/module/cmdb/process/constvalue/CmdbAuditDetailType.java @@ -0,0 +1,54 @@ +package neatlogic.module.cmdb.process.constvalue; + +import neatlogic.framework.process.audithandler.core.IProcessTaskAuditDetailType; + +public enum CmdbAuditDetailType implements IProcessTaskAuditDetailType { + + CMDBSYNCMESSAGE("cmdbsyncmessage", "CMDB配置项同步信息", "cmdbSyncMessage", "oldCmdbSyncMessage", 20, false), + ; + private String value; + private String text; + private String paramName; + private String oldDataParamName; + private int sort; + private boolean needCompression; + + CmdbAuditDetailType(String value, String text, String paramName, String oldDataParamName, int sort, boolean needCompression) { + this.value = value; + this.text = text; + this.paramName = paramName; + this.oldDataParamName = oldDataParamName; + this.sort = sort; + this.needCompression = needCompression; + } + + @Override + public String getValue() { + return value; + } + + @Override + public String getText() { + return text; + } + + @Override + public String getParamName() { + return paramName; + } + + @Override + public String getOldDataParamName() { + return oldDataParamName; + } + + @Override + public int getSort() { + return sort; + } + + @Override + public boolean getNeedCompression() { + return needCompression; + } +} diff --git a/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncBatchDataSourceVo.java b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncBatchDataSourceVo.java new file mode 100644 index 0000000000000000000000000000000000000000..933002cb5ef5c85ab3d13b99d8a7ea38ab2492b2 --- /dev/null +++ b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncBatchDataSourceVo.java @@ -0,0 +1,24 @@ +package neatlogic.module.cmdb.process.dto; + +import java.util.List; + +public class CiEntitySyncBatchDataSourceVo { + private String attributeUuid; + private List filterList; + + public String getAttributeUuid() { + return attributeUuid; + } + + public void setAttributeUuid(String attributeUuid) { + this.attributeUuid = attributeUuid; + } + + public List getFilterList() { + return filterList; + } + + public void setFilterList(List filterList) { + this.filterList = filterList; + } +} diff --git a/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncConfigVo.java b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncConfigVo.java new file mode 100644 index 0000000000000000000000000000000000000000..1b994e84ad036de26dcc5f588f5472ab3f6ad277 --- /dev/null +++ b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncConfigVo.java @@ -0,0 +1,110 @@ +package neatlogic.module.cmdb.process.dto; + +import java.util.List; + +public class CiEntitySyncConfigVo { + private Long id; + private String uuid; + private Long ciId; + private String ciName; + private String ciLabel; + private String ciIcon; + /** 是否是起始模型 **/ + private Integer isStart; + /** 单个和批量 **/ + private String createPolicy; + /** 追加或替换 **/ + private String action; + /** 批量数据 **/ + private CiEntitySyncBatchDataSourceVo batchDataSource; + /** 全局属性、属性和关系映射列表 **/ + private List mappingList; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getUuid() { + return uuid; + } + + public void setUuid(String uuid) { + this.uuid = uuid; + } + + public Long getCiId() { + return ciId; + } + + public void setCiId(Long ciId) { + this.ciId = ciId; + } + + public String getCiName() { + return ciName; + } + + public void setCiName(String ciName) { + this.ciName = ciName; + } + + public String getCiLabel() { + return ciLabel; + } + + public void setCiLabel(String ciLabel) { + this.ciLabel = ciLabel; + } + + public String getCiIcon() { + return ciIcon; + } + + public void setCiIcon(String ciIcon) { + this.ciIcon = ciIcon; + } + + public Integer getIsStart() { + return isStart; + } + + public void setIsStart(Integer isStart) { + this.isStart = isStart; + } + + public String getCreatePolicy() { + return createPolicy; + } + + public void setCreatePolicy(String createPolicy) { + this.createPolicy = createPolicy; + } + + public String getAction() { + return action; + } + + public void setAction(String action) { + this.action = action; + } + + public CiEntitySyncBatchDataSourceVo getBatchDataSource() { + return batchDataSource; + } + + public void setBatchDataSource(CiEntitySyncBatchDataSourceVo batchDataSource) { + this.batchDataSource = batchDataSource; + } + + public List getMappingList() { + return mappingList; + } + + public void setMappingList(List mappingList) { + this.mappingList = mappingList; + } +} diff --git a/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncFilterVo.java b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncFilterVo.java new file mode 100644 index 0000000000000000000000000000000000000000..4f8f4651b236485593ccf8dd51670500d7f20964 --- /dev/null +++ b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncFilterVo.java @@ -0,0 +1,31 @@ +package neatlogic.module.cmdb.process.dto; + +public class CiEntitySyncFilterVo { + private String column; + private String expression; + private String value; + + public String getColumn() { + return column; + } + + public void setColumn(String column) { + this.column = column; + } + + public String getExpression() { + return expression; + } + + public void setExpression(String expression) { + this.expression = expression; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } +} diff --git a/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncMappingVo.java b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncMappingVo.java new file mode 100644 index 0000000000000000000000000000000000000000..924b6dbf8e7fc29be9093b9ec6809d648bb47bf2 --- /dev/null +++ b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncMappingVo.java @@ -0,0 +1,89 @@ +package neatlogic.module.cmdb.process.dto; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import org.apache.commons.collections4.CollectionUtils; + +import java.util.ArrayList; +import java.util.List; + +public class CiEntitySyncMappingVo { + private String key; + private String mappingMode; + private String column; + private List filterList; + private JSONArray valueList; + + public CiEntitySyncMappingVo() {} + + public CiEntitySyncMappingVo(CiEntitySyncMappingVo ciEntitySyncMappingVo) { + this.key = ciEntitySyncMappingVo.getKey(); + this.mappingMode = ciEntitySyncMappingVo.getMappingMode(); + this.column = ciEntitySyncMappingVo.getColumn(); + List newFilterList = ciEntitySyncMappingVo.getFilterList(); + if (CollectionUtils.isNotEmpty(newFilterList)) { + this.filterList = new ArrayList<>(); + for (CiEntitySyncFilterVo filter : newFilterList) { + CiEntitySyncFilterVo filterVo = new CiEntitySyncFilterVo(); + filterVo.setColumn(filter.getColumn()); + filterVo.setExpression(filter.getExpression()); + filterVo.setValue(filter.getValue()); + this.filterList.add(filterVo); + } + } + JSONArray newValueList = ciEntitySyncMappingVo.getValueList(); + if (CollectionUtils.isNotEmpty(newValueList)) { + this.valueList = new JSONArray(); + for (int i = 0; i < newValueList.size(); i++) { + Object obj = newValueList.get(i); + if (obj instanceof JSONObject) { + JSONObject jsonObj = new JSONObject(); + jsonObj.putAll((JSONObject) obj); + this.valueList.add(jsonObj); + } else { + this.valueList.add(obj); + } + } + } + } + + public String getKey() { + return key; + } + + public void setKey(String key) { + this.key = key; + } + + public String getMappingMode() { + return mappingMode; + } + + public void setMappingMode(String mappingMode) { + this.mappingMode = mappingMode; + } + + public String getColumn() { + return column; + } + + public void setColumn(String column) { + this.column = column; + } + + public List getFilterList() { + return filterList; + } + + public void setFilterList(List filterList) { + this.filterList = filterList; + } + + public JSONArray getValueList() { + return valueList; + } + + public void setValueList(JSONArray valueList) { + this.valueList = valueList; + } +} diff --git a/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncVo.java b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncVo.java new file mode 100644 index 0000000000000000000000000000000000000000..d1f1848ebd30287c7298c5a31c645d81a4707e06 --- /dev/null +++ b/src/main/java/neatlogic/module/cmdb/process/dto/CiEntitySyncVo.java @@ -0,0 +1,33 @@ +package neatlogic.module.cmdb.process.dto; + +import java.util.List; + +public class CiEntitySyncVo { + private String failPolicy; + private Integer rerunStepToSync; + private List configList; + + public String getFailPolicy() { + return failPolicy; + } + + public void setFailPolicy(String failPolicy) { + this.failPolicy = failPolicy; + } + + public Integer getRerunStepToSync() { + return rerunStepToSync; + } + + public void setRerunStepToSync(Integer rerunStepToSync) { + this.rerunStepToSync = rerunStepToSync; + } + + public List getConfigList() { + return configList; + } + + public void setConfigList(List configList) { + this.configList = configList; + } +} diff --git a/src/main/java/neatlogic/module/cmdb/process/exception/CiEntityConfigIllegalException.java b/src/main/java/neatlogic/module/cmdb/process/exception/CiEntityConfigIllegalException.java new file mode 100644 index 0000000000000000000000000000000000000000..014b16442db13bd3276a50c666d29110e24b26a7 --- /dev/null +++ b/src/main/java/neatlogic/module/cmdb/process/exception/CiEntityConfigIllegalException.java @@ -0,0 +1,10 @@ +package neatlogic.module.cmdb.process.exception; + +import neatlogic.framework.exception.core.ApiRuntimeException; + +public class CiEntityConfigIllegalException extends ApiRuntimeException { + + public CiEntityConfigIllegalException(String msg) { + super("nmcpe.cientityconfigillegalexception.cientityconfigillegalexception", msg); + } +} diff --git a/src/main/java/neatlogic/module/cmdb/process/stephandler/CmdbSyncProcessComponent.java b/src/main/java/neatlogic/module/cmdb/process/stephandler/CmdbSyncProcessComponent.java index 701560f492da4d6f0539a84cee1dea0bbd01e590..95eb5dff6697ee800e8bfc2a4835e84e862e0cc1 100644 --- a/src/main/java/neatlogic/module/cmdb/process/stephandler/CmdbSyncProcessComponent.java +++ b/src/main/java/neatlogic/module/cmdb/process/stephandler/CmdbSyncProcessComponent.java @@ -16,27 +16,94 @@ package neatlogic.module.cmdb.process.stephandler; +import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONPath; +import neatlogic.framework.asynchronization.threadlocal.InputFromContext; +import neatlogic.framework.asynchronization.threadlocal.UserContext; +import neatlogic.framework.cmdb.dto.ci.AttrVo; +import neatlogic.framework.cmdb.dto.ci.CiVo; +import neatlogic.framework.cmdb.dto.ci.RelVo; +import neatlogic.framework.cmdb.dto.cientity.AttrFilterVo; +import neatlogic.framework.cmdb.dto.cientity.CiEntityVo; +import neatlogic.framework.cmdb.dto.cientity.RelEntityVo; +import neatlogic.framework.cmdb.dto.globalattr.GlobalAttrVo; +import neatlogic.framework.cmdb.dto.transaction.CiEntityTransactionVo; +import neatlogic.framework.cmdb.enums.RelDirectionType; +import neatlogic.framework.cmdb.enums.SearchExpression; +import neatlogic.framework.cmdb.enums.TransactionActionType; +import neatlogic.framework.cmdb.exception.ci.CiNotFoundException; +import neatlogic.framework.cmdb.exception.cientity.NewCiEntityNotFoundException; +import neatlogic.framework.cmdb.utils.RelUtil; +import neatlogic.framework.common.constvalue.Expression; +import neatlogic.framework.common.constvalue.InputFrom; +import neatlogic.framework.form.constvalue.FormHandler; +import neatlogic.framework.form.dto.FormAttributeVo; +import neatlogic.framework.form.dto.FormVersionVo; +import neatlogic.framework.process.constvalue.ProcessFlowDirection; import neatlogic.framework.process.constvalue.ProcessStepMode; -import neatlogic.framework.process.dto.ProcessTaskStepVo; -import neatlogic.framework.process.dto.ProcessTaskStepWorkerVo; +import neatlogic.framework.process.constvalue.ProcessTaskAuditType; +import neatlogic.framework.process.constvalue.ProcessTaskOperationType; +import neatlogic.framework.process.constvalue.automatic.FailPolicy; +import neatlogic.framework.process.dao.mapper.ProcessTaskStepDataMapper; +import neatlogic.framework.process.dto.*; import neatlogic.framework.process.exception.processtask.ProcessTaskException; +import neatlogic.framework.process.exception.processtask.ProcessTaskNoPermissionException; +import neatlogic.framework.process.stephandler.core.IProcessStepHandler; import neatlogic.framework.process.stephandler.core.ProcessStepHandlerBase; +import neatlogic.framework.process.stephandler.core.ProcessStepHandlerFactory; +import neatlogic.framework.process.stephandler.core.ProcessStepThread; +import neatlogic.framework.transaction.core.EscapeTransactionJob; +import neatlogic.framework.util.UuidUtil; +import neatlogic.module.cmdb.dao.mapper.ci.AttrMapper; +import neatlogic.module.cmdb.dao.mapper.ci.CiMapper; +import neatlogic.module.cmdb.dao.mapper.ci.RelMapper; +import neatlogic.module.cmdb.dao.mapper.cientity.CiEntityMapper; +import neatlogic.module.cmdb.dao.mapper.cientity.RelEntityMapper; +import neatlogic.module.cmdb.dao.mapper.globalattr.GlobalAttrMapper; +import neatlogic.module.cmdb.process.constvalue.CmdbAuditDetailType; +import neatlogic.module.cmdb.process.dto.*; +import neatlogic.module.cmdb.service.cientity.CiEntityService; +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; import org.springframework.stereotype.Service; -import java.util.List; -import java.util.Set; +import javax.annotation.Resource; +import java.util.*; +import java.util.stream.Collectors; @Service public class CmdbSyncProcessComponent extends ProcessStepHandlerBase { private final Logger logger = LoggerFactory.getLogger(CmdbSyncProcessComponent.class); + @Resource + private ProcessTaskStepDataMapper processTaskStepDataMapper; + + @Resource + private CiMapper ciMapper; + + @Resource + private GlobalAttrMapper globalAttrMapper; + + @Resource + private AttrMapper attrMapper; + + @Resource + private RelMapper relMapper; + + @Resource + private CiEntityMapper ciEntityMapper; + + @Resource + private RelEntityMapper relEntityMapper; + + @Resource + private CiEntityService ciEntityService; + @Override public String getHandler() { return CmdbProcessStepHandlerType.CMDBSYNC.getHandler(); @@ -61,7 +128,7 @@ public class CmdbSyncProcessComponent extends ProcessStepHandlerBase { @Override public ProcessStepMode getMode() { - return ProcessStepMode.AT; + return ProcessStepMode.MT; } @Override @@ -95,7 +162,6 @@ public class CmdbSyncProcessComponent extends ProcessStepHandlerBase { } // 获取工单当前步骤配置信息 String config = selectContentByHashMapper.getProcessTaskStepConfigByHash(configHash); - if (StringUtils.isBlank(config)) { return 0; } @@ -103,7 +169,182 @@ public class CmdbSyncProcessComponent extends ProcessStepHandlerBase { if (MapUtils.isEmpty(ciEntityConfig)) { return 0; } - // TODO 根据配置数据修改配置项数据逻辑 + Map processTaskFormAttributeDataMap = new HashMap<>(); + Map formAttributeMap = new HashMap<>(); + Long processTaskId = currentProcessTaskStepVo.getProcessTaskId(); + // 如果工单有表单信息，则查询出表单配置及数据 + ProcessTaskFormVo processTaskFormVo = processTaskMapper.getProcessTaskFormByProcessTaskId(processTaskId); + if (processTaskFormVo != null) { + String formContent = selectContentByHashMapper.getProcessTaskFromContentByHash(processTaskFormVo.getFormContentHash()); + FormVersionVo formVersionVo = new FormVersionVo(); + formVersionVo.setFormUuid(processTaskFormVo.getFormUuid()); + formVersionVo.setFormName(processTaskFormVo.getFormName()); + formVersionVo.setFormConfig(JSONObject.parseObject(formContent)); + List formAttributeList = formVersionVo.getFormAttributeList(); + if (CollectionUtils.isNotEmpty(formAttributeList)) { + formAttributeMap = formAttributeList.stream().collect(Collectors.toMap(e -> e.getUuid(), e -> e)); + } + List processTaskFormAttributeDataList = processTaskMapper.getProcessTaskStepFormAttributeDataByProcessTaskId(processTaskId); + if (CollectionUtils.isNotEmpty(processTaskFormAttributeDataList)) { + processTaskFormAttributeDataMap = processTaskFormAttributeDataList.stream().collect(Collectors.toMap(e -> e.getAttributeUuid(), e -> e)); + } + } + boolean flag = false; + JSONArray errorMessageList = new JSONArray(); + try { + CiEntitySyncVo ciEntitySyncVo = ciEntityConfig.toJavaObject(CiEntitySyncVo.class); + // rerunStepToSync为1时表示重新激活CMDB步骤时同步配置项实例，rerunStepToSync为0时表示重新激活CMDB步骤时不同步配置项实例，即什么都不做，直接自动流转到下一阶段 + Integer rerunStepToSync = ciEntitySyncVo.getRerunStepToSync(); + if (!Objects.equals(rerunStepToSync, 1)) { + ProcessTaskStepDataVo searchVo = new ProcessTaskStepDataVo(); + searchVo.setProcessTaskId(currentProcessTaskStepVo.getProcessTaskId()); + searchVo.setProcessTaskStepId(currentProcessTaskStepVo.getId()); + searchVo.setType("ciEntitySyncResult"); + ProcessTaskStepDataVo processTaskStepData = processTaskStepDataMapper.getProcessTaskStepData(searchVo); + if (processTaskStepData != null) { + myAutoComplete(currentProcessTaskStepVo); + return 1; + } + } + ProcessTaskStepDataVo searchVo = new ProcessTaskStepDataVo(); + searchVo.setProcessTaskId(currentProcessTaskStepVo.getProcessTaskId()); + searchVo.setProcessTaskStepId(currentProcessTaskStepVo.getId()); + searchVo.setType("ciEntitySyncError"); + ProcessTaskStepDataVo processTaskStepData = processTaskStepDataMapper.getProcessTaskStepData(searchVo); + if (processTaskStepData != null) { + processTaskStepDataMapper.deleteProcessTaskStepDataById(processTaskStepData.getId()); + } + List configList = ciEntitySyncVo.getConfigList(); + /* 重新构建configList配置信息 */ + configList = rebuildConfigList(configList, formAttributeMap, processTaskFormAttributeDataMap); + if (CollectionUtils.isEmpty(configList)) { + return 1; + } + /* 遍历configList， 找出起始模型配置列表，根据id和uuid的值判断是新增还是更新 */ + List startConfigList = new ArrayList<>(); + Map ciEntityTransactionMap = new HashMap<>(); + Map dependencyConfigMap = new HashMap<>(); + for (CiEntitySyncConfigVo configObject : configList) { + String uuid = configObject.getUuid(); + if (StringUtils.isBlank(uuid)) { + continue; + } + Long ciId = configObject.getCiId(); + if (ciId == null) { + continue; + } + CiEntityTransactionVo ciEntityTransactionVo = new CiEntityTransactionVo(); + ciEntityTransactionVo.setCiEntityUuid(uuid); + ciEntityTransactionVo.setCiId(ciId); + Long id = configObject.getId(); + if (id != null) { + ciEntityTransactionVo.setCiEntityId(id); + ciEntityTransactionVo.setAction(TransactionActionType.UPDATE.getValue()); + } else { + ciEntityTransactionVo.setAction(TransactionActionType.INSERT.getValue()); + } + Integer isStart = configObject.getIsStart(); + if (Objects.equals(isStart, 1)) { + startConfigList.add(configObject); + } else { + dependencyConfigMap.put(uuid, configObject); + } + ciEntityTransactionMap.put(uuid, ciEntityTransactionVo); + } + if (CollectionUtils.isEmpty(startConfigList)) { + return 0; + } + /* 遍历起始模型配置信息列表，生成CiEntityTransactionVo列表 */ + List ciEntityTransactionList = new ArrayList<>(); + for (CiEntitySyncConfigVo mainConfigObj : startConfigList) { + List list = createCiEntityTransactionVo(ciEntityTransactionMap, mainConfigObj, dependencyConfigMap); + for (CiEntityTransactionVo ciEntityTransactionVo : list) { + if (!ciEntityTransactionList.contains(ciEntityTransactionVo)) { + ciEntityTransactionList.add(ciEntityTransactionVo); + } + } + } + if (CollectionUtils.isNotEmpty(ciEntityTransactionList)) { + for (CiEntityTransactionVo t : ciEntityTransactionList) { + t.setAllowCommit(true); + } + EscapeTransactionJob.State s = new EscapeTransactionJob(() -> { + InputFromContext.init(InputFrom.ITSM); + Long transactionGroupId = ciEntityService.saveCiEntity(ciEntityTransactionList); + currentProcessTaskStepVo.getParamObj().put(CmdbAuditDetailType.CMDBSYNCMESSAGE.getParamName(), transactionGroupId); + ProcessTaskStepDataVo search = new ProcessTaskStepDataVo(); + search.setProcessTaskId(currentProcessTaskStepVo.getProcessTaskId()); + search.setProcessTaskStepId(currentProcessTaskStepVo.getId()); + search.setType("ciEntitySyncResult"); + ProcessTaskStepDataVo oldProcessTaskStepData = processTaskStepDataMapper.getProcessTaskStepData(search); + if (oldProcessTaskStepData != null) { + JSONObject dataObj = oldProcessTaskStepData.getData(); + JSONArray transactionGroupList = dataObj.getJSONArray("transactionGroupList"); + JSONObject jsonObj = new JSONObject(); + jsonObj.put("time", System.currentTimeMillis()); + jsonObj.put("transactionGroupId", transactionGroupId); + transactionGroupList.add(jsonObj); + } else { + oldProcessTaskStepData = search; + oldProcessTaskStepData.setFcu(UserContext.get().getUserUuid()); + JSONObject dataObj = new JSONObject(); + JSONArray transactionGroupList = new JSONArray(); + JSONObject jsonObj = new JSONObject(); + jsonObj.put("time", System.currentTimeMillis()); + jsonObj.put("transactionGroupId", transactionGroupId); + transactionGroupList.add(jsonObj); + dataObj.put("transactionGroupList", transactionGroupList); + oldProcessTaskStepData.setData(dataObj.toJSONString()); + } + processTaskStepDataMapper.replaceProcessTaskStepData(oldProcessTaskStepData); + }).execute(); + if (!s.isSucceed()) { + // 增加提醒 + logger.error(s.getError(), s.getException()); + JSONObject errorMessageObj = new JSONObject(); + errorMessageObj.put("error", s.getError()); + errorMessageList.add(errorMessageObj); + JSONObject dataObj = new JSONObject(); + dataObj.put("time", System.currentTimeMillis()); + dataObj.put("errorList", errorMessageList); + currentProcessTaskStepVo.getParamObj().put(CmdbAuditDetailType.CMDBSYNCMESSAGE.getParamName(), dataObj.toJSONString()); + flag = true; + } + /* 处理历史记录 **/ + IProcessStepHandlerUtil.audit(currentProcessTaskStepVo, ProcessTaskAuditType.ACTIVE); + } + } catch (Exception e) { + // 增加提醒 + logger.error(e.getMessage(), e); + JSONObject errorMessageObj = new JSONObject(); + errorMessageObj.put("error", e.getMessage()); + errorMessageList.add(errorMessageObj); + JSONObject dataObj = new JSONObject(); + dataObj.put("time", System.currentTimeMillis()); + dataObj.put("errorList", errorMessageList); + currentProcessTaskStepVo.getParamObj().put(CmdbAuditDetailType.CMDBSYNCMESSAGE.getParamName(), dataObj.toJSONString()); + flag = true; + } + + // 如果有异常，则根据失败策略执行操作 + if (flag) { + ProcessTaskStepDataVo processTaskStepDataVo = new ProcessTaskStepDataVo(); + processTaskStepDataVo.setProcessTaskId(currentProcessTaskStepVo.getProcessTaskId()); + processTaskStepDataVo.setProcessTaskStepId(currentProcessTaskStepVo.getId()); + processTaskStepDataVo.setType("ciEntitySyncError"); + JSONObject dataObj = new JSONObject(); + dataObj.put("time", System.currentTimeMillis()); + dataObj.put("errorList", errorMessageList); + processTaskStepDataVo.setData(dataObj.toJSONString()); + processTaskStepDataVo.setFcu(UserContext.get().getUserUuid()); + processTaskStepDataMapper.replaceProcessTaskStepData(processTaskStepDataVo); + String failPolicy = ciEntityConfig.getString("failPolicy"); + if (FailPolicy.KEEP_ON.getValue().equals(failPolicy)) { + myAutoComplete(currentProcessTaskStepVo); + } + } else { + myAutoComplete(currentProcessTaskStepVo); + } } catch (Exception e) { logger.error(e.getMessage(), e); throw new ProcessTaskException(e.getMessage()); @@ -111,6 +352,684 @@ public class CmdbSyncProcessComponent extends ProcessStepHandlerBase { return 1; } + private void myAutoComplete(ProcessTaskStepVo currentProcessTaskStepVo) { + List toProcessTaskStepIdList = processTaskMapper.getToProcessTaskStepIdListByFromIdAndType(currentProcessTaskStepVo.getId(), ProcessFlowDirection.FORWARD.getValue()); + if (toProcessTaskStepIdList.size() == 1) { + Long nextStepId = toProcessTaskStepIdList.get(0); + IProcessStepHandler handler = ProcessStepHandlerFactory.getHandler(CmdbProcessStepHandlerType.CMDBSYNC.getHandler()); + try { + ProcessTaskStepVo processTaskStepVo = processTaskMapper.getProcessTaskStepBaseInfoById(currentProcessTaskStepVo.getId()); + JSONObject paramObj = processTaskStepVo.getParamObj(); + paramObj.put("nextStepId", nextStepId); + paramObj.put("action", ProcessTaskOperationType.STEP_COMPLETE.getValue()); + /* 自动处理 **/ + doNext(ProcessTaskOperationType.STEP_COMPLETE, new ProcessStepThread(processTaskStepVo) { + @Override + public void myExecute() { + handler.autoComplete(processTaskStepVo); + } + }); + } catch (ProcessTaskNoPermissionException e) { + logger.error(e.getMessage(), e); + } + } + } + + /** + * 遍历configList，将“批量操作”的配置信息根据表单数据转换成多条“单个操作”配置信息 + * @param configList 配置信息列表 + * @param processTaskFormAttributeDataMap 表单数据信息 + * @return + */ + private List handleBatchDataSource( + List configList, + Map processTaskFormAttributeDataMap + ) { + Map> oldUuid2NewUuidListMap = new HashMap<>(); + List newConfigList = new ArrayList<>(); + for (CiEntitySyncConfigVo configObj : configList) { + if (!Objects.equals(configObj.getCreatePolicy(), "batch")) { + // 单个操作配置，不做修改 + newConfigList.add(configObj); + continue; + } + String oldUuid = configObj.getUuid(); + // 批量操作配置信息 + CiEntitySyncBatchDataSourceVo batchDataSource = configObj.getBatchDataSource(); + String attributeUuid = batchDataSource.getAttributeUuid(); + ProcessTaskFormAttributeDataVo formAttributeDataVo = processTaskFormAttributeDataMap.get(attributeUuid); + List filterList = batchDataSource.getFilterList(); + JSONArray tbodyList = getTbodyList(formAttributeDataVo, filterList); + if (CollectionUtils.isEmpty(tbodyList)) { + continue; + } + List mappingList = configObj.getMappingList(); + // 遍历批量操作表格数据 + for (int j = 0; j < tbodyList.size(); j++) { + JSONObject tbodyObj = tbodyList.getJSONObject(j); + if (MapUtils.isEmpty(tbodyObj)) { + continue; + } + CiEntitySyncConfigVo newConfigObj = new CiEntitySyncConfigVo(); + List newMappingList = new ArrayList<>(); + for (CiEntitySyncMappingVo mappingObj : mappingList) { + CiEntitySyncMappingVo newMappingObj = new CiEntitySyncMappingVo(mappingObj); + String mappingMode = mappingObj.getMappingMode(); + if (Objects.equals(mappingMode, "formTableComponent")) { + // 映射模式是表单表格组件 + JSONArray valueList = mappingObj.getValueList(); + if (CollectionUtils.isNotEmpty(valueList)) { + String value = valueList.getString(0); + if (Objects.equals(value, attributeUuid)) { + String column = mappingObj.getColumn(); + JSONArray newValueList = new JSONArray(); + Object valueObj = tbodyObj.get(column); + if (valueObj instanceof JSONObject) { + + } else if (valueObj instanceof JSONArray) { + JSONArray valueArray = (JSONArray) valueObj; + for (int k = 0; k < valueArray.size(); k++) { + String valueStr = valueArray.getString(k); + if (valueStr.contains("&=&")) { + String[] split = valueStr.split("&=&"); + newValueList.add(split[0]); + } else { + newValueList.add(valueStr); + } + } + } else if (valueObj instanceof String) { + String valueStr = (String) valueObj; + if (valueStr.contains("&=&")) { + String[] split = valueStr.split("&=&"); + newValueList.add(split[0]); + } else { + newValueList.add(valueStr); + } + } else { + String valueStr = valueObj.toString(); + if (valueStr.contains("&=&")) { + String[] split = valueStr.split("&=&"); + newValueList.add(split[0]); + } else { + newValueList.add(valueStr); + } + } + if (CollectionUtils.isNotEmpty(newValueList)) { + newMappingObj.setMappingMode("constant"); + newMappingObj.setValueList(newValueList); + } else { + continue; + } + } + } else { + continue; + } + } + newMappingList.add(newMappingObj); + } + String newUuid = UuidUtil.randomUuid(); + oldUuid2NewUuidListMap.computeIfAbsent(oldUuid, key -> new ArrayList<>()).add(newUuid); + newConfigObj.setUuid(newUuid); + newConfigObj.setCiId(configObj.getCiId()); + newConfigObj.setCiName(configObj.getCiName()); + newConfigObj.setCiLabel(configObj.getCiLabel()); + newConfigObj.setIsStart(configObj.getIsStart()); + newConfigObj.setCiIcon(configObj.getCiIcon()); + newConfigObj.setMappingList(newMappingList); + newConfigList.add(newConfigObj); + } + } + // 遍历newConfigList，根据oldUuid2NewUuidListMap，将关系映射配置信息中的valueList数据重新构建 + for (CiEntitySyncConfigVo configObj : newConfigList) { + List mappingList = configObj.getMappingList(); + for (CiEntitySyncMappingVo mappingObj : mappingList) { + String key = mappingObj.getKey(); + if (key.startsWith("rel")) { + JSONArray valueList = mappingObj.getValueList(); + if (CollectionUtils.isNotEmpty(valueList)) { + JSONArray newValueList = new JSONArray(); + for (int i = 0; i < valueList.size(); i++) { + JSONObject valueObj = valueList.getJSONObject(i); + String ciEntityUuid = valueObj.getString("ciEntityUuid"); + List newUuidList = oldUuid2NewUuidListMap.get(ciEntityUuid); + if (CollectionUtils.isNotEmpty(newUuidList)) { + for (String newUuid : newUuidList) { + JSONObject newValueObj = new JSONObject(); + newValueObj.putAll(valueObj); + newValueObj.put("ciEntityUuid", newUuid); + newValueList.add(newValueObj); + } + mappingObj.setValueList(newValueList); + } else { + JSONObject newValueObj = new JSONObject(); + newValueObj.putAll(valueObj); + newValueList.add(newValueObj); + } + } + } + } + } + } + return newConfigList; + } + + /** + * 遍历configList，将mappingList中映射模式为“表单普通组件”和“表单表格组件”的数据替换称表单组件对应的真实值 + * @param configList 配置信息列表 + * @param formAttributeMap 表单组件信息 + * @param processTaskFormAttributeDataMap 表单数据信息 + */ + private void handleMappingFormComponent( + List configList, + Map formAttributeMap, + Map processTaskFormAttributeDataMap + ) { + for (CiEntitySyncConfigVo configObj : configList) { + List mappingList = configObj.getMappingList(); + for (CiEntitySyncMappingVo mappingObj : mappingList) { + JSONArray valueList = mappingObj.getValueList(); + if (CollectionUtils.isEmpty(valueList)) { + continue; + } + JSONArray newValueList = new JSONArray(); + String mappingMode = mappingObj.getMappingMode(); + mappingObj.setValueList(newValueList); + if (Objects.equals(mappingMode, "formTableComponent")) { + mappingObj.setMappingMode("constant"); + ProcessTaskFormAttributeDataVo attributeDataVo = processTaskFormAttributeDataMap.get(valueList.getString(0)); + if (attributeDataVo == null) { + continue; + } + List filterList = mappingObj.getFilterList(); + JSONArray tbodyList = getTbodyList(attributeDataVo, filterList); + if (CollectionUtils.isEmpty(tbodyList)) { + continue; + } + String column = mappingObj.getColumn(); + for (int m = 0; m < tbodyList.size(); m++) { + JSONObject tbodyObj = tbodyList.getJSONObject(m); + if (MapUtils.isEmpty(tbodyObj)) { + continue; + } + Object valueObj = tbodyObj.get(column); + if (valueObj instanceof JSONObject) { + + } else if (valueObj instanceof JSONArray) { + JSONArray valueArray = (JSONArray) valueObj; + for (int j = 0; j < valueArray.size(); j++) { + String valueStr = valueArray.getString(j); + if (valueStr.contains("&=&")) { + String[] split = valueStr.split("&=&"); + newValueList.add(split[0]); + } else { + newValueList.add(valueStr); + } + } + } else if (valueObj instanceof String) { + String valueStr = (String) valueObj; + if (valueStr.contains("&=&")) { + String[] split = valueStr.split("&=&"); + newValueList.add(split[0]); + } else { + newValueList.add(valueStr); + } + } else { + String valueStr = valueObj.toString(); + if (valueStr.contains("&=&")) { + String[] split = valueStr.split("&=&"); + newValueList.add(split[0]); + } else { + newValueList.add(valueStr); + } + } + } + } else if (Objects.equals(mappingMode, "formCommonComponent")) { + mappingObj.setMappingMode("constant"); + ProcessTaskFormAttributeDataVo attributeDataVo = processTaskFormAttributeDataMap.get(valueList.getString(0)); + if (attributeDataVo == null) { + continue; + } + Object dataObj = attributeDataVo.getDataObj(); + if (dataObj == null) { + continue; + } + FormAttributeVo formAttributeVo = formAttributeMap.get(valueList.getString(0)); + if (Objects.equals(formAttributeVo.getHandler(), FormHandler.FORMUPLOAD.getHandler())) { + if (dataObj instanceof JSONArray) { + JSONArray dataArray = (JSONArray) dataObj; + for (int m = 0; m < dataArray.size(); m++) { + JSONObject data = dataArray.getJSONObject(m); + Long id = data.getLong("id"); + if (id != null) { + newValueList.add(id); + } + } + } + } else { + if (dataObj instanceof JSONObject) { + + } else if (dataObj instanceof JSONArray) { + newValueList.addAll((JSONArray) dataObj); + } else { + newValueList.add(dataObj); + } + } + } else { + newValueList.addAll(valueList); + } + } + } + } + + /** + * 遍历configList，根据唯一规则属性值删除重复配置信息 + * @param configList 配置信息列表 + * @return + */ + private List removeDuplicatesByUniqueAttrValue(List configList) { + List uniqueAttrValueListJoinStrList = new ArrayList<>(); + List newConfigList = new ArrayList<>(); + for (CiEntitySyncConfigVo configObj : configList) { + Long ciId = configObj.getCiId(); + CiVo ciVo = ciMapper.getCiById(ciId); + if (ciVo == null) { + String ciName = configObj.getCiName(); + throw new CiNotFoundException(ciName); + } + List uniqueAttrIdList = ciVo.getUniqueAttrIdList(); + if (CollectionUtils.isEmpty(uniqueAttrIdList)) { + newConfigList.add(configObj); + continue; + } + Map key2ValueListMap = new HashMap<>(); + List mappingList = configObj.getMappingList(); + for (CiEntitySyncMappingVo mappingObj : mappingList) { + String key = mappingObj.getKey(); + JSONArray valueList = mappingObj.getValueList(); + key2ValueListMap.put(key, valueList); + } + List list = new ArrayList<>(); + list.add(ciId.toString()); + for (Long attrId : uniqueAttrIdList) { + JSONArray valueList = key2ValueListMap.get("attr_" + attrId); + list.add(valueList.toJSONString()); + } + String uniqueAttrValueListJoinStr = String.join(",", list); + if (uniqueAttrValueListJoinStrList.contains(uniqueAttrValueListJoinStr)) { + continue; + } + //校验唯一规则 + CiEntityVo ciEntityConditionVo = new CiEntityVo(); + ciEntityConditionVo.setCiId(ciId); + ciEntityConditionVo.setAttrIdList(new ArrayList() {{ + this.add(0L); + }}); + ciEntityConditionVo.setRelIdList(new ArrayList() {{ + this.add(0L); + }}); + for (Long attrId : ciVo.getUniqueAttrIdList()) { + AttrFilterVo filterVo = new AttrFilterVo(); + filterVo.setAttrId(attrId); + filterVo.setExpression(SearchExpression.EQ.getExpression()); + List valueList = new ArrayList<>(); + JSONArray valueArray = key2ValueListMap.get("attr_" + attrId); + if (CollectionUtils.isNotEmpty(valueArray)) { + valueList = valueArray.toJavaList(String.class); + } + filterVo.setValueList(valueList); + ciEntityConditionVo.addAttrFilter(filterVo); + } + if (CollectionUtils.isNotEmpty(ciEntityConditionVo.getAttrFilterList())) { + List checkList = ciEntityService.searchCiEntity(ciEntityConditionVo); + if (CollectionUtils.isNotEmpty(checkList)) { + configObj.setId(checkList.get(0).getId()); + } + } + uniqueAttrValueListJoinStrList.add(uniqueAttrValueListJoinStr); + newConfigList.add(configObj); + } + return newConfigList; + } + + /** + * 遍历configList，重新生成uuid的值 + * @param configList 配置信息列表 + * @return + */ + private List updateUuidValue(List configList) { + Map oldUuid2NewUuidMap = new HashMap<>(); + for (CiEntitySyncConfigVo configObject : configList) { + String uuid = configObject.getUuid(); + Long id = configObject.getId(); + if (id != null) { + CiEntityVo ciEntityVo = ciEntityMapper.getCiEntityBaseInfoById(id); + if (ciEntityVo == null) { + configObject.setId(null); + oldUuid2NewUuidMap.put(uuid, UuidUtil.randomUuid()); + } else { + if (!Objects.equals(uuid, ciEntityVo.getUuid())) { + oldUuid2NewUuidMap.put(uuid, ciEntityVo.getUuid()); + } + } + } else if (StringUtils.isNotBlank(uuid)) { + CiEntityVo ciEntityVo = ciEntityMapper.getCiEntityBaseInfoByUuid(uuid); + if (ciEntityVo != null) { + oldUuid2NewUuidMap.put(uuid, UuidUtil.randomUuid()); + } + } + } + if (MapUtils.isNotEmpty(oldUuid2NewUuidMap)) { + String configListStr = JSONObject.toJSONString(configList); + for (Map.Entry entry : oldUuid2NewUuidMap.entrySet()) { + configListStr = configListStr.replace(entry.getKey(), entry.getValue()); + } + return JSONObject.parseArray(configListStr, CiEntitySyncConfigVo.class); + } + return configList; + } + /** + * 重新构建configList配置信息 + * @param configList 配置信息列表 + * @param formAttributeMap 表单组件信息 + * @param processTaskFormAttributeDataMap 表单数据信息 + * @return + */ + private List rebuildConfigList( + List configList, + Map formAttributeMap, + Map processTaskFormAttributeDataMap) { + // 遍历configList，将“批量操作”的配置信息根据表单数据转换成多条“单个操作”配置信息 + configList = handleBatchDataSource(configList, processTaskFormAttributeDataMap); + // 遍历configList，将mappingList中映射模式为“表单普通组件”和“表单表格组件”的数据替换称表单组件对应的真实值 + handleMappingFormComponent(configList, formAttributeMap, processTaskFormAttributeDataMap); + // 遍历configList，根据唯一规则属性值删除重复配置信息 + configList = removeDuplicatesByUniqueAttrValue(configList); + // 遍历configList，重新生成uuid的值 + configList = updateUuidValue(configList); + return configList; + } + + private List createCiEntityTransactionVo( + Map ciEntityTransactionMap, + CiEntitySyncConfigVo mainConfigObj, + Map dependencyConfigMap) { + List ciEntityTransactionList = new ArrayList<>(); + + Long ciId = mainConfigObj.getCiId(); + Map mappingMap = new HashMap<>(); + List mappingList = mainConfigObj.getMappingList(); + for (CiEntitySyncMappingVo mappingObj : mappingList) { + String key = mappingObj.getKey(); + if (StringUtils.isBlank(key)) { + continue; + } + mappingMap.put(key, mappingObj); + } + String uuid = mainConfigObj.getUuid(); + CiEntityTransactionVo ciEntityTransactionVo = ciEntityTransactionMap.get(uuid); + /** 变更说明 **/ + CiEntitySyncMappingVo descriptionMappingObj = mappingMap.get("description"); + if (descriptionMappingObj != null) { + JSONArray valueList = descriptionMappingObj.getValueList(); + if (CollectionUtils.isEmpty(valueList)) { + } + String description = valueList.getString(0); + if (StringUtils.isBlank(description)) { + } + ciEntityTransactionVo.setDescription(description); + } + + /** 属性 **/ + JSONObject attrEntityData = new JSONObject(); + List attrList = attrMapper.getAttrByCiId(ciId); + for (AttrVo attrVo : attrList) { + if (Objects.equals(attrVo.getType(), "expression")) { + continue; + } + String key = "attr_" + attrVo.getId(); + CiEntitySyncMappingVo mappingObj = mappingMap.get(key); + if (mappingObj == null) { + JSONObject attrEntity = new JSONObject(); + attrEntity.put("type", attrVo.getType()); + attrEntity.put("config", attrVo.getConfig()); + attrEntity.put("valueList", new JSONArray()); + attrEntityData.put(key, attrEntity); + continue; + } + // 映射模式为常量 + JSONArray valueList = mappingObj.getValueList(); + if (CollectionUtils.isNotEmpty(valueList)) { + for (int i = valueList.size() - 1; i >= 0; i--) { + if (valueList.get(i) instanceof JSONObject) { + JSONObject valueObj = valueList.getJSONObject(i); + String attrCiEntityUuid = valueObj.getString("uuid"); + Long attrCiEntityId = valueObj.getLong("id"); + if (attrCiEntityId == null && StringUtils.isNotBlank(attrCiEntityUuid)) { + CiEntityTransactionVo tmpVo = ciEntityTransactionMap.get(attrCiEntityUuid); + if (tmpVo != null) { + //替换掉原来的ciEntityUuid为新的ciEntityId + valueList.set(i, tmpVo.getCiEntityId()); + } else { + //使用uuid寻找配置项 + CiEntityVo uuidCiEntityVo = ciEntityMapper.getCiEntityBaseInfoByUuid(attrCiEntityUuid); + if (uuidCiEntityVo == null) { + throw new NewCiEntityNotFoundException(attrCiEntityUuid); + } else { + valueList.set(i, uuidCiEntityVo.getId()); + } + } + } else if (attrCiEntityId != null) { + valueList.set(i, attrCiEntityId); + } else { + valueList.remove(i); + } + } + } + } + JSONObject attrEntity = new JSONObject(); + attrEntity.put("type", attrVo.getType()); + attrEntity.put("config", attrVo.getConfig()); + attrEntity.put("valueList", valueList); + attrEntityData.put(key, attrEntity); + } + ciEntityTransactionVo.setAttrEntityData(attrEntityData); + /** 关系 **/ + JSONObject relEntityData = new JSONObject(); + List relList = RelUtil.ClearRepeatRel(relMapper.getRelByCiId(ciId)); + for (RelVo relVo : relList) { + String key = "rel" + relVo.getDirection() + "_" + relVo.getId(); + CiEntitySyncMappingVo mappingObj = mappingMap.get(key); + if (mappingObj == null) { + continue; + } + String mappingMode = mappingObj.getMappingMode(); + if (Objects.equals(mappingMode, "new")) { + JSONArray valueList = mappingObj.getValueList(); + if (CollectionUtils.isNotEmpty(valueList)) { + List ciEntityIdList = new ArrayList<>(); + List alreadyExistRelList = new ArrayList<>(); + for (int i = 0; i < valueList.size(); i++) { + JSONObject valueObj = valueList.getJSONObject(i); + if (MapUtils.isEmpty(valueObj)) { + continue; + } + String ciEntityUuid = valueObj.getString("ciEntityUuid"); + if (StringUtils.isBlank(ciEntityUuid)) { + continue; + } + Long ciEntityId = valueObj.getLong("ciEntityId"); + if (ciEntityId == null) { + CiEntityTransactionVo tmpVo = ciEntityTransactionMap.get(ciEntityUuid); + if (tmpVo != null) { + ciEntityId = tmpVo.getCiEntityId(); + valueObj.put("ciEntityId", ciEntityId); + } else { + CiEntityVo uuidCiEntityVo = ciEntityMapper.getCiEntityBaseInfoByUuid(ciEntityUuid); + if (uuidCiEntityVo == null) { + throw new NewCiEntityNotFoundException(valueObj.getString("ciEntityUuid")); + } else { + ciEntityId = uuidCiEntityVo.getId(); + valueObj.put("ciEntityId", ciEntityId); + } + } + } + ciEntityIdList.add(ciEntityId); + String type = valueObj.getString("type"); + if (!Objects.equals(type, "new")) { + continue; + } + CiEntitySyncConfigVo dependencyConfig = dependencyConfigMap.get(ciEntityUuid); + if (dependencyConfig == null) { + continue; + } + // 关系选择追加模式时，需要将该配置项原来就关联的关系数据补充到valueList中 + if (Objects.equals(dependencyConfig.getAction(), "append") && ciEntityTransactionVo.getCiEntityId() != null) { + List relEntityList; + if (relVo.getDirection().equals(RelDirectionType.FROM.getValue())) { + relEntityList = relEntityMapper.getRelEntityByFromCiEntityIdAndRelId(ciEntityTransactionVo.getCiEntityId(), relVo.getId(), null); + for (RelEntityVo relEntityVo : relEntityList) { + JSONObject jsonObj = new JSONObject(); + jsonObj.put("ciEntityId", relEntityVo.getToCiEntityId()); + jsonObj.put("ciEntityName", relEntityVo.getToCiEntityName()); + jsonObj.put("ciId", relEntityVo.getToCiId()); + alreadyExistRelList.add(jsonObj); + } + } else { + relEntityList = relEntityMapper.getRelEntityByToCiEntityIdAndRelId(ciEntityTransactionVo.getCiEntityId(), relVo.getId(), null); + for (RelEntityVo relEntityVo : relEntityList) { + JSONObject jsonObj = new JSONObject(); + jsonObj.put("ciEntityId", relEntityVo.getFromCiEntityId()); + jsonObj.put("ciEntityName", relEntityVo.getFromCiEntityName()); + jsonObj.put("ciId", relEntityVo.getFromCiId()); + alreadyExistRelList.add(jsonObj); + } + } + } + List list = createCiEntityTransactionVo(ciEntityTransactionMap, dependencyConfig, dependencyConfigMap); + ciEntityTransactionList.addAll(list); + } + // 关系选择追加模式时，需要将该配置项原来就关联的关系数据补充到valueList中 + for (JSONObject jsonObj : alreadyExistRelList) { + if (ciEntityIdList.contains(jsonObj.getLong("ciEntityId"))) { + continue; + } + valueList.add(jsonObj); + } + JSONObject relEntity = new JSONObject(); + relEntity.put("valueList", valueList); + relEntityData.put(key, relEntity); + } + } + } + ciEntityTransactionVo.setRelEntityData(relEntityData); + /** 全局属性 **/ + JSONObject globalAttrEntityData = new JSONObject(); + GlobalAttrVo searchVo = new GlobalAttrVo(); + searchVo.setIsActive(1); + List globalAttrList = globalAttrMapper.searchGlobalAttr(searchVo); + for (GlobalAttrVo globalAttrVo : globalAttrList) { + String key = "global_" + globalAttrVo.getId(); + CiEntitySyncMappingVo mappingObj = mappingMap.get(key); + if (mappingObj == null) { + JSONObject globalAttrEntity = new JSONObject(); + globalAttrEntity.put("valueList", new JSONArray()); + globalAttrEntityData.put(key, globalAttrEntity); + continue; + } + JSONArray valueList = new JSONArray(); + String mappingMode = mappingObj.getMappingMode(); + if (Objects.equals(mappingMode, "constant")) { + // 映射模式为常量 + JSONArray valueArray = mappingObj.getValueList(); + if (CollectionUtils.isNotEmpty(valueArray)) { + valueList = valueArray; + } + } + JSONObject globalAttrEntity = new JSONObject(); + globalAttrEntity.put("valueList", valueList); + globalAttrEntityData.put(key, globalAttrEntity); + } + ciEntityTransactionVo.setGlobalAttrEntityData(globalAttrEntityData); + + ciEntityTransactionList.add(ciEntityTransactionVo); + return ciEntityTransactionList; + } + + private JSONArray getTbodyList(ProcessTaskFormAttributeDataVo formAttributeDataVo, List filterList) { + JSONArray tbodyList = new JSONArray(); + if (formAttributeDataVo == null) { + return tbodyList; + } + if (!Objects.equals(formAttributeDataVo.getType(), neatlogic.framework.form.constvalue.FormHandler.FORMTABLEINPUTER.getHandler()) + && !Objects.equals(formAttributeDataVo.getType(), neatlogic.framework.form.constvalue.FormHandler.FORMTABLESELECTOR.getHandler())) { + return tbodyList; + } + if (formAttributeDataVo.getDataObj() == null) { + return tbodyList; + } + JSONArray dataList = (JSONArray) formAttributeDataVo.getDataObj(); + // 数据过滤 + if (CollectionUtils.isNotEmpty(filterList)) { + for (int i = 0; i < dataList.size(); i++) { + JSONObject data = dataList.getJSONObject(i); + if (MapUtils.isEmpty(data)) { + continue; + } + boolean flag = true; + for (CiEntitySyncFilterVo filterObj : filterList) { + String column = filterObj.getColumn(); + if (StringUtils.isBlank(column)) { + continue; + } + String expression = filterObj.getExpression(); + if (StringUtils.isBlank(expression)) { + continue; + } + String value = filterObj.getValue(); + if (StringUtils.isBlank(value)) { + continue; + } + if (Objects.equals(expression, Expression.EQUAL.getExpression())) { + if (!Objects.equals(value, data.getString(column))) { + flag = false; + break; + } + } else if (Objects.equals(expression, Expression.UNEQUAL.getExpression())) { + if (Objects.equals(value, data.getString(column))) { + flag = false; + break; + } + } else if (Objects.equals(expression, Expression.LIKE.getExpression())) { + String columnValue = data.getString(column); + if (StringUtils.isBlank(columnValue)) { + flag = false; + break; + } + if (!columnValue.contains(value)) { + flag = false; + break; + } + } else if (Objects.equals(expression, Expression.NOTLIKE.getExpression())) { + String columnValue = data.getString(column); + if (StringUtils.isBlank(columnValue)) { + continue; + } + if (columnValue.contains(value)) { + flag = false; + break; + } + } + } + if (flag) { + tbodyList.add(data); + } + } + } else { + tbodyList = dataList; + } + return tbodyList; + } + @Override protected int myAssign(ProcessTaskStepVo currentProcessTaskStepVo, Set workerSet) throws ProcessTaskException { return defaultAssign(currentProcessTaskStepVo, workerSet); diff --git a/src/main/java/neatlogic/module/cmdb/process/stephandler/CmdbSyncProcessUtilHandler.java b/src/main/java/neatlogic/module/cmdb/process/stephandler/CmdbSyncProcessUtilHandler.java index 2d39221d6216ad14fd4786c9cd97be6ce1e1466d..0e82aae73222fb831610b55f1b4678fb60030a89 100644 --- a/src/main/java/neatlogic/module/cmdb/process/stephandler/CmdbSyncProcessUtilHandler.java +++ b/src/main/java/neatlogic/module/cmdb/process/stephandler/CmdbSyncProcessUtilHandler.java @@ -18,29 +18,49 @@ package neatlogic.module.cmdb.process.stephandler; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; +import neatlogic.framework.cmdb.dto.transaction.TransactionVo; import neatlogic.framework.crossover.CrossoverServiceFactory; import neatlogic.framework.notify.crossover.INotifyServiceCrossoverService; import neatlogic.framework.notify.dto.InvokeNotifyPolicyConfigVo; import neatlogic.framework.process.constvalue.ProcessTaskOperationType; +import neatlogic.framework.process.dao.mapper.ProcessTaskStepDataMapper; import neatlogic.framework.process.dto.ProcessStepVo; import neatlogic.framework.process.dto.ProcessStepWorkerPolicyVo; +import neatlogic.framework.process.dto.ProcessTaskStepDataVo; import neatlogic.framework.process.dto.ProcessTaskStepVo; import neatlogic.framework.process.dto.processconfig.ActionConfigActionVo; import neatlogic.framework.process.dto.processconfig.ActionConfigVo; import neatlogic.framework.process.stephandler.core.ProcessStepInternalHandlerBase; import neatlogic.framework.process.util.ProcessConfigUtil; +import neatlogic.framework.util.TableResultUtil; +import neatlogic.module.cmdb.dao.mapper.transaction.TransactionMapper; +import neatlogic.module.cmdb.process.dto.*; +import neatlogic.module.cmdb.process.exception.CiEntityConfigIllegalException; import neatlogic.module.cmdb.process.notifyhandler.CiEntitySyncNotifyHandler; 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; import org.springframework.stereotype.Service; +import javax.annotation.Resource; import java.util.ArrayList; +import java.util.Iterator; import java.util.List; import java.util.Objects; @Service public class CmdbSyncProcessUtilHandler extends ProcessStepInternalHandlerBase { + + private Logger logger = LoggerFactory.getLogger(CmdbSyncProcessUtilHandler.class); + + @Resource + private ProcessTaskStepDataMapper processTaskStepDataMapper; + + @Resource + private TransactionMapper transactionMapper; + @Override public String getHandler() { return CmdbProcessStepHandlerType.CMDBSYNC.getHandler(); @@ -48,12 +68,56 @@ public class CmdbSyncProcessUtilHandler extends ProcessStepInternalHandlerBase { @Override public Object getHandlerStepInfo(ProcessTaskStepVo currentProcessTaskStepVo) { - return null; + return getHandlerStepInitInfo(currentProcessTaskStepVo); } @Override public Object getHandlerStepInitInfo(ProcessTaskStepVo currentProcessTaskStepVo) { - return null; + JSONObject resultObj = new JSONObject(); + /** 事务审计列表 **/ + ProcessTaskStepDataVo search = new ProcessTaskStepDataVo(); + search.setProcessTaskId(currentProcessTaskStepVo.getProcessTaskId()); + search.setProcessTaskStepId(currentProcessTaskStepVo.getId()); + search.setType("ciEntitySyncResult"); + ProcessTaskStepDataVo processTaskStepData = processTaskStepDataMapper.getProcessTaskStepData(search); + if (processTaskStepData != null) { + JSONObject dataObj = processTaskStepData.getData(); + JSONArray transactionGroupArray = dataObj.getJSONArray("transactionGroupList"); + if (CollectionUtils.isNotEmpty(transactionGroupArray)) { + List tableList = new ArrayList<>(); + for (int i = transactionGroupArray.size() - 1; i >= 0; i--) { + JSONObject transactionGroupObj = transactionGroupArray.getJSONObject(i); + Long time = transactionGroupObj.getLong("time"); + Long transactionGroupId = transactionGroupObj.getLong("transactionGroupId"); + TransactionVo transactionVo = new TransactionVo(); + transactionVo.setTransactionGroupId(transactionGroupId); + List tbodyList = transactionMapper.searchTransaction(transactionVo); + if (CollectionUtils.isNotEmpty(tbodyList)) { + JSONObject tableObj = TableResultUtil.getResult(tbodyList); + tableObj.put("time", time); + tableList.add(tableObj); + } + } + resultObj.put("tableList", tableList); + } + } + /** 错误信息列表 **/ + ProcessTaskStepDataVo searchVo = new ProcessTaskStepDataVo(); + searchVo.setProcessTaskId(currentProcessTaskStepVo.getProcessTaskId()); + searchVo.setProcessTaskStepId(currentProcessTaskStepVo.getId()); + searchVo.setType("ciEntitySyncError"); + ProcessTaskStepDataVo processTaskStepDataVo = processTaskStepDataMapper.getProcessTaskStepData(searchVo); + if (processTaskStepDataVo != null) { + JSONObject dataObj = processTaskStepDataVo.getData(); + if (MapUtils.isNotEmpty(dataObj)) { + resultObj.putAll(dataObj); +// JSONArray errorList = dataObj.getJSONArray("errorList"); +// if (CollectionUtils.isNotEmpty(errorList)) { +// resultObj.put("errorList", errorList); +// } + } + } + return resultObj; } @Override @@ -217,8 +281,8 @@ public class CmdbSyncProcessUtilHandler extends ProcessStepInternalHandlerBase { /** 自动化配置 **/ JSONObject ciEntityConfig = configObj.getJSONObject("ciEntityConfig"); - JSONObject ciEntityObj = regulateCiEntityConfig(ciEntityConfig); - resultObj.put("ciEntityConfig", ciEntityObj); + CiEntitySyncVo ciEntitySyncVo = regulateCiEntityConfig(ciEntityConfig); + resultObj.put("ciEntityConfig", ciEntitySyncVo); /** 分配处理人 **/ JSONObject workerPolicyConfig = configObj.getJSONObject("workerPolicyConfig"); @@ -235,7 +299,229 @@ public class CmdbSyncProcessUtilHandler extends ProcessStepInternalHandlerBase { return resultObj; } - private JSONObject regulateCiEntityConfig(JSONObject ciEntityConfig) { - return ciEntityConfig; + private CiEntitySyncVo regulateCiEntityConfig(JSONObject ciEntityConfig) { + CiEntitySyncVo ciEntitySyncVo = new CiEntitySyncVo(); + if (ciEntityConfig != null) { + ciEntitySyncVo = ciEntityConfig.toJavaObject(CiEntitySyncVo.class); + } + // 失败策略 + String failPolicy = ciEntitySyncVo.getFailPolicy(); + if (failPolicy == null) { + if (ciEntityConfig != null) { + logger.warn("ciEntityConfig.failPolicy is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.failPolicy is null"); + } + ciEntitySyncVo.setFailPolicy(StringUtils.EMPTY); + } + // 回退步骤重新同步 + Integer rerunStepToSync = ciEntitySyncVo.getRerunStepToSync(); + if (rerunStepToSync == null) { + if (ciEntityConfig != null) { + logger.warn("ciEntityConfig.rerunStepToSync is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.rerunStepToSync is null"); + } + ciEntitySyncVo.setRerunStepToSync(0); + } + List configList = ciEntitySyncVo.getConfigList(); + if (CollectionUtils.isEmpty(configList)) { + if (ciEntityConfig != null) { + logger.warn("ciEntityConfig.configList is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList is null"); + } + return ciEntitySyncVo; + } + Iterator iterator = configList.iterator(); + while (iterator.hasNext()) { + CiEntitySyncConfigVo configObj = iterator.next(); + if (configObj == null) { + iterator.remove(); + continue; + } + if (configObj.getId() != null) { + logger.warn("ciEntityConfig.configList[x].id is not null"); + configObj.setId(null); + } + if (StringUtils.isBlank(configObj.getUuid())) { + logger.warn("ciEntityConfig.configList[x].uuid is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].uuid is null"); + } + if (configObj.getCiId() == null) { + logger.warn("ciEntityConfig.configList[x].ciId is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].ciId is null"); + } + if (StringUtils.isBlank(configObj.getCiName())) { + logger.warn("ciEntityConfig.configList[x].ciName is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].ciName is null"); + } + if (StringUtils.isBlank(configObj.getCiLabel())) { + logger.warn("ciEntityConfig.configList[x].ciLabel is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].ciLabel is null"); + } + if (StringUtils.isBlank(configObj.getCiIcon())) { + logger.warn("ciEntityConfig.configList[x].ciIcon is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].ciIcon is null"); + } + String createPolicy = configObj.getCreatePolicy(); + if (StringUtils.isBlank(createPolicy)) { + logger.warn("ciEntityConfig.configList[x].createPolicy is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].createPolicy is null"); + } + CiEntitySyncBatchDataSourceVo batchDataSource = configObj.getBatchDataSource(); + if (Objects.equals(createPolicy, "single")) { + if (batchDataSource != null) { + if (StringUtils.isNotBlank(batchDataSource.getAttributeUuid())) { + logger.warn("ciEntityConfig.configList[x].batchDataSource.attributeUuid is not null"); + } + List filterList = batchDataSource.getFilterList(); + if (CollectionUtils.isNotEmpty(filterList)) { + logger.warn("ciEntityConfig.configList[x].batchDataSource.filterList is not null"); + } + } + } else if (Objects.equals(createPolicy, "batch")) { + if (batchDataSource == null) { + logger.warn("createPolicy = batch, ciEntityConfig.configList[x].batchDataSource is null"); + throw new CiEntityConfigIllegalException("createPolicy = batch, ciEntityConfig.configList[x].batchDataSource is null"); + } + if (StringUtils.isBlank(batchDataSource.getAttributeUuid())) { + logger.warn("ciEntityConfig.configList[x].batchDataSource.attributeUuid is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].batchDataSource.attributeUuid is null"); + } + List filterList = batchDataSource.getFilterList(); + if (CollectionUtils.isNotEmpty(filterList)) { + Iterator filterIterator = filterList.iterator(); + while (filterIterator.hasNext()) { + CiEntitySyncFilterVo filterVo = filterIterator.next(); + if (filterVo == null) { + logger.warn("ciEntityConfig.configList[x].batchDataSource.filterList[y] is null"); + filterIterator.remove(); + continue; + } + if (StringUtils.isBlank(filterVo.getColumn())) { + logger.warn("ciEntityConfig.configList[x].batchDataSource.filterList[y].column is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].batchDataSource.filterList[y].column is null"); + } + if (StringUtils.isBlank(filterVo.getExpression())) { + logger.warn("ciEntityConfig.configList[x].batchDataSource.filterList[y].expression is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].batchDataSource.filterList[y].expression is null"); + } + if (StringUtils.isBlank(filterVo.getValue())) { + logger.warn("ciEntityConfig.configList[x].batchDataSource.filterList[y].value is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].batchDataSource.filterList[y].value is null"); + } + } + } + } + + List mappingList = configObj.getMappingList(); + if (CollectionUtils.isEmpty(mappingList)) { + logger.warn("ciEntityConfig.configList[x].mappingList is null"); + continue; +// throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList is null"); + } + Iterator mappingIterator = mappingList.iterator(); + while (mappingIterator.hasNext()) { + CiEntitySyncMappingVo mappingVo = mappingIterator.next(); + if (mappingVo == null) { + logger.warn("ciEntityConfig.configList[x].mappingList[y] is null"); + mappingIterator.remove(); + continue; + } + if (StringUtils.isBlank(mappingVo.getKey())) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].key is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].key is null"); + } + String mappingMode = mappingVo.getMappingMode(); + if (StringUtils.isBlank(mappingMode)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].mappingMode is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].mappingMode is null"); + } + JSONArray valueList = mappingVo.getValueList(); + String column = mappingVo.getColumn(); + List filterList = mappingVo.getFilterList(); + if (Objects.equals(mappingMode, "formTableComponent")) { + if (CollectionUtils.isEmpty(valueList)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].valueList is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].valueList is null"); + } + if (valueList.get(0) == null) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].valueList[0] is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].valueList[0] is null"); + } + if (StringUtils.isBlank(column)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].column is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].column is null"); + } + if (CollectionUtils.isNotEmpty(filterList)) { + Iterator filterIterator = filterList.iterator(); + while (filterIterator.hasNext()) { + CiEntitySyncFilterVo filterVo = filterIterator.next(); + if (filterVo == null) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].filterList[z] is null"); + filterIterator.remove(); + continue; + } + if (StringUtils.isBlank(filterVo.getColumn())) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].filterList[z].column is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].filterList[z].column is null"); + } + if (StringUtils.isBlank(filterVo.getExpression())) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].filterList[z].expression is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].filterList[z].expression is null"); + } + if (StringUtils.isBlank(filterVo.getValue())) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].filterList[z].value is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].filterList[z].value is null"); + } + } + } + } else if (Objects.equals(mappingMode, "formCommonComponent")) { + if (CollectionUtils.isEmpty(valueList)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].valueList is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].valueList is null"); + } + for (int i = 0; i < valueList.size(); i++) { + if (valueList.get(i) == null) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].valueList[z] is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].valueList[0] is null"); + } + } + if (StringUtils.isNotBlank(column)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].column is not null"); + mappingVo.setColumn(null); + } + if (CollectionUtils.isNotEmpty(filterList)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].filterList is not null"); + mappingVo.setFilterList(null); + } + } else if (Objects.equals(mappingMode, "constant")) { + if (StringUtils.isNotBlank(column)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].column is not null"); + mappingVo.setColumn(null); + } + if (CollectionUtils.isNotEmpty(filterList)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].filterList is not null"); + mappingVo.setFilterList(null); + } + } else if (Objects.equals(mappingMode, "new")) { + if (CollectionUtils.isEmpty(valueList)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].valueList is null"); + } + + if (valueList.get(0) == null) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].valueList[0] is null"); + throw new CiEntityConfigIllegalException("ciEntityConfig.configList[x].mappingList[y].valueList[0] is null"); + } + if (StringUtils.isNotBlank(column)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].column is not null"); + mappingVo.setColumn(null); + } + if (CollectionUtils.isNotEmpty(filterList)) { + logger.warn("ciEntityConfig.configList[x].mappingList[y].filterList is not null"); + mappingVo.setFilterList(null); + } + } + } + } + return ciEntitySyncVo; } }