package com.highdatas.mdm.service.act.impl;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.fasterxml.jackson.databind.JsonNode;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.fasterxml.jackson.databind.node.ObjectNode;
|
import com.highdatas.mdm.pojo.Result;
|
import com.highdatas.mdm.util.WorkflowUtils;
|
import lombok.extern.slf4j.Slf4j;
|
import org.activiti.bpmn.converter.BpmnXMLConverter;
|
import org.activiti.bpmn.model.BpmnModel;
|
import org.activiti.bpmn.model.FlowElement;
|
import org.activiti.editor.constants.ModelDataJsonConstants;
|
import org.activiti.editor.language.json.converter.BpmnJsonConverter;
|
import org.activiti.engine.ActivitiException;
|
import org.activiti.engine.RepositoryService;
|
import org.activiti.engine.repository.Deployment;
|
import org.activiti.engine.repository.Model;
|
import org.activiti.engine.repository.ModelQuery;
|
import org.activiti.engine.repository.ProcessDefinition;
|
import org.activiti.engine.task.Task;
|
import org.apache.batik.transcoder.TranscoderInput;
|
import org.apache.batik.transcoder.TranscoderOutput;
|
import org.apache.batik.transcoder.image.PNGTranscoder;
|
import org.apache.commons.fileupload.FileItem;
|
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
|
import org.apache.commons.fileupload.servlet.ServletFileUpload;
|
import org.apache.commons.io.FilenameUtils;
|
import org.apache.commons.io.IOUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.ClassUtils;
|
|
import javax.servlet.http.HttpServletRequest;
|
import javax.servlet.http.HttpServletResponse;
|
import javax.xml.stream.XMLInputFactory;
|
import javax.xml.stream.XMLStreamReader;
|
import java.io.*;
|
import java.util.*;
|
import java.util.zip.ZipInputStream;
|
|
@Slf4j
|
@Service
|
public class RepositoryServiceImpl extends BaseServiceImpl implements com.highdatas.mdm.service.act.RepositoryService{
|
|
private static final String MODEL_NAME = "name";
|
private static final String MODEL_REVISION = "revision";
|
private static final String MODEL_DESCRIPTION = "description";
|
@Autowired
|
RepositoryService service;
|
@Autowired
|
ObjectMapper objectMapper;
|
@Value("${img.url}")
|
String basePath;
|
//download
|
public void getModelXml(HttpServletResponse response, String modelId) throws IOException {
|
Model model = service.getModel(modelId);
|
BpmnJsonConverter jsonConverter = new BpmnJsonConverter();
|
JsonNode editorNode = new ObjectMapper().readTree(service.getModelEditorSource(model.getId()));
|
BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(editorNode);
|
BpmnXMLConverter xmlConverter = new BpmnXMLConverter();
|
byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);
|
|
ByteArrayInputStream in = new ByteArrayInputStream(bpmnBytes);
|
IOUtils.copy(in, response.getOutputStream());
|
String filename = bpmnModel.getMainProcess().getId() + ".bpmn20.xml";
|
response.setHeader("Content-Disposition", "attachment; filename=" + filename);
|
response.flushBuffer();
|
}
|
|
public boolean updateProcessDefStatus(String type, String modelId) {
|
Model model = service.createModelQuery().modelId(modelId).singleResult();
|
ProcessDefinition processDefinition = service.createProcessDefinitionQuery().deploymentId(model.getDeploymentId()).singleResult();
|
String processDefinitionId = processDefinition.getId();
|
try {
|
if ("active".equalsIgnoreCase(type)) {
|
service.activateProcessDefinitionById(processDefinitionId, true, null);
|
}
|
else if ("suspend".equalsIgnoreCase(type)) {
|
service.suspendProcessDefinitionById(processDefinitionId, true, null);
|
}
|
return true;
|
//resultPool.addValue(type +" update success");
|
} catch (Exception e) {
|
e.printStackTrace();
|
|
//resultPool.addValue(type +" update fail");
|
log.debug(type +" update fail");
|
return false;
|
}
|
|
}
|
|
public boolean deleteDeployModel(String modelId) {
|
try {
|
Model modelData = service.getModel(modelId);
|
String deploymentId = modelData.getDeploymentId();
|
|
if (deploymentId != null) {
|
service.deleteDeployment(deploymentId, true);
|
modelData.setDeploymentId(null);
|
modelData.setCategory(null);
|
}
|
return true;
|
//resultPool.addValue("删除部署成功，部署ID=" + deploymentId);
|
}
|
catch (Exception e) {
|
e.printStackTrace();
|
//resultPool.addValue("删除部署失败，modelId=" + modelId);
|
log.error("根据模型删除部署流程失败：modelId="+modelId, e);
|
return false;
|
}
|
|
}
|
|
public boolean deployModel(String modelId) {
|
try {
|
Model modelData = service.getModel(modelId);
|
ObjectNode modelNode = (ObjectNode) new ObjectMapper().readTree(service.getModelEditorSource(modelData.getId()));
|
byte[] bpmnBytes = null;
|
BpmnModel model = new BpmnJsonConverter().convertToBpmnModel(modelNode);
|
bpmnBytes = new BpmnXMLConverter().convertToXML(model);
|
|
String processName = modelData.getName() + ".bpmn20.xml";
|
Deployment deployment = service.createDeployment().name(modelData.getName()).addString(processName, new String(bpmnBytes,"UTF-8")).deploy();
|
modelData.setDeploymentId(deployment.getId());
|
modelData.setCategory(deployment.getId());
|
|
service.saveModel(modelData);
|
return true;
|
// resultPool.addValue("部署成功，部署ID=" + deployment.getId());
|
}
|
catch (Exception e) {
|
e.printStackTrace();
|
//resultPool.addValue("部署失败，modelId=" + modelId);
|
log.error("根据模型部署流程失败：modelId="+modelId, e);
|
return false;
|
}
|
|
}
|
@Override
|
public boolean deleteModel(String modelId) {
|
try {
|
Model model = service.getModel(modelId);
|
String deploymentId = model.getDeploymentId();
|
if (deploymentId != null) {
|
//TODO
|
// updateDeletedStatus("agreement",deploymentId);
|
// updateDeletedStatus("rebateslit",deploymentId);
|
//updateDeletedStatus("agreement",deploymentId);
|
service.deleteDeployment(deploymentId,true);
|
}
|
service.deleteModel(modelId);
|
return true;
|
//resultPool.addValue("delete model successful");
|
}
|
catch (Exception e) {
|
e.printStackTrace();
|
log.debug("delete model failed");
|
//resultPool.addValue("delete model failed");
|
return false;
|
}
|
|
}
|
|
public String createModel(String modelName, String key, String desp) throws UnsupportedEncodingException {
|
ObjectMapper objectMapper = new ObjectMapper();
|
ObjectNode editorNode = objectMapper.createObjectNode();
|
editorNode.put("id", "canvas");
|
editorNode.put("resourceId", "canvas");
|
ObjectNode stencilSetNode = objectMapper.createObjectNode();
|
stencilSetNode.put("namespace", "http://b3mn.org/stencilset/bpmn2.0#");
|
editorNode.set("stencilset", stencilSetNode);
|
Model modelData = service.newModel();
|
|
ObjectNode modelObjectNode = objectMapper.createObjectNode();
|
modelObjectNode.put(MODEL_NAME, modelName);
|
modelObjectNode.put(MODEL_REVISION, 1);
|
modelObjectNode.put(MODEL_DESCRIPTION, desp);
|
modelData.setMetaInfo(modelObjectNode.toString());
|
modelData.setName(modelName);
|
modelData.setKey(key);
|
|
service.saveModel(modelData);
|
service.addModelEditorSource(modelData.getId(), editorNode.toString().getBytes("utf-8"));
|
String id = modelData.getId();
|
return id;
|
//resultPool.addValue(id);
|
}
|
|
@SuppressWarnings("unchecked")
|
public void uploadFlow(HttpServletRequest request) {
|
try{
|
//TODO 修改需
|
DiskFileItemFactory factory = new DiskFileItemFactory();
|
ServletFileUpload servletFileUpload = new ServletFileUpload(factory);
|
servletFileUpload.setHeaderEncoding("UTF-8");
|
List<FileItem> items = servletFileUpload.parseRequest(request);
|
if (items.isEmpty()) {
|
|
//resultPool.error("请选择上传文件");
|
return;
|
}
|
FileItem fileItem = items.get(0);
|
InputStream inputStream = fileItem.getInputStream();
|
Deployment deployment = null;
|
|
String extension = FilenameUtils.getExtension(fileItem.getName());
|
if (extension.equals("zip") || extension.equals("bar")) {
|
ZipInputStream zip = new ZipInputStream(inputStream);
|
deployment = service.createDeployment().addZipInputStream(zip).deploy();
|
} else {
|
deployment = service.createDeployment().addInputStream(fileItem.getName(), inputStream).deploy();
|
}
|
|
ProcessDefinition processDefinition = service.createProcessDefinitionQuery().deploymentId(deployment.getId()).singleResult();
|
Model model = change2Model(processDefinition);
|
byte[] modelEditorSource = service.getModelEditorSource(model.getId());
|
String string = new String(modelEditorSource, "utf-8");
|
log.debug(string);
|
//TODO dir
|
WorkflowUtils.exportDiagramToFile(service, processDefinition, "model/"+model.getId()+".png");
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
log.error("error on deploy process, because of file input stream", e);
|
}
|
}
|
|
private Model change2Model(ProcessDefinition processDefinition)throws Exception {
|
InputStream bpmnStream = service.getResourceAsStream(processDefinition.getDeploymentId(),processDefinition.getResourceName());
|
String processDefinitionKey = processDefinition.getKey();
|
int modelVersion = 1;
|
XMLInputFactory xif = XMLInputFactory.newInstance();
|
InputStreamReader in = new InputStreamReader(bpmnStream, "UTF-8");
|
XMLStreamReader xtr = xif.createXMLStreamReader(in);
|
BpmnModel bpmnModel = new BpmnXMLConverter().convertToBpmnModel(xtr);
|
|
BpmnJsonConverter converter = new BpmnJsonConverter();
|
ObjectNode modelNode = converter.convertToJson(bpmnModel);
|
|
List<Model> list = service.createModelQuery().modelKey(processDefinitionKey).orderByModelVersion().desc().list();
|
|
if (list.size() != 0) {
|
Model MaxVerModel = list.get(0);
|
Integer version = MaxVerModel.getVersion();
|
modelVersion = version+1;
|
}
|
|
Model modelData = service.newModel();
|
modelData.setKey(processDefinitionKey);
|
modelData.setName(processDefinition.getResourceName());
|
modelData.setCategory(processDefinition.getDeploymentId());
|
modelData.setDeploymentId(processDefinition.getDeploymentId());
|
modelData.setVersion(modelVersion);
|
|
ObjectNode modelObjectNode = new ObjectMapper().createObjectNode();
|
modelObjectNode.put(ModelDataJsonConstants.MODEL_NAME, processDefinition.getName());
|
modelObjectNode.put(ModelDataJsonConstants.MODEL_REVISION, modelVersion);
|
modelObjectNode.put(ModelDataJsonConstants.MODEL_DESCRIPTION, processDefinition.getDescription());
|
modelData.setMetaInfo(modelObjectNode.toString());
|
|
service.saveModel(modelData);
|
service.addModelEditorSource(modelData.getId(), modelNode.toString().getBytes("utf-8"));
|
return modelData;
|
}
|
|
public void readProcessResource(String resoucreType, String processDefinitionId,HttpServletResponse response) {
|
String resourceName = "";
|
ProcessDefinition processDefinition = service.createProcessDefinitionQuery().processDefinitionId(processDefinitionId).singleResult();
|
|
if ("xml".equalsIgnoreCase(resoucreType)) {
|
|
}
|
else if ("image".equalsIgnoreCase(resoucreType)) {
|
resourceName = processDefinition.getDiagramResourceName();
|
}
|
//TODO resp
|
InputStream resourceAsStream = service.getResourceAsStream(processDefinition.getDeploymentId(), resourceName);
|
try {
|
byte[] b = new byte[1024];
|
int len = -1;
|
while ((len = resourceAsStream.read(b, 0, 1024)) != -1) {
|
response.getOutputStream().write(b, 0, len);
|
}
|
}
|
catch (Exception e) {
|
e.printStackTrace();
|
error("file can not be read");
|
}
|
finally {
|
try {
|
resourceAsStream.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
error("steam can not be close");
|
}
|
}
|
|
}
|
|
public Result<JSONArray> getProcessList() {
|
List<Object[]> processList = new ArrayList<Object[]>();
|
ModelQuery modelQuery = service.createModelQuery().orderByModelVersion().desc();
|
List<Model> list = modelQuery.list();
|
for (Model model: list) {
|
boolean isAdd = true;
|
String deploymentId = model.getDeploymentId();
|
Deployment deployment = null;
|
ProcessDefinition prodef= null;
|
|
if (deploymentId != null) {
|
prodef = service.createProcessDefinitionQuery().deploymentId(deploymentId).singleResult();
|
deployment = service.createDeploymentQuery().deploymentId(deploymentId).singleResult();
|
}
|
for (Object[] obj : processList) {
|
Model processModel = (Model) obj[0];
|
if (model.getKey().equals(processModel.getKey())) {
|
if (model.getVersion() <= processModel.getVersion()) {
|
isAdd = false;
|
continue;
|
}
|
}
|
}
|
if (isAdd) {
|
processList.add(new Object[]{model, deployment,prodef});
|
}
|
|
}
|
|
JSONArray array = new JSONArray();
|
for (Object[] bean : processList) {
|
JSONObject object = new JSONObject();
|
Model model = (Model)bean[0];
|
Deployment deployment = (Deployment)bean[1];
|
ProcessDefinition prodef = (ProcessDefinition)bean[2];
|
|
if (model != null) {
|
object.fluentPut("id", model.getId());
|
object.fluentPut("category", model.getCategory());
|
object.fluentPut("version", model.getVersion());
|
object.fluentPut("createTime", model.getCreateTime());
|
object.fluentPut("lastUpdateTime", model.getLastUpdateTime());
|
object.fluentPut("description", model.getMetaInfo());
|
}
|
|
//2.
|
if (deployment != null) {
|
object.fluentPut("isDeploymented", "true");
|
object.fluentPut("deploymentTime", deployment.getDeploymentTime());
|
}else {
|
object.fluentPut("isDeploymented", "false");
|
object.fluentPut("deploymentTime", "未部署");
|
}
|
//3.
|
if (prodef != null) {
|
object.fluentPut("isSuspension", String.valueOf(prodef.isSuspended()));
|
object.fluentPut("name", prodef.getName());
|
|
}else {
|
object.fluentPut("isSuspension", "false");
|
object.fluentPut("name", model.getName());
|
}
|
array.add(object);
|
}
|
return Result.success(array);
|
//return processList;
|
|
//resultPool.addValue("processList", processList, new ModelWriter());
|
}
|
|
public Model getModel(String modelId) {
|
Model model = service.getModel(modelId);
|
ObjectNode modelNode;
|
|
if (model != null) {
|
try {
|
if (StringUtils.isNotEmpty(model.getMetaInfo())) {
|
modelNode = (ObjectNode) objectMapper.readTree(model.getMetaInfo());
|
}
|
else {
|
modelNode = objectMapper.createObjectNode();
|
modelNode.put(ModelDataJsonConstants.MODEL_NAME, model.getName());
|
}
|
|
modelNode.put(ModelDataJsonConstants.MODEL_ID, model.getId());
|
ObjectNode editorJsonNode = (ObjectNode) objectMapper.readTree(new String(service.getModelEditorSource(model.getId()), "utf-8"));
|
modelNode.put("model", editorJsonNode);
|
|
// resultPool.addValue("name",model.getName());
|
// resultPool.addValue("description", model.getMetaInfo());
|
// resultPool.addValue("modelId", modelId);
|
// resultPool.addJson("model", editorJsonNode.toString());
|
}
|
catch (Exception e) {
|
log.error("Error creating model JSON", e);
|
throw new ActivitiException("Error creating model JSON", e);
|
}
|
}
|
return model;
|
}
|
|
public boolean saveModel(String modelId, HttpServletRequest request) {
|
HashMap<String,String> hashMap = new HashMap<String, String>();
|
StringBuilder builder = new StringBuilder();
|
FileOutputStream fileOutputStream2 = null;
|
ByteArrayOutputStream outStream = null;
|
FileOutputStream fileOutputStream = null;
|
try {
|
//1.1
|
request.setCharacterEncoding("utf-8");
|
Map<String, String[]> parameterMap = request.getParameterMap();
|
Set<String> keys = parameterMap.keySet();
|
for (String key : keys) {
|
String[] strings = parameterMap.get(key);
|
for (String string : strings) {
|
builder.append(string);
|
}
|
hashMap.put(key, builder.toString());
|
builder.setLength(0);
|
}
|
|
String jsonXmlString = hashMap.get("json_xml");
|
jsonXmlString = jsonXmlString.replaceAll("\\+\\+", "&&");
|
hashMap.put("json_xml", jsonXmlString);
|
|
Model model = service.getModel(modelId);
|
Integer version = model.getVersion();
|
String key = model.getKey();
|
//1.2 add new model version++
|
Model newModel = service.newModel();
|
ObjectNode modelJson = (ObjectNode) objectMapper.readTree(model.getMetaInfo());
|
modelJson.put(MODEL_NAME, hashMap.get("name"));
|
modelJson.put(MODEL_DESCRIPTION, hashMap.get("description"));
|
modelJson.put(MODEL_REVISION, (version + 1));
|
|
newModel.setMetaInfo(modelJson.toString());
|
newModel.setVersion((version + 1));
|
newModel.setName(hashMap.get("name"));
|
newModel.setKey(key);
|
|
//1.3
|
ObjectNode modelNode = (ObjectNode) new ObjectMapper().readTree(hashMap.get("json_xml").getBytes("utf-8"));
|
BpmnModel bpmnModel = new BpmnJsonConverter().convertToBpmnModel(modelNode);
|
if (bpmnModel.getProcesses().size() == 0) {
|
return false;
|
}
|
byte[] bpmnBytes = new BpmnXMLConverter().convertToXML(bpmnModel);
|
String processName = newModel.getName()+ ".bpmn20.xml";
|
Deployment deployment = service.createDeployment().name(newModel.getName()).addString(processName,new String(bpmnBytes,"UTF-8")).deploy();
|
newModel.setDeploymentId(deployment.getId());
|
newModel.setCategory(deployment.getId());
|
|
service.saveModel(newModel);
|
|
//1.4
|
service.addModelEditorSource(newModel.getId(), hashMap.get("json_xml").getBytes("utf-8"));
|
|
InputStream svgStream = new ByteArrayInputStream(hashMap.get("svg_xml").getBytes("utf-8"));
|
TranscoderInput input = new TranscoderInput(svgStream);
|
PNGTranscoder transcoder = new PNGTranscoder();
|
outStream = new ByteArrayOutputStream();
|
TranscoderOutput output = new TranscoderOutput(outStream);
|
transcoder.transcode(input, output);
|
final byte[] result = outStream.toByteArray();
|
service.addModelEditorSourceExtra(newModel.getId(), result);
|
String newModelId = newModel.getId();
|
//TODO dir 2.
|
String path = basePath + newModelId;
|
File dir = new File(path);
|
if (!dir.exists()) {
|
dir.mkdirs();
|
}
|
//2.1 save model xml to server
|
|
File file = new File(path,newModelId + ".bpmn20.xml");
|
if (file.exists()) {
|
file.delete();
|
}
|
log.info(file.getAbsolutePath());
|
file.createNewFile();
|
fileOutputStream2 = new FileOutputStream(file);
|
fileOutputStream2.write(bpmnBytes);
|
|
//2.2 save model png to server
|
fileOutputStream = new FileOutputStream(new File(path,newModelId + ".png"));
|
InputStream svgs = new ByteArrayInputStream(hashMap.get("svg_xml").getBytes("utf-8"));
|
TranscoderInput inputs = new TranscoderInput(svgs);
|
TranscoderOutput outputs = new TranscoderOutput(fileOutputStream);
|
transcoder.transcode(inputs, outputs);
|
fileOutputStream.flush();
|
return true;
|
} catch (Exception e) {
|
log.error("Error saving model", e);
|
return false;
|
}
|
finally {
|
try {
|
if (fileOutputStream != null) {
|
fileOutputStream.close();
|
}
|
if (fileOutputStream2 != null) {
|
fileOutputStream2.close();
|
}
|
if (outStream != null) {
|
outStream.close();
|
}
|
|
}
|
catch (IOException e) {
|
log.error("Error close ioStream ", e);
|
e.printStackTrace();
|
return false;
|
}
|
}
|
}
|
|
public void getEditor() {
|
// File file = new File(Configer.getPath_Config(), "stencilset.json");
|
// String value = null;
|
//
|
// FileInputStream fileInputStream = new FileInputStream(file);
|
// try {
|
// value = IOUtils.toString(fileInputStream, "utf-8");
|
// }
|
// finally {
|
// fileInputStream.close();
|
// }
|
|
//resultPool.setJson(value);
|
}
|
|
public static void save2File(InputStream input, String filePath,String fileName) {
|
BufferedOutputStream bos = null;
|
FileOutputStream fos = null;
|
File file = null;
|
try {
|
file = new File(filePath,fileName);
|
fos = new FileOutputStream(file);
|
bos = new BufferedOutputStream(fos);
|
int ch = 0;
|
int read = input.read();
|
|
while((ch=read) != -1){
|
fos.write(ch);
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
} finally {
|
if (bos != null) {
|
try {
|
bos.close();
|
} catch (IOException e1) {
|
e1.printStackTrace();
|
}
|
}
|
if (fos != null) {
|
try {
|
fos.close();
|
} catch (IOException e1) {
|
e1.printStackTrace();
|
}
|
}
|
}
|
}
|
|
private void updateDeletedStatus(String tableName, String deploymentId) throws Exception {
|
//TODO db
|
// NamedSQL getDeletedWorkflowItem = NamedSQL.getInstance("getDeletedWorkflowItem");
|
// getDeletedWorkflowItem.setParam("tablename", tableName);
|
// getDeletedWorkflowItem.setParam("deploymentid", deploymentId);
|
// EntitySet entitySet = SQLRunner.getEntitySet(getDeletedWorkflowItem);
|
//
|
// for (Entity entity : entitySet) {
|
// String id = entity.getString("id");
|
// Entity line = DataHandler.getLine(tableName, id);
|
// String statusCode = line.getString("statuscode");
|
//
|
// if (statusCode.equalsIgnoreCase("open")) {
|
// continue;
|
// }
|
// line.setString("statuscode", "input");
|
// line.update();
|
//
|
// DataHandler.clearFieldbyEntity(line, "keycode");
|
// }
|
|
}
|
|
public String getNextPosition(Task task) {
|
String currentPosition = task.getTaskDefinitionKey();
|
String processDefinitionId = task.getProcessDefinitionId();
|
BpmnModel bpmnModel = service.getBpmnModel(processDefinitionId);
|
|
if (bpmnModel != null) {
|
Collection<FlowElement> flowElements = bpmnModel.getMainProcess().getFlowElements();
|
FlowElement[] flowArray = new FlowElement[flowElements.size()];
|
flowElements.toArray(flowArray);
|
|
int pos = -1;
|
|
//1. goto current position
|
for (int i = 0; i < flowArray.length - 1; i++) {
|
FlowElement flowElement = flowArray[i];
|
|
if (flowElement.getId().equalsIgnoreCase(currentPosition)) {
|
pos = i;
|
}
|
}
|
|
if (pos < 0) {
|
return null;
|
}
|
|
//2. find parent
|
for (int i = pos + 1; i < flowArray.length -1; i++) {
|
FlowElement element = flowArray[i];
|
String type = element.getClass().getSimpleName();
|
|
if (!"UserTask".equalsIgnoreCase(type)) {
|
continue;
|
}
|
|
return element.getId();
|
}
|
}
|
|
return null;
|
}
|
}
|
