package process.service;
|
|
import java.io.BufferedReader;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.InputStreamReader;
|
import java.net.URLDecoder;
|
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.http.HttpServletRequest;
|
import javax.xml.stream.XMLInputFactory;
|
import javax.xml.stream.XMLStreamReader;
|
|
|
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.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.commons.io.FilenameUtils;
|
import org.apache.commons.io.IOUtils;
|
import org.apache.commons.lang3.StringUtils;
|
|
import process.WorkflowUtils;
|
import process.service.writer.ModelWriter;
|
|
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 = "REVISON";
|
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 ("getProcessList".equalsIgnoreCase(operator)) {
|
getProcessList();
|
}
|
else if ("readProcessSource".equals(operator)) {
|
readProcessResource();
|
}
|
else if ("uploadProcess".equalsIgnoreCase(operator)) {
|
uploadProcess();
|
}
|
}
|
|
private void deleteModel() {
|
String modelId = request.getParameter("modelId");
|
try {
|
service.deleteModel(modelId);
|
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() {
|
File file = new File(Configer.getPath_Application()+"/diagram/leave.bpmn");
|
try {
|
FileInputStream fileInputStream = new FileInputStream(file);
|
Deployment deployment = null;
|
|
String extension = FilenameUtils.getExtension(file.getName());
|
if (extension.equals("zip") || extension.equals("bar")) {
|
ZipInputStream zip = new ZipInputStream(fileInputStream);
|
deployment = service.createDeployment().addZipInputStream(zip).deploy();
|
} else {
|
deployment = service.createDeployment().addInputStream(file.getName(), fileInputStream).deploy();
|
}
|
|
List<ProcessDefinition> list = service.createProcessDefinitionQuery().deploymentId(deployment.getId()).list();
|
|
for (ProcessDefinition processDefinition : list) {
|
|
WorkflowUtils.exportDiagramToFile(service, processDefinition, Configer.getPath_Application()+"/export");
|
|
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;
|
|
if (deploymentId != null) {
|
deployment = service.createDeploymentQuery().deploymentId(deploymentId).singleResult();
|
}
|
|
processList.add(new Object[]{model, deployment});
|
}
|
|
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() throws IOException {
|
request.setCharacterEncoding("utf-8");
|
HashMap<String,String> hashMap = new HashMap();
|
String modelId = paths[3];
|
StringBuilder builder = new StringBuilder();
|
BufferedReader in = new BufferedReader(new InputStreamReader(request.getInputStream(),"UTF-8"));
|
String line;
|
while ((line = in.readLine()) != null) {
|
builder.append(line);
|
}
|
String paramString = builder.toString();
|
String decode = URLDecoder.decode(paramString,"utf-8");
|
String[] split = decode.split("&");
|
for (String string : split) {
|
String[] split2 = string.split("=");
|
String key = split2[0];
|
String value = split2[1];
|
hashMap.put(key, value);
|
}
|
|
Set<String> keySet2 = hashMap.keySet();
|
for (String key : keySet2) {
|
String value = hashMap.get(key);
|
}
|
Model model = service.getModel(modelId);
|
|
Map<String, String[]> parameterMap = request.getParameterMap();
|
Set<String> keySet = parameterMap.keySet();
|
for (String string : keySet) {
|
|
}
|
}
|
|
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);
|
}
|
|
}
|
