集成了微信公众号、工作流(activiti)可视化界面的OA开发框架，SSM的代码详情-代码-最代码

首页>代码>集成了微信公众号、工作流(activiti)可视化界面的OA开发框架，SSM>/javaaciviti/src/com/fh/controller/activiti/AcBaseController.java
001package com.fh.controller.activiti;
002 
003import java.io.BufferedReader;
004import java.io.ByteArrayInputStream;
005import java.io.File;
006import java.io.FileInputStream;
007import java.io.FileNotFoundException;
008import java.io.IOException;
009import java.io.InputStream;
010import java.io.InputStreamReader;
011import java.io.UnsupportedEncodingException;
012import java.util.HashMap;
013import java.util.List;
014import java.util.Map;
015import java.util.zip.ZipInputStream;
016 
017import javax.servlet.http.HttpServletResponse;
018import javax.xml.stream.XMLInputFactory;
019import javax.xml.stream.XMLStreamException;
020import javax.xml.stream.XMLStreamReader;
021 
022import org.activiti.bpmn.converter.BpmnXMLConverter;
023import org.activiti.bpmn.model.BpmnModel;
024import org.activiti.editor.constants.ModelDataJsonConstants;
025import org.activiti.editor.language.json.converter.BpmnJsonConverter;
026import org.activiti.engine.HistoryService;
027import org.activiti.engine.ProcessEngine;
028import org.activiti.engine.RepositoryService;
029import org.activiti.engine.RuntimeService;
030import org.activiti.engine.repository.Deployment;
031import org.activiti.engine.repository.DeploymentBuilder;
032import org.activiti.engine.repository.Model;
033import org.activiti.engine.repository.ProcessDefinition;
034import org.apache.commons.io.IOUtils;
035import org.springframework.beans.factory.annotation.Autowired;
036 
037import com.fasterxml.jackson.core.JsonProcessingException;
038import com.fasterxml.jackson.databind.ObjectMapper;
039import com.fasterxml.jackson.databind.node.ObjectNode;
040import com.fh.controller.base.BaseController;
041import com.fh.util.Const;
042import com.fh.util.DelAllFile;
043import com.fh.util.FileUpload;
044import com.fh.util.PathUtil;
045 
046 
047/** 
048 * 类名称：流程管家总类
049 * 创建人：jocker
050 * 更新时间：2018年1月31日
051 * @version
052 */
053public class AcBaseController extends BaseController{
054     
055    @Autowired
056    private ProcessEngine processEngine;         //流程引擎对象
057     
058    @Autowired
059    private RepositoryService repositoryService; //管理流程定义  与流程定义和部署对象相关的Service
060     
061    @Autowired
062    private RuntimeService runtimeService;      //与正在执行的流程实例和执行对象相关的Service(执行管理，包括启动、推进、删除流程实例等操作)
063     
064    @Autowired
065    private HistoryService historyService;      //历史管理(执行完的数据的管理)
066     
067    /**添加流程模型并返回modelId
068     * @param process_id        //流程唯一标识key
069     * @param process_author    //流程作者
070     * @param name              //流程名称
071     * @param modelname         //模型名称
072     * @param description       //模型描述
073     * @param category          //模型分类
074     * @return
075     * @throws UnsupportedEncodingException
076     */
077    protected String createModel(String process_id,String process_author,String name,String modelname,String description,String category) throws UnsupportedEncodingException{
078         
079        ObjectMapper objectMapper = new ObjectMapper();
080        ObjectNode editorNode = objectMapper.createObjectNode();
081        editorNode.put("id", "canvs");
082        editorNode.put("resourceId", "canvs");
083        ObjectNode stencilSetNode = objectMapper.createObjectNode();
084        stencilSetNode.put("namespace", "http://b3mn.org/stencilset/bpmn2.0#");     //命名空间(禁止修改)
085        stencilSetNode.put("author", "");                                           //流程节点作者
086        editorNode.set("stencilset", stencilSetNode);
087        ObjectNode propertiesNode = objectMapper.createObjectNode();
088        propertiesNode.put("process_id",process_id);                                //流程唯一标识
089        propertiesNode.put("process_author",process_author);                        //流程作者
090        propertiesNode.put("name",name);                                            //流程名称
091        editorNode.set("properties", propertiesNode);
092         
093        ObjectNode modelObjectNode = objectMapper.createObjectNode();
094        modelObjectNode.put("name", modelname);                 //模型名称
095        modelObjectNode.put("revision", 1);                     //模型版本
096        modelObjectNode.put("description", description);        //模型描述
097        Model modelData = repositoryService.newModel();
098        modelData.setCategory(category);                        //模型分类
099        modelData.setDeploymentId(null);
100        modelData.setKey(null);
101        modelData.setMetaInfo(modelObjectNode.toString());
102        modelData.setName(modelname);                           //模型名称
103        modelData.setTenantId("");
104        modelData.setVersion(1);
105         
106        repositoryService.saveModel(modelData);                 //保存模型,存储数据到表：act_re_model 流程设计模型部署表
107        repositoryService.addModelEditorSource(modelData.getId(), editorNode.toString().getBytes("utf-8"));//保存资源,存储数据到表：act_ge_bytearray 二进制数据表
108         
109        return modelData.getId();
110    }
111     
112    /**从流程定义映射模型
113     * @param processDefinitionId //流程定义ID
114     * @return
115     * @throws UnsupportedEncodingException
116     * @throws XMLStreamException
117     */
118    protected Model saveModelFromPro(String processDefinitionId) throws Exception {
119         
120        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefinitionId).singleResult();
121        InputStream bpmnStream = repositoryService.getResourceAsStream(processDefinition.getDeploymentId(),
122        processDefinition.getResourceName());
123        XMLInputFactory xif = XMLInputFactory.newInstance();
124        InputStreamReader in = new InputStreamReader(bpmnStream, "UTF-8");
125        XMLStreamReader xtr = xif.createXMLStreamReader(in);
126        BpmnModel bpmnModel = new BpmnXMLConverter().convertToBpmnModel(xtr);
127     
128        BpmnJsonConverter converter = new BpmnJsonConverter();
129        ObjectNode modelNode = converter.convertToJson(bpmnModel);
130        Model modelData = repositoryService.newModel();
131        modelData.setKey(processDefinition.getKey());                   //唯一标识
132        modelData.setName(processDefinition.getName()+"(反射)");          //名称
133        modelData.setCategory("00102");                                 //分类，默认行政审批分类
134        modelData.setDeploymentId(processDefinition.getDeploymentId());
135        modelData.setVersion(Integer.parseInt(String.valueOf(repositoryService.createModelQuery().modelKey(modelData.getKey()).count()+1))); //版本
136     
137        ObjectNode modelObjectNode = new ObjectMapper().createObjectNode();
138        modelObjectNode.put(ModelDataJsonConstants.MODEL_NAME, processDefinition.getName());
139        modelObjectNode.put(ModelDataJsonConstants.MODEL_REVISION, modelData.getVersion());
140        modelObjectNode.put(ModelDataJsonConstants.MODEL_DESCRIPTION, processDefinition.getDescription());
141        modelData.setMetaInfo(modelObjectNode.toString());
142     
143        repositoryService.saveModel(modelData); //保存模型
144        repositoryService.addModelEditorSource(modelData.getId(), modelNode.toString().getBytes("utf-8"));//保存资源
145     
146        return modelData;
147    }
148     
149    /**通过模型ID获取流程基本信息
150     * @param modelId   //流程ID
151     * @throws JsonProcessingException
152     * @throws UnsupportedEncodingException
153     * @throws IOException
154     * @return
155     */
156    protected Map<String,String> getProcessProperties(String modelId) throws Exception{
157        ObjectMapper objectMapper = new ObjectMapper();
158        ObjectNode editorJsonNode = (ObjectNode)objectMapper.readTree(new String(repositoryService.getModelEditorSource(modelId), "utf-8")).get("properties");
159        Map<String,String> map = new HashMap<String,String>();
160        map.put("process_id",editorJsonNode.get("process_id").toString());                  //流程唯一标识(KEY)
161        map.put("process_author",editorJsonNode.get("process_author").toString());          //流程作者
162        map.put("name",editorJsonNode.get("name").toString());                              //流程名称
163        return map;
164    }
165     
166    /**删除模型
167     * @param modelId //模型ID
168     */
169    protected void deleteModel(String modelId){
170        repositoryService.deleteModel(modelId); //act_re_model 和  act_ge_bytearray 两张表中相关数据都删除
171    }
172     
173    /**根据模型ID导出xml文件
174     * @param response
175     * @param modelId   //模型ID
176     * @throws Exception
177     */
178    protected void exportXmlFromModelId(HttpServletResponse response, String modelId) throws Exception{
179        Model modelData = repositoryService.getModel(modelId);  
180        BpmnJsonConverter jsonConverter = new BpmnJsonConverter();  
181        ObjectNode modelNode = (ObjectNode) new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
182        BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(modelNode);  
183        BpmnXMLConverter xmlConverter = new BpmnXMLConverter();  
184        byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);  
185        ByteArrayInputStream in = new ByteArrayInputStream(bpmnBytes);  
186        IOUtils.copy(in, response.getOutputStream());  
187        String filename = bpmnModel.getMainProcess().getId() + ".bpmn20.xml";  
188        response.setHeader("Content-Disposition", "attachment; filename=" + filename);  
189        response.flushBuffer(); 
190        in.close();
191    }
192     
193    /**根据模型ID预览xml文件
194     * @param response
195     * @param modelId   //模型ID
196     * @throws Exception
197     */
198    protected String viewXmlFromModelId(String modelId) throws Exception{
199        Model modelData = repositoryService.getModel(modelId);  
200        BpmnJsonConverter jsonConverter = new BpmnJsonConverter();  
201        ObjectNode modelNode = (ObjectNode) new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
202        BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(modelNode);  
203        BpmnXMLConverter xmlConverter = new BpmnXMLConverter();  
204        byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);  
205        ByteArrayInputStream in = new ByteArrayInputStream(bpmnBytes);  
206        InputStreamReader isr = new InputStreamReader(in,"utf-8");
207        BufferedReader bufferedReader = new BufferedReader(isr);
208        StringBuffer xmlContent = new StringBuffer(); 
209        String lineTxt = null;
210        while ((lineTxt = bufferedReader.readLine()) != null) {
211            xmlContent.append(lineTxt);
212            xmlContent.append("\n");
213        }
214        isr.close();
215        return xmlContent.toString();
216    }
217     
218    /**判断能否正常根据模型ID导出xml文件(当没有画流程图的时候会报异常)
219     * @param response
220     * @param modelId   //模型ID
221     * @throws Exception
222     */
223    protected void isCanexportXmlFromModelId(HttpServletResponse response, String modelId) throws Exception{
224        Model modelData = repositoryService.getModel(modelId);  
225        BpmnJsonConverter jsonConverter = new BpmnJsonConverter();  
226        ObjectNode modelNode = (ObjectNode) new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
227        BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(modelNode);  
228        BpmnXMLConverter xmlConverter = new BpmnXMLConverter();  
229        xmlConverter.convertToXML(bpmnModel);  
230    }
231     
232    /**部署流程定义(根据modelId部署)
233     * @param modelId   //模型ID
234     * @return 部署ID
235     */
236    protected String deploymentProcessDefinitionFromModelId(String modelId) throws Exception{
237        Model modelData = repositoryService.getModel(modelId);
238        ObjectNode modelNode = (ObjectNode) new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
239        byte[] bpmnBytes = null;
240        BpmnJsonConverter BpmnJsonConverter = new BpmnJsonConverter();
241        BpmnModel model = BpmnJsonConverter.convertToBpmnModel(modelNode);
242        bpmnBytes = new BpmnXMLConverter().convertToXML(model);
243        String processName = modelData.getName() + ".bpmn20.xml";
244        DeploymentBuilder deploymentBuilder = repositoryService.createDeployment().name(modelData.getName());       //部署名称
245        Deployment deployment = deploymentBuilder.addString(processName, new String(bpmnBytes,"utf-8")).deploy();   //完成部署
246        return deployment.getId();  //部署ID
247    }
248     
249    /**部署流程定义(从Classpath)
250     * @param name      //部署名称
251     * @param xmlpath   //xml文件路径
252     * @param pngpath   //png文件路径
253     * @return 部署ID
254     */
255    protected String deploymentProcessDefinitionFromClasspath(String name, String xmlpath, String pngpath){
256        DeploymentBuilder deploymentBuilder = repositoryService.createDeployment();     //创建部署对象
257        deploymentBuilder.name(name);                       //部署名称
258        deploymentBuilder.addClasspathResource(xmlpath);    //从文件中读取xml资源
259        deploymentBuilder.addClasspathResource(pngpath);    //从文件中读取png资源
260        Deployment deployment = deploymentBuilder.deploy(); //完成部署
261        return deployment.getId();                          //部署ID
262    }
263     
264    /**部署流程定义(从zip压缩包)
265     * @param name      //部署名称
266     * @param zippath   //zip文件路径
267     * @return 部署ID
268     * @throws FileNotFoundException 
269     */
270    protected String deploymentProcessDefinitionFromZip(String name, String zippath) throws Exception{
271        File outfile = new File(zippath);
272        FileInputStream inputStream = new FileInputStream(outfile);
273        ZipInputStream ipInputStream = new ZipInputStream(inputStream);
274        DeploymentBuilder deploymentBuilder = repositoryService.createDeployment();     //创建部署对象
275        deploymentBuilder.name(name);                       //部署名称
276        deploymentBuilder.addZipInputStream(ipInputStream);
277        Deployment deployment = deploymentBuilder.deploy(); //完成部署
278        ipInputStream.close();
279        inputStream.close();
280        return deployment.getId();                          //部署ID
281    }
282     
283    /**根据流程定义的部署ID生成XML和PNG
284     * @param DEPLOYMENT_ID_ //部署ID
285     * @throws IOException 
286     */
287    protected void createXmlAndPng(String DEPLOYMENT_ID_) throws IOException{
288        DelAllFile.delFolder(PathUtil.getClasspath()+"uploadFiles/activitiFile");           //生成先清空之前生成的文件
289        List<String> names = repositoryService.getDeploymentResourceNames(DEPLOYMENT_ID_);
290        for (String name : names) {
291            if(name.indexOf("zip")!=-1)continue;
292            InputStream in = repositoryService.getResourceAsStream(DEPLOYMENT_ID_, name);  
293            FileUpload.copyFile(in,PathUtil.getClasspath()+Const.FILEACTIVITI,name);        //把文件上传到文件目录里面
294            in.close();  
295        }  
296    }
297     
298    /**删除部署的流程
299     * @param DEPLOYMENT_ID_ //部署ID
300     * @throws IOException 
301     */
302    protected void deleteDeployment(String DEPLOYMENT_ID_) throws Exception{
303        //repositoryService.deleteDeployment(DEPLOYMENT_ID_);       //不带级联的删除，此删除只能删除没有启动的流程，否则抛出异常 .act_re_deployment，act_re_procdef 和  act_ge_bytearray 三张表中相关数据都删除
304        repositoryService.deleteDeployment(DEPLOYMENT_ID_, true);   //级联删除，不管流程是否启动，都可以删除
305    }
306     
307    /**激活流程定义
308     * @param DEPLOYMENT_ID_ //流程定义ID
309     * @throws IOException
310     */
311    protected void activateProcessDefinitionById(String DEPLOYMENT_ID_) throws IOException{
312        repositoryService.activateProcessDefinitionById(DEPLOYMENT_ID_, true, null);
313    }
314     
315    /**挂起流程定义
316     * @param DEPLOYMENT_ID_ //流程定义ID
317     * @throws IOException
318     */
319    protected void suspendProcessDefinitionById(String DEPLOYMENT_ID_) throws IOException{
320        repositoryService.suspendProcessDefinitionById(DEPLOYMENT_ID_, true, null);
321    }
322 
323}