package process.service;
|
|
import java.io.BufferedInputStream;
|
import java.io.BufferedOutputStream;
|
import java.io.BufferedReader;
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.InputStreamReader;
|
import java.io.OutputStream;
|
import java.net.URLDecoder;
|
import java.nio.file.FileSystem;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.zip.ZipInputStream;
|
|
import javax.print.attribute.HashAttributeSet;
|
import javax.servlet.ServletInputStream;
|
import javax.servlet.http.HttpServletRequest;
|
import javax.xml.stream.XMLInputFactory;
|
import javax.xml.stream.XMLStreamReader;
|
|
|
import oracle.net.aso.f;
|
import oracle.net.aso.s;
|
|
import org.activiti.bpmn.converter.BpmnXMLConverter;
|
import org.activiti.bpmn.model.BpmnModel;
|
import org.activiti.editor.constants.ModelDataJsonConstants;
|
import org.activiti.editor.language.json.converter.BpmnJsonConverter;
|
import org.activiti.editor.ui.DeployModelPopupWindow;
|
import org.activiti.engine.ActivitiException;
|
import org.activiti.engine.impl.cmd.SaveModelCmd;
|
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.apache.batik.transcoder.TranscoderInput;
|
import org.apache.batik.transcoder.TranscoderOutput;
|
import org.apache.batik.transcoder.image.PNGTranscoder;
|
import org.apache.commons.fileupload.DiskFileUpload;
|
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.apache.http.client.utils.URLEncodedUtils;
|
|
import process.WorkflowUtils;
|
import process.service.writer.ModelWriter;
|
|
import com.fasterxml.jackson.databind.JsonNode;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.fasterxml.jackson.databind.node.ObjectNode;
|
import com.mxgraph.io.graphml.mxGraphMlKey.keyForValues;
|
|
import foundation.callable.Callable;
|
import foundation.config.Configer;
|
|
|
public class RepositoryService extends Service {
|
|
private static final String MODEL_NAME = "name";
|
private static final String MODEL_REVISION = "revision";
|
private static final String MODEL_DESCRIPTION = "description";
|
private org.activiti.engine.RepositoryService service;
|
private ObjectMapper objectMapper;
|
private HttpServletRequest request;
|
|
public RepositoryService(Callable context) throws Exception {
|
super(context);
|
service = processEngine.getRepositoryService();
|
objectMapper = new ObjectMapper();
|
request = context.getRequest();
|
}
|
|
@Override
|
public void call(String operator) throws Exception {
|
if ("model".equalsIgnoreCase(operator)) {
|
String modelOperator = paths[4];
|
if (modelOperator.equalsIgnoreCase("save")) {
|
saveModel();
|
}
|
else {
|
getModel();
|
}
|
}
|
else if ("editor".equalsIgnoreCase(operator)) {
|
getEditor();
|
}
|
else if ("createModel".equalsIgnoreCase(operator)) {
|
createModel();
|
}
|
else if ("deleteModel".equalsIgnoreCase(operator)) {
|
deleteModel();
|
}
|
else if ("deployModel".equalsIgnoreCase(operator)) {
|
deployModel();
|
}
|
else if ("getProcessList".equalsIgnoreCase(operator)) {
|
getProcessList();
|
}
|
else if ("readProcessSource".equals(operator)) {
|
readProcessResource();
|
}
|
else if ("uploadProcess".equalsIgnoreCase(operator)) {
|
uploadProcess();
|
}
|
else if ("updateProcessDefStatus".equalsIgnoreCase(operator)) {
|
updateProcessDefStatus();
|
}
|
else if ("getModelXml".equalsIgnoreCase(operator)) {
|
getModelXml();
|
}
|
}
|
|
|
|
private void getModelXml() throws Exception {
|
String getModleId = request.getParameter("modleId");
|
Model model = service.getModel(getModleId);
|
ProcessDefinition processDefinition = service.createProcessDefinitionQuery().deploymentId(model.getDeploymentId()).singleResult();
|
String resourceName = processDefinition.getResourceName();
|
InputStream resourceAsStream = service.getResourceAsStream(processDefinition.getDeploymentId(), resourceName);
|
|
response.setContentType(request.getServletContext().getMimeType(resourceName));
|
//设置Content-Disposition
|
response.setHeader("Content-Disposition", "attachment;filename="+resourceName);
|
byte[] b = new byte[1024];
|
int len = -1;
|
|
while ((len = resourceAsStream.read(b, 0, 1024)) != -1) {
|
response.getOutputStream().write(b, 0, len);
|
}
|
}
|
|
private void updateProcessDefStatus() {
|
String type = request.getParameter("type");
|
|
String modelId = request.getParameter("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);
|
}
|
resultPool.addValue(type +" update success");
|
} catch (Exception e) {
|
e.printStackTrace();
|
resultPool.addValue(type +" update fail");
|
logger.debug(type +" update fail");
|
|
}
|
|
}
|
|
private void deployModel() {
|
String modelId = request.getParameter("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)).deploy();
|
modelData.setDeploymentId(deployment.getId());
|
modelData.setCategory(deployment.getId());
|
service.saveModel(modelData);
|
|
resultPool.addValue("部署成功，部署ID=" + deployment.getId());
|
} catch (Exception e) {
|
e.printStackTrace();
|
resultPool.addValue("部署失败，modelId=" + modelId);
|
logger.error("根据模型部署流程失败：modelId="+modelId, e);
|
}
|
}
|
|
private void deleteModel() {
|
String modelId = request.getParameter("modelId");
|
try {
|
Model model = service.getModel(modelId);
|
String deploymentId = model.getDeploymentId();
|
if (deploymentId == null) {
|
service.deleteModel(modelId);
|
}else {
|
service.deleteDeployment(deploymentId, true);
|
}
|
resultPool.addValue("delete model successful");
|
} catch (Exception e) {
|
e.printStackTrace();
|
logger.debug("delete model failed");
|
resultPool.addValue("delete model failed");
|
}
|
}
|
private void createModel() throws Exception {
|
String modelName = request.getParameter("name");
|
String key = request.getParameter("key");
|
String desp = request.getParameter("desp");
|
|
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();
|
|
resultPool.addValue(id);
|
}
|
private void uploadProcess() {
|
try{
|
DiskFileItemFactory factory = new DiskFileItemFactory();
|
ServletFileUpload upload = new ServletFileUpload(factory);
|
upload.setHeaderEncoding("UTF-8");
|
List<FileItem> items = upload.parseRequest(request);
|
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();
|
}
|
|
List<ProcessDefinition> list = service.createProcessDefinitionQuery().deploymentId(deployment.getId()).list();
|
|
for (ProcessDefinition processDefinition : list) {
|
WorkflowUtils.exportDiagramToFile(service, processDefinition, Configer.getPath_Application()+"/model ");
|
change2Model(processDefinition);
|
}
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
logger.error("error on deploy process, because of file input stream", e);
|
}
|
}
|
|
private void change2Model(ProcessDefinition processDefinition)throws Exception {
|
InputStream bpmnStream = service.getResourceAsStream(processDefinition.getDeploymentId(),processDefinition.getResourceName());
|
|
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();
|
com.fasterxml.jackson.databind.node.ObjectNode modelNode = converter.convertToJson(bpmnModel);
|
Model modelData = service.newModel();
|
modelData.setKey(processDefinition.getKey());
|
modelData.setName(processDefinition.getResourceName());
|
modelData.setCategory(processDefinition.getDeploymentId());
|
modelData.setDeploymentId(processDefinition.getDeploymentId());
|
|
ObjectNode modelObjectNode = new ObjectMapper().createObjectNode();
|
modelObjectNode.put(ModelDataJsonConstants.MODEL_NAME, processDefinition.getName());
|
modelObjectNode.put(ModelDataJsonConstants.MODEL_REVISION, 1);
|
modelObjectNode.put(ModelDataJsonConstants.MODEL_DESCRIPTION, processDefinition.getDescription());
|
modelData.setMetaInfo(modelObjectNode.toString());
|
|
service.saveModel(modelData);
|
service.addModelEditorSource(modelData.getId(), modelNode.toString().getBytes("utf-8"));
|
}
|
|
private void readProcessResource() {
|
String resoucreType = request.getParameter("resoucreType");
|
String processDefinitionId = request.getParameter("processDefinitionId");
|
String resourceName = "";
|
ProcessDefinition processDefinition = service.createProcessDefinitionQuery().processDefinitionId(processDefinitionId).singleResult();
|
if ("xml".equalsIgnoreCase(resoucreType)) {
|
}
|
else if ("image".equalsIgnoreCase(resoucreType)) {
|
resourceName = processDefinition.getDiagramResourceName();
|
}
|
|
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");
|
}
|
}
|
|
}
|
|
private void getProcessList() {
|
List<Object[]> processList = new ArrayList<Object[]>();
|
ModelQuery modelQuery = service.createModelQuery().orderByLastUpdateTime().desc();
|
List<Model> list = modelQuery.list();
|
for (Model model: list) {
|
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();
|
}
|
processList.add(new Object[]{model, deployment,prodef});
|
}
|
|
resultPool.addValue("processList", processList, new ModelWriter());
|
}
|
|
private void getModel() {
|
ObjectNode modelNode = null;
|
|
String modelId = paths[3];
|
Model model = service.getModel(modelId);
|
|
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) {
|
logger.error("Error creating model JSON", e);
|
throw new ActivitiException("Error creating model JSON", e);
|
}
|
}
|
}
|
|
private void saveModel() {
|
HashMap<String,String> hashMap = new HashMap<String, String>();
|
String modelId = paths[3];
|
StringBuilder builder = new StringBuilder();
|
|
try {
|
request.setCharacterEncoding("utf-8");
|
BufferedReader in = new BufferedReader(new InputStreamReader(request.getInputStream(),"UTF-8"));
|
String line;
|
while ((line = in.readLine()) != null) {
|
builder.append(line);
|
}
|
String decode = URLDecoder.decode(builder.toString(),"utf-8");
|
String[] split = decode.split("&");
|
for (String item : split) {
|
String[] split2 = item.split("=");
|
String key = split2[0];
|
int length = key.length();
|
|
String value = item.substring((length+1));
|
hashMap.put(key, value);
|
}
|
|
Model model = service.getModel(modelId);
|
ObjectNode modelJson = (ObjectNode) objectMapper.readTree(model.getMetaInfo());
|
modelJson.put(MODEL_NAME, hashMap.get("name"));
|
modelJson.put(MODEL_DESCRIPTION, hashMap.get("description"));
|
model.setMetaInfo(modelJson.toString());
|
model.setName(hashMap.get("name"));
|
|
service.saveModel(model);
|
service.addModelEditorSource(model.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();
|
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
|
TranscoderOutput output = new TranscoderOutput(outStream);
|
transcoder.transcode(input, output);
|
final byte[] result = outStream.toByteArray();
|
service.addModelEditorSourceExtra(model.getId(), result);
|
|
String path = Configer.getParam("ModelPicPathRoot");
|
File dir = new File(path);
|
if (!dir.exists()) {
|
dir.mkdirs();
|
}
|
// save model xml to server
|
BpmnJsonConverter jsonConverter = new BpmnJsonConverter();
|
JsonNode editorNode = new ObjectMapper().readTree(service.getModelEditorSource(modelId));
|
BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(editorNode);
|
BpmnXMLConverter xmlConverter = new BpmnXMLConverter();
|
byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);
|
File file = new File(path,modelId+".bpmn20.xml");
|
FileOutputStream fileOutputStream2 = new FileOutputStream(file);
|
fileOutputStream2.write(bpmnBytes);
|
|
// save model png to server
|
FileOutputStream fileOutputStream = new FileOutputStream(new File(path,modelId+".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);
|
fileOutputStream2.close();
|
fileOutputStream.close();
|
outStream.close();
|
|
} catch (Exception e) {
|
logger.error("Error saving model", e);
|
throw new ActivitiException("Error saving model", e);
|
}
|
}
|
|
private void getEditor() throws IOException {
|
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();
|
}
|
}
|
}
|
}
|
}
|
