activiti+app+mysql_Activiti工作流应用

config

package com.bootdo.activiti.config;

import org.activiti.engine.*;

import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;

import org.activiti.spring.ProcessEngineFactoryBean;

import org.activiti.spring.SpringProcessEngineConfiguration;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

@Configuration

public class ActivitiConfig {

//流程配置，与spring整合采用SpringProcessEngineConfiguration这个实现

@Bean

public ProcessEngineConfiguration processEngineConfiguration(DataSource dataSource, PlatformTransactionManager transactionManager){

SpringProcessEngineConfiguration processEngineConfiguration = new SpringProcessEngineConfiguration();

processEngineConfiguration.setDataSource(dataSource);

processEngineConfiguration.setDatabaseSchemaUpdate("true");

processEngineConfiguration.setDatabaseType("mysql");

processEngineConfiguration.setTransactionManager(transactionManager);

//流程图字体

processEngineConfiguration.setActivityFontName("宋体");

processEngineConfiguration.setAnnotationFontName("宋体");

processEngineConfiguration.setLabelFontName("宋体");

return processEngineConfiguration;

}

//流程引擎，与spring整合使用factoryBean

@Bean

public ProcessEngineFactoryBean processEngine(ProcessEngineConfiguration processEngineConfiguration){

ProcessEngineFactoryBean processEngineFactoryBean = new ProcessEngineFactoryBean();

processEngineFactoryBean.setProcessEngineConfiguration((ProcessEngineConfigurationImpl) processEngineConfiguration);

return processEngineFactoryBean;

}

//八大接口

@Bean

public RepositoryService repositoryService(ProcessEngine processEngine){

return processEngine.getRepositoryService();

}

@Bean

public RuntimeService runtimeService(ProcessEngine processEngine){

return processEngine.getRuntimeService();

}

@Bean

public TaskService taskService(ProcessEngine processEngine){

return processEngine.getTaskService();

}

@Bean

public HistoryService historyService(ProcessEngine processEngine){

return processEngine.getHistoryService();

}

@Bean

public FormService formService(ProcessEngine processEngine){

return processEngine.getFormService();

}

@Bean

public IdentityService identityService(ProcessEngine processEngine){

return processEngine.getIdentityService();

}

@Bean

public ManagementService managementService(ProcessEngine processEngine){

return processEngine.getManagementService();

}

@Bean

public DynamicBpmnService dynamicBpmnService(ProcessEngine processEngine){

return processEngine.getDynamicBpmnService();

}

//八大接口 end

}

package com.bootdo.activiti.config;

/**

*/

public class ActivitiConstant {

public static final String[] ACTIVITI_SALARY = new String[]{"salary","salary"};

}

controller

package com.bootdo.activiti.controller;

import com.bootdo.common.config.Constant;

import com.bootdo.common.controller.BaseController;

import com.bootdo.common.utils.PageUtils;

import com.bootdo.common.utils.R;

import com.fasterxml.jackson.databind.JsonNode;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.databind.node.ObjectNode;

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.RepositoryService;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.repository.Model;

import org.activiti.rest.editor.model.ModelEditorJsonRestResource;

import org.apache.batik.transcoder.TranscoderInput;

import org.apache.batik.transcoder.TranscoderOutput;

import org.apache.batik.transcoder.image.PNGTranscoder;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.web.bind.annotation.*;

import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletResponse;

import java.io.*;

import java.util.List;

import static org.activiti.editor.constants.ModelDataJsonConstants.*;

/**

* @author bootdo 1992lcg@163.com

*/

@RequestMapping("/activiti")

@RestController

public class ModelController extends BaseController{

protected static final Logger LOGGER = LoggerFactory.getLogger(ModelEditorJsonRestResource.class);

@Autowired

private RepositoryService repositoryService;

@Autowired

private ObjectMapper objectMapper;

@GetMapping("/model")

ModelAndView model() {

return new ModelAndView("act/model/model");

}

@GetMapping("/model/list")

PageUtils list(int offset, int limit) {

List list = repositoryService.createModelQuery().listPage(offset

, limit);

int total = (int) repositoryService.createModelQuery().count();

PageUtils pageUtil = new PageUtils(list, total);

return pageUtil;

}

@RequestMapping("/model/add")

public void newModel(HttpServletResponse response) throws UnsupportedEncodingException {

//初始化一个空模型

Model model = repositoryService.newModel();

//设置一些默认信息

String name = "new-process";

String description = "";

int revision = 1;

String key = "process";

ObjectNode modelNode = objectMapper.createObjectNode();

modelNode.put(ModelDataJsonConstants.MODEL_NAME, name);

modelNode.put(ModelDataJsonConstants.MODEL_DESCRIPTION, description);

modelNode.put(ModelDataJsonConstants.MODEL_REVISION, revision);

model.setName(name);

model.setKey(key);

model.setMetaInfo(modelNode.toString());

repositoryService.saveModel(model);

String id = model.getId();

//完善ModelEditorSource

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.put("stencilset", stencilSetNode);

repositoryService.addModelEditorSource(id, editorNode.toString().getBytes("utf-8"));

try {

response.sendRedirect("/modeler.html?modelId=" + id);

} catch (IOException e) {

e.printStackTrace();

}

}

@GetMapping(value = "/model/{modelId}/json")

public ObjectNode getEditorJson(@PathVariable String modelId) {

ObjectNode modelNode = null;

Model model = repositoryService.getModel(modelId);

if (model != null) {

try {

if (StringUtils.isNotEmpty(model.getMetaInfo())) {

modelNode = (ObjectNode) objectMapper.readTree(model.getMetaInfo());

} else {

modelNode = objectMapper.createObjectNode();

modelNode.put(MODEL_NAME, model.getName());

}

modelNode.put(MODEL_ID, model.getId());

ObjectNode editorJsonNode = (ObjectNode) objectMapper.readTree(

new String(repositoryService.getModelEditorSource(model.getId()), "utf-8"));

modelNode.put("model", editorJsonNode);

} catch (Exception e) {

LOGGER.error("Error creating model JSON", e);

throw new ActivitiException("Error creating model JSON", e);

}

}

return modelNode;

}

@RequestMapping(value = "/editor/stencilset", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

public String getStencilset() {

InputStream stencilsetStream = this.getClass().getClassLoader().getResourceAsStream("stencilset.json");

try {

return IOUtils.toString(stencilsetStream, "utf-8");

} catch (Exception e) {

throw new ActivitiException("Error while loading stencil set", e);

}

}

@GetMapping("/model/edit/{id}")

public void edit(HttpServletResponse response, @PathVariable("id") String id) {

try {

response.sendRedirect("/modeler.html?modelId=" + id);

} catch (IOException e) {

e.printStackTrace();

}

}

@DeleteMapping("/model/{id}")

public R remove(@PathVariable("id") String id) {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

repositoryService.deleteModel(id);

return R.ok();

}

@PostMapping("/model/deploy/{id}")

public R deploy(@PathVariable("id") String id) throws Exception {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

//获取模型

Model modelData = repositoryService.getModel(id);

byte[] bytes = repositoryService.getModelEditorSource(modelData.getId());

if (bytes == null) {

return R.error("模型数据为空，请先设计流程并成功保存，再进行发布。");

}

JsonNode modelNode = new ObjectMapper().readTree(bytes);

BpmnModel model = new BpmnJsonConverter().convertToBpmnModel(modelNode);

if (model.getProcesses().size() == 0) {

return R.error("数据模型不符要求，请至少设计一条主线流程。");

}

byte[] bpmnBytes = new BpmnXMLConverter().convertToXML(model);

//发布流程

String processName = modelData.getName() + ".bpmn20.xml";

Deployment deployment = repositoryService.createDeployment()

.name(modelData.getName())

.addString(processName, new String(bpmnBytes, "UTF-8"))

.deploy();

modelData.setDeploymentId(deployment.getId());

repositoryService.saveModel(modelData);

return R.ok();

}

@PostMapping("/model/batchRemove")

public R batchRemove(@RequestParam("ids[]") String[] ids) {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

for (String id : ids) {

repositoryService.deleteModel(id);

}

return R.ok();

}

@RequestMapping(value = "/model/{modelId}/save", method = RequestMethod.PUT)

@ResponseStatus(value = HttpStatus.OK)

public void saveModel(@PathVariable String modelId

, String name, String description

, String json_xml, String svg_xml) {

try {

Model model = repositoryService.getModel(modelId);

ObjectNode modelJson = (ObjectNode) objectMapper.readTree(model.getMetaInfo());

modelJson.put(MODEL_NAME, name);

modelJson.put(MODEL_DESCRIPTION, description);

model.setMetaInfo(modelJson.toString());

model.setName(name);

repositoryService.saveModel(model);

repositoryService.addModelEditorSource(model.getId(), json_xml.getBytes("utf-8"));

InputStream svgStream = new ByteArrayInputStream(svg_xml.getBytes("utf-8"));

TranscoderInput input = new TranscoderInput(svgStream);

PNGTranscoder transcoder = new PNGTranscoder();

// Setup output

ByteArrayOutputStream outStream = new ByteArrayOutputStream();

TranscoderOutput output = new TranscoderOutput(outStream);

// Do the transformation

transcoder.transcode(input, output);

final byte[] result = outStream.toByteArray();

repositoryService.addModelEditorSourceExtra(model.getId(), result);

outStream.close();

} catch (Exception e) {

LOGGER.error("Error saving model", e);

throw new ActivitiException("Error saving model", e);

}

}

@GetMapping("/model/export/{id}")

public void exportToXml(@PathVariable("id") String id, HttpServletResponse response) {

try {

org.activiti.engine.repository.Model modelData = repositoryService.getModel(id);

BpmnJsonConverter jsonConverter = new BpmnJsonConverter();

JsonNode editorNode = new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.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();

} catch (Exception e) {

throw new ActivitiException("导出model的xml文件失败，模型ID=" + id, e);

}

}

}

package com.bootdo.activiti.controller;

import com.bootdo.activiti.service.ProcessService;

import com.bootdo.activiti.vo.ProcessVO;

import com.bootdo.common.config.Constant;

import com.bootdo.common.controller.BaseController;

import com.bootdo.common.utils.PageUtils;

import com.bootdo.common.utils.R;

import org.activiti.engine.ActivitiException;

import org.activiti.engine.RepositoryService;

import org.activiti.engine.RuntimeService;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.repository.ProcessDefinition;

import org.apache.commons.io.FilenameUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.web.bind.annotation.*;

import org.springframework.web.multipart.MultipartFile;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import javax.servlet.http.HttpServletResponse;

import javax.xml.stream.XMLStreamException;

import java.io.InputStream;

import java.io.UnsupportedEncodingException;

import java.util.ArrayList;

import java.util.List;

import java.util.zip.ZipInputStream;

@RequestMapping("activiti/process")

@RestController

public class ProcessController extends BaseController{

@Autowired

private RepositoryService repositoryService;

@Autowired

private ProcessService processService;

@Autowired

private RuntimeService runtimeService;

@GetMapping

ModelAndView process() {

return new ModelAndView("act/process/process");

}

@GetMapping("list")

PageUtils list(int offset, int limit) {

List processDefinitions = repositoryService.createProcessDefinitionQuery()

.listPage(offset, limit);

int count = (int) repositoryService.createProcessDefinitionQuery().count();

List list = new ArrayList<>();

for(ProcessDefinition processDefinition: processDefinitions){

list.add(new ProcessVO(processDefinition));

}

PageUtils pageUtils = new PageUtils(list, count);

return pageUtils;

}

@GetMapping("/add")

public ModelAndView add() {

return new ModelAndView("act/process/add");

}

@PostMapping("/save")

@Transactional(readOnly = false)

public R deploy(String exportDir, String category, MultipartFile file) {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

String message = "";

String fileName = file.getOriginalFilename();

try {

InputStream fileInputStream = file.getInputStream();

Deployment deployment = null;

String extension = FilenameUtils.getExtension(fileName);

if (extension.equals("zip") || extension.equals("bar")) {

ZipInputStream zip = new ZipInputStream(fileInputStream);

deployment = repositoryService.createDeployment().addZipInputStream(zip).deploy();

} else if (extension.equals("png")) {

deployment = repositoryService.createDeployment().addInputStream(fileName, fileInputStream).deploy();

} else if (fileName.indexOf("bpmn20.xml") != -1) {

deployment = repositoryService.createDeployment().addInputStream(fileName, fileInputStream).deploy();

} else if (extension.equals("bpmn")) { // bpmn扩展名特殊处理，转换为bpmn20.xml

String baseName = FilenameUtils.getBaseName(fileName);

deployment = repositoryService.createDeployment().addInputStream(baseName + ".bpmn20.xml", fileInputStream).deploy();

} else {

message = "不支持的文件类型：" + extension;

}

List list = repositoryService.createProcessDefinitionQuery().deploymentId(deployment.getId()).list();

// 设置流程分类

for (ProcessDefinition processDefinition : list) {

//ActUtils.exportDiagramToFile(repositoryService, processDefinition, exportDir);

repositoryService.setProcessDefinitionCategory(processDefinition.getId(), category);

message += "部署成功，流程ID=" + processDefinition.getId() + "
";

}

if (list.size() == 0) {

message = "部署失败，没有流程。";

}

} catch (Exception e) {

throw new ActivitiException("部署失败！", e);

}

return R.ok(message);

}

/**

* 将部署的流程转换为模型

*

* @param procDefId

* @param redirectAttributes

* @return

* @throws UnsupportedEncodingException

* @throws XMLStreamException

*/

@RequestMapping(value = "/convertToModel/{procDefId}")

public R convertToModel(@PathVariable("procDefId") String procDefId, RedirectAttributes redirectAttributes) throws UnsupportedEncodingException, XMLStreamException {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

org.activiti.engine.repository.Model modelData = null;

try {

modelData = processService.convertToModel(procDefId);

return R.ok( "转换模型成功，模型ID=" + modelData.getId());

} catch (Exception e) {

e.printStackTrace();

return R.ok( "转换模型失败");

}

}

@RequestMapping(value = "/resource/read/{xml}/{id}")

public void resourceRead(@PathVariable("xml") String resType, @PathVariable("id") String id, HttpServletResponse response) throws Exception {

InputStream resourceAsStream = processService.resourceRead(id,resType);

byte[] b = new byte[1024];

int len = -1;

while ((len = resourceAsStream.read(b, 0, 1024)) != -1) {

response.getOutputStream().write(b, 0, len);

}

}

@PostMapping("/remove")

public R remove(String id){

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

repositoryService.deleteDeployment(id,true);

return R.ok();

}

@PostMapping("/batchRemove")

public R batchRemove(@RequestParam("ids[]") String[] ids) {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

for (String id : ids) {

repositoryService.deleteDeployment(id,true);

}

return R.ok();

}

}

package com.bootdo.activiti.controller;

import com.bootdo.activiti.domain.SalaryDO;

import com.bootdo.activiti.service.SalaryService;

import com.bootdo.activiti.utils.ActivitiUtils;

import com.bootdo.common.config.Constant;

import com.bootdo.common.controller.BaseController;

import com.bootdo.common.utils.PageUtils;

import com.bootdo.common.utils.Query;

import com.bootdo.common.utils.R;

import com.bootdo.common.utils.ShiroUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.*;

import java.util.Date;

import java.util.List;

import java.util.Map;

/**

* 审批流程测试表

*

* @author chglee

* @email 1992lcg@163.com

* @date 2017-11-25 13:33:16

*/

@Controller

@RequestMapping("/act/salary")

public class SalaryController extends BaseController{

@Autowired

private SalaryService salaryService;

@Autowired

ActivitiUtils activitiUtils;

@GetMapping()

String Salary() {

return "activiti/salary/salary";

}

@ResponseBody

@GetMapping("/list")

public PageUtils list(@RequestParam Map params) {

Query query = new Query(params);

List salaryList = salaryService.list(query);

int total = salaryService.count(query);

PageUtils pageUtils = new PageUtils(salaryList, total);

return pageUtils;

}

@GetMapping("/form")

String add() {

return "act/salary/add";

}

@GetMapping("/form/{taskId}")

String edit(@PathVariable("taskId") String taskId, Model model) {

SalaryDO salary = salaryService.get(activitiUtils.getBusinessKeyByTaskId(taskId));

salary.setTaskId(taskId);

model.addAttribute("salary", salary);

return "act/salary/edit";

}

/**

* 保存

*/

@ResponseBody

@PostMapping("/save")

public R saveOrUpdate(SalaryDO salary) {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

salary.setCreateDate(new Date());

salary.setUpdateDate(new Date());

salary.setCreateBy(ShiroUtils.getUserId().toString());

salary.setUpdateBy(ShiroUtils.getUserId().toString());

salary.setDelFlag("1");

if (salaryService.save(salary) > 0) {

return R.ok();

}

return R.error();

}

/**

* 修改

*/

@ResponseBody

@RequestMapping("/update")

public R update(SalaryDO salary) {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

String taskKey = activitiUtils.getTaskByTaskId(salary.getTaskId()).getTaskDefinitionKey();

if ("audit2".equals(taskKey)) {

salary.setHrText(salary.getTaskComment());

} else if ("audit3".equals(taskKey)) {

salary.setLeadText(salary.getTaskComment());

} else if ("audit4".equals(taskKey)) {

salary.setMainLeadText(salary.getTaskComment());

} else if("apply_end".equals(salary.getTaskComment())){

//流程完成，兑现

}

salaryService.update(salary);

return R.ok();

}

/**

* 删除

*/

@PostMapping("/remove")

@ResponseBody

public R remove(String id) {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

if (salaryService.remove(id) > 0) {

return R.ok();

}

return R.error();

}

/**

* 删除

*/

@PostMapping("/batchRemove")

@ResponseBody

public R remove(@RequestParam("ids[]") String[] ids) {

if (Constant.DEMO_ACCOUNT.equals(getUsername())) {

return R.error(1, "演示系统不允许修改,完整体验请部署程序");

}

salaryService.batchRemove(ids);

return R.ok();

}

}

package com.bootdo.activiti.controller;

import com.bootdo.activiti.service.ActTaskService;

import com.bootdo.activiti.vo.ProcessVO;

import com.bootdo.activiti.vo.TaskVO;

import com.bootdo.common.utils.PageUtils;

import com.bootdo.common.utils.ShiroUtils;

import org.activiti.engine.FormService;

import org.activiti.engine.RepositoryService;

import org.activiti.engine.TaskService;

import org.activiti.engine.repository.ProcessDefinition;

import org.activiti.engine.task.Task;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.List;

/**

*/

@RequestMapping("activiti/task")

@RestController

public class TaskController {

@Autowired

RepositoryService repositoryService;

@Autowired

FormService formService;

@Autowired

TaskService taskService;

@Autowired

ActTaskService actTaskService;

@GetMapping("goto")

public ModelAndView gotoTask(){

return new ModelAndView("act/task/gotoTask");

}

@GetMapping("/gotoList")

PageUtils list(int offset, int limit) {

List processDefinitions = repositoryService.createProcessDefinitionQuery()

.listPage(offset, limit);

int count = (int) repositoryService.createProcessDefinitionQuery().count();

List list = new ArrayList<>();

for(ProcessDefinition processDefinition: processDefinitions){

list.add(new ProcessVO(processDefinition));

}

PageUtils pageUtils = new PageUtils(list, count);

return pageUtils;

}

@GetMapping("/form/{procDefId}")

public void startForm(@PathVariable("procDefId") String procDefId ,HttpServletResponse response) throws IOException {

String formKey = actTaskService.getFormKey(procDefId, null);

response.sendRedirect(formKey);

}

@GetMapping("/form/{procDefId}/{taskId}")

public void form(@PathVariable("procDefId") String procDefId,@PathVariable("taskId") String taskId ,HttpServletResponse response) throws IOException {

// 获取流程XML上的表单KEY

String formKey = actTaskService.getFormKey(procDefId, taskId);

response.sendRedirect(formKey+"/"+taskId);

}

@GetMapping("/todo")

ModelAndView todo(){

return new ModelAndView("act/task/todoTask");

}

@GetMapping("/todoList")

List todoList(){

String userId = ShiroUtils.getUser().getUsername();

//改为候选人

List tasks = taskService.createTaskQuery().taskCandidateOrAssigned(userId).list();

List taskVOS = new ArrayList<>();

for(Task task : tasks){

TaskVO taskVO = new TaskVO(task);

taskVOS.add(taskVO);

}

return taskVOS;

}

/**

* 读取带跟踪的图片

* @param execId processId

*/

@RequestMapping(value = "/trace/photo/{procDefId}/{execId}")

public void tracePhoto(@PathVariable("procDefId") String procDefId, @PathVariable("execId") String execId, HttpServletResponse response) throws Exception {

InputStream imageStream = actTaskService.tracePhoto(procDefId, execId);

// 输出资源内容到相应对象

byte[] b = new byte[1024];

int len;

while ((len = imageStream.read(b, 0, 1024)) != -1) {

response.getOutputStream().write(b, 0, len);

}

}

}

dao

package com.bootdo.activiti.dao;

import com.bootdo.activiti.domain.SalaryDO;

import org.apache.ibatis.annotations.Mapper;

import java.util.List;

import java.util.Map;

/**

* 审批流程测试表

* @author chglee

* @email 1992lcg@163.com

* @date 2017-11-25 13:28:58

*/

@Mapper

public interface SalaryDao {

SalaryDO get(String id);

List list(Map map);

int count(Map map);

int save(SalaryDO salary);

int update(SalaryDO salary);

int remove(String id);

int batchRemove(String[] ids);

}

domain

package com.bootdo.activiti.domain;

import org.activiti.engine.history.HistoricActivityInstance;

import org.activiti.engine.history.HistoricTaskInstance;

import org.activiti.engine.repository.ProcessDefinition;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

import java.util.Date;

import java.util.List;

/**

*

*/

public class ActivitiDO {

private String taskId; // 任务编号

private String taskName; // 任务名称

private String taskDefKey; // 任务定义Key(任务环节标识)

private String procInsId; // 流程实例ID

private String procDefId; // 流程定义ID

private String procDefKey; // 流程定义Key(流程定义标识)

private String businessTable;// 业务绑定Table

private String businessId;// 业务绑定ID

private String title; // 任务标题

private String status; // 任务状态(todo/claim/finish)

private String procExecUrl; // 流程执行(办理)RUL

private String comment; // 任务意见

private String flag; // 意见状态

private Task task; // 任务对象

private ProcessDefinition procDef; // 流程定义对象

private ProcessInstance procIns;// 流程实例对象

private HistoricTaskInstance histTask; // 历史任务

private HistoricActivityInstance histIns;//历史活动任务

private String assignee; // 任务执行人编号

private String assigneeName; // 任务执行人名称

private Variable vars; // 流程变量

private Variable taskVars; // 流程任务变量

private Date beginDate;// 开始查询日期

private Date endDate;// 结束查询日期

private List list; // 任务列表

public String getTaskId() {

return taskId;

}

public void setTaskId(String taskId) {

this.taskId = taskId;

}

public String getTaskName() {

return taskName;

}

public void setTaskName(String taskName) {

this.taskName = taskName;

}

public String getTaskDefKey() {

return taskDefKey;

}

public void setTaskDefKey(String taskDefKey) {

this.taskDefKey = taskDefKey;

}

public String getProcInsId() {

return procInsId;

}

public void setProcInsId(String procInsId) {

this.procInsId = procInsId;

}

public String getProcDefId() {

return procDefId;

}

public void setProcDefId(String procDefId) {

this.procDefId = procDefId;

}

public String getProcDefKey() {

return procDefKey;

}

public void setProcDefKey(String procDefKey) {

this.procDefKey = procDefKey;

}

public String getBusinessTable() {

return businessTable;

}

public void setBusinessTable(String businessTable) {

this.businessTable = businessTable;

}

public String getBusinessId() {

return businessId;

}

public void setBusinessId(String businessId) {

this.businessId = businessId;

}

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

public String getStatus() {

return status;

}

public void setStatus(String status) {

this.status = status;

}

public String getProcExecUrl() {

return procExecUrl;

}

public void setProcExecUrl(String procExecUrl) {

this.procExecUrl = procExecUrl;

}

public String getComment() {

return comment;

}

public void setComment(String comment) {

this.comment = comment;

}

public String getFlag() {

return flag;

}

public void setFlag(String flag) {

this.flag = flag;

}

public Task getTask() {

return task;

}

public void setTask(Task task) {

this.task = task;

}

public ProcessDefinition getProcDef() {

return procDef;

}

public void setProcDef(ProcessDefinition procDef) {

this.procDef = procDef;

}

public ProcessInstance getProcIns() {

return procIns;

}

public void setProcIns(ProcessInstance procIns) {

this.procIns = procIns;

}

public HistoricTaskInstance getHistTask() {

return histTask;

}

public void setHistTask(HistoricTaskInstance histTask) {

this.histTask = histTask;

}

public HistoricActivityInstance getHistIns() {

return histIns;

}

public void setHistIns(HistoricActivityInstance histIns) {

this.histIns = histIns;

}

public String getAssignee() {

return assignee;

}

public void setAssignee(String assignee) {

this.assignee = assignee;

}

public String getAssigneeName() {

return assigneeName;

}

public void setAssigneeName(String assigneeName) {

this.assigneeName = assigneeName;

}

public Variable getVars() {

return vars;

}

public void setVars(Variable vars) {

this.vars = vars;

}

public Variable getTaskVars() {

return taskVars;

}

public void setTaskVars(Variable taskVars) {

this.taskVars = taskVars;

}

public Date getBeginDate() {

return beginDate;

}

public void setBeginDate(Date beginDate) {

this.beginDate = beginDate;

}

public Date getEndDate() {

return endDate;

}

public void setEndDate(Date endDate) {

this.endDate = endDate;

}

public List getList() {

return list;

}

public void setList(List list) {

this.list = list;

}

}

package com.bootdo.activiti.domain;

import org.springframework.format.annotation.DateTimeFormat;

import java.io.Serializable;

import java.util.Date;

/**

* 审批流程测试表

*

* @author chglee

* @email 1992lcg@163.com

* @date 2017-11-25 13:28:58

*/

public class SalaryDO extends TaskDO implements Serializable {

private static final long serialVersionUID = 1L;

//编号

private String id;

//流程实例ID

private String procInsId;

//变动用户

private String userId;

//归属部门

private String officeId;

//岗位

private String post;

//性别

private String age;

//学历

private String edu;

//调整原因

private String content;

//现行标准 薪酬档级

private String olda;

//现行标准 月工资额

private String oldb;

//现行标准 年薪总额

private String oldc;

//调整后标准 薪酬档级

private String newa;

//调整后标准 月工资额

private String newb;

//调整后标准 年薪总额

private String newc;

//月增资

private String addNum;

//执行时间

private String exeDate;

//人力资源部门意见

private String hrText;

//分管领导意见

private String leadText;

//集团主要领导意见

private String mainLeadText;

//创建者

private String createBy;

//创建时间

@DateTimeFormat(pattern = "yyyy-MM-dd")

private Date createDate;

//更新者

private String updateBy;

//更新时间

@DateTimeFormat(pattern = "yyyy-MM-dd")

private Date updateDate;

//备注信息

private String remarks;

//删除标记

private String delFlag;

/**

* 设置：编号

*/

public void setId(String id) {

this.id = id;

}

/**

* 获取：编号

*/

public String getId() {

return id;

}

/**

* 设置：流程实例ID

*/

public void setProcInsId(String procInsId) {

this.procInsId = procInsId;

}

/**

* 获取：流程实例ID

*/

public String getProcInsId() {

return procInsId;

}

/**

* 设置：变动用户

*/

public void setUserId(String userId) {

this.userId = userId;

}

/**

* 获取：变动用户

*/

public String getUserId() {

return userId;

}

/**

* 设置：归属部门

*/

public void setOfficeId(String officeId) {

this.officeId = officeId;

}

/**

* 获取：归属部门

*/

public String getOfficeId() {

return officeId;

}

/**

* 设置：岗位

*/

public void setPost(String post) {

this.post = post;

}

/**

* 获取：岗位

*/

public String getPost() {

return post;

}

/**

* 设置：性别

*/

public void setAge(String age) {

this.age = age;

}

/**

* 获取：性别

*/

public String getAge() {

return age;

}

/**

* 设置：学历

*/

public void setEdu(String edu) {

this.edu = edu;

}

/**

* 获取：学历

*/

public String getEdu() {

return edu;

}

/**

* 设置：调整原因

*/

public void setContent(String content) {

this.content = content;

}

/**

* 获取：调整原因

*/

public String getContent() {

return content;

}

/**

* 设置：现行标准 薪酬档级

*/

public void setOlda(String olda) {

this.olda = olda;

}

/**

* 获取：现行标准 薪酬档级

*/

public String getOlda() {

return olda;

}

/**

* 设置：现行标准 月工资额

*/

public void setOldb(String oldb) {

this.oldb = oldb;

}

/**

* 获取：现行标准 月工资额

*/

public String getOldb() {

return oldb;

}

/**

* 设置：现行标准 年薪总额

*/

public void setOldc(String oldc) {

this.oldc = oldc;

}

/**

* 获取：现行标准 年薪总额

*/

public String getOldc() {

return oldc;

}

/**

* 设置：调整后标准 薪酬档级

*/

public void setNewa(String newa) {

this.newa = newa;

}

/**

* 获取：调整后标准 薪酬档级

*/

public String getNewa() {

return newa;

}

/**

* 设置：调整后标准 月工资额

*/

public void setNewb(String newb) {

this.newb = newb;

}

/**

* 获取：调整后标准 月工资额

*/

public String getNewb() {

return newb;

}

/**

* 设置：调整后标准 年薪总额

*/

public void setNewc(String newc) {

this.newc = newc;

}

/**

* 获取：调整后标准 年薪总额

*/

public String getNewc() {

return newc;

}

/**

* 设置：月增资

*/

public void setAddNum(String addNum) {

this.addNum = addNum;

}

/**

* 获取：月增资

*/

public String getAddNum() {

return addNum;

}

/**

* 设置：执行时间

*/

public void setExeDate(String exeDate) {

this.exeDate = exeDate;

}

/**

* 获取：执行时间

*/

public String getExeDate() {

return exeDate;

}

/**

* 设置：人力资源部门意见

*/

public void setHrText(String hrText) {

this.hrText = hrText;

}

/**

* 获取：人力资源部门意见

*/

public String getHrText() {

return hrText;

}

/**

* 设置：分管领导意见

*/

public void setLeadText(String leadText) {

this.leadText = leadText;

}

/**

* 获取：分管领导意见

*/

public String getLeadText() {

return leadText;

}

/**

* 设置：集团主要领导意见

*/

public void setMainLeadText(String mainLeadText) {

this.mainLeadText = mainLeadText;

}

/**

* 获取：集团主要领导意见

*/

public String getMainLeadText() {

return mainLeadText;

}

/**

* 设置：创建者

*/

public void setCreateBy(String createBy) {

this.createBy = createBy;

}

/**

* 获取：创建者

*/

public String getCreateBy() {

return createBy;

}

/**

* 设置：创建时间

*/

public void setCreateDate(Date createDate) {

this.createDate = createDate;

}

/**

* 获取：创建时间

*/

public Date getCreateDate() {

return createDate;

}

/**

* 设置：更新者

*/

public void setUpdateBy(String updateBy) {

this.updateBy = updateBy;

}

/**

* 获取：更新者

*/

public String getUpdateBy() {

return updateBy;

}

/**

* 设置：更新时间

*/

public void setUpdateDate(Date updateDate) {

this.updateDate = updateDate;

}

/**

* 获取：更新时间

*/

public Date getUpdateDate() {

return updateDate;

}

/**

* 设置：备注信息

*/

public void setRemarks(String remarks) {

this.remarks = remarks;

}

/**

* 获取：备注信息

*/

public String getRemarks() {

return remarks;

}

/**

* 设置：删除标记

*/

public void setDelFlag(String delFlag) {

this.delFlag = delFlag;

}

/**

* 获取：删除标记

*/

public String getDelFlag() {

return delFlag;

}

}

package com.bootdo.activiti.domain;

import java.util.Map;

import com.fasterxml.jackson.annotation.JsonInclude;

/**

* @author bootdo 1992lcg@163.com

*/

public class TaskDO {

@JsonInclude(JsonInclude.Include.NON_NULL)

private String taskId;

@JsonInclude(JsonInclude.Include.NON_NULL)

private String taskComment;

@JsonInclude(JsonInclude.Include.NON_NULL)

private String taskPass;

@JsonInclude(JsonInclude.Include.NON_NULL)

private String execId;// 流程实例id

@JsonInclude(JsonInclude.Include.NON_NULL)

private String procDefId;// 流程定义id

@JsonInclude(JsonInclude.Include.NON_NULL)

private Map vars;

public String getExecId() {

return execId;

}

public void setExecId(String execId) {

this.execId = execId;

}

public String getProcDefId() {

return procDefId;

}

public void setProcDefId(String procDefId) {

this.procDefId = procDefId;

}

public String getTaskId() {

return taskId;

}

public void setTaskId(String taskId) {

this.taskId = taskId;

}

public String getTaskComment() {

return taskComment;

}

public void setTaskComment(String taskComment) {

this.taskComment = taskComment;

}

public String getTaskPass() {

return taskPass;

}

public void setTaskPass(String taskPass) {

this.taskPass = taskPass;

}

public Map getVars() {

return vars;

}

public void setVars(Map vars) {

this.vars = vars;

}

}

service

package com.bootdo.activiti.service;

import com.bootdo.activiti.domain.ActivitiDO;

import java.io.InputStream;

import java.util.List;

import java.util.Map;

/**

*/

public interface ActTaskService {

List listTodo(ActivitiDO act);

void complete(String taskId, String procInsId, String comment, String title, Map vars);

void complete(String taskId,Map vars);

//后台启动流程

String startProcess(String procDefKey, String businessTable, String businessId, String title, Map vars);

//app启动流程

String startAppProcess(String userId,String procDefKey, String businessTable, String businessId, String title, Map vars);

String getFormKey(String procDefId, String taskDefKey);

InputStream tracePhoto(String processDefinitionId, String executionId);

}

package com.bootdo.activiti.service.impl;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.activiti.bpmn.model.BpmnModel;

import org.activiti.engine.FormService;

import org.activiti.engine.HistoryService;

import org.activiti.engine.IdentityService;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.RepositoryService;

import org.activiti.engine.RuntimeService;

import org.activiti.engine.TaskService;

import org.activiti.engine.history.HistoricActivityInstance;

import org.activiti.engine.history.HistoricProcessInstance;

import org.activiti.engine.impl.RepositoryServiceImpl;

import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;

import org.activiti.engine.impl.pvm.PvmTransition;

import org.activiti.engine.impl.pvm.process.ActivityImpl;

import org.activiti.image.ProcessDiagramGenerator;

import org.activiti.spring.ProcessEngineFactoryBean;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import com.bootdo.activiti.domain.ActivitiDO;

import com.bootdo.activiti.service.ActTaskService;

import com.bootdo.common.utils.ShiroUtils;

import com.bootdo.common.utils.StringUtils;

/**

*/

@Service

public class ActTaskServiceImpl implements ActTaskService {

@Autowired

TaskService taskService;

@Autowired

IdentityService identityService;

@Autowired

RuntimeService runtimeService;

@Autowired

FormService formService;

@Autowired

RepositoryService repositoryService;

@Autowired

private ProcessEngineFactoryBean processEngineFactory;

@Autowired

private ProcessEngine processEngine;

@Autowired

private HistoryService historyService;

@Override

public List listTodo(ActivitiDO act) {

// String userId = String.valueOf(ShiroUtils.getUserId());

List result = new ArrayList();

return result;

}

/**

* 提交任务, 并保存意见

*

* @param taskId

* 任务ID

* @param procInsId

* 流程实例ID，如果为空，则不保存任务提交意见

* @param comment

* 任务提交意见的内容

* @param title

* 流程标题，显示在待办任务标题

* @param vars

* 任务变量

*/

@Override

public void complete(String taskId, String procInsId, String comment,

String title, Map vars) {

// 添加意见

if (StringUtils.isNotBlank(procInsId)

&& StringUtils.isNotBlank(comment)) {

taskService.addComment(taskId, procInsId, comment);

}

// 设置流程变量

if (vars == null) {

vars = new HashMap<>();

}

// 设置流程标题

if (StringUtils.isNotBlank(title)) {

vars.put("title", title);

}

// 提交任务

taskService.complete(taskId, vars);

}

@Override

public void complete(String taskId, Map vars) {

// 2.1根据人物ID查询流程实力ID

// Task task =

// taskService.createTaskQuery().taskId(taskId).singleResult();

// 获取流程实例ID

// String processInstance = task.getProcessInstanceId();

// 2.2根据流程实例ID，人物ID，评论的消息，保存教师或者学术对与该学生申请的评论信息

// taskService.addComment(taskId,

// processInstance, "");

// Map vars = new HashMap<>();

// vars.put("pass", "1" );

// vars.put("title","");

taskService.complete(taskId, vars);

}

/**

* 启动流程

*

* @param procDefKey

* 流程定义KEY

* @param businessTable

* 业务表表名

* @param businessId

* 业务表编号

* @param title

* 流程标题，显示在待办任务标题

* @param vars

* 流程变量

* @return 流程实例ID

*/

@Override

public String startProcess(String procDefKey, String businessTable,

String businessId, String title, Map vars) {

String userId = ShiroUtils.getUser().getUsername();// ObjectUtils.toString(UserUtils.getUser().getId())

// 用来设置启动流程的人员ID，引擎会自动把用户ID保存到activiti:initiator中

identityService.setAuthenticatedUserId(userId);

// 设置流程变量

if (vars == null) {

vars = new HashMap();

}

// 设置流程标题

if (StringUtils.isNotBlank(title)) {

vars.put("title", title);

}

// 启动流程

runtimeService.startProcessInstanceByKey(procDefKey, businessId, vars);

return null;

}

// app启动流程

@Override

public String startAppProcess(String userId, String procDefKey,

String businessTable, String businessId, String title,

Map vars) {

// 用来设置启动流程的人员ID，引擎会自动把用户ID保存到activiti:initiator中

identityService.setAuthenticatedUserId(userId);

// 设置流程变量

if (vars == null) {

vars = new HashMap();

}

// 设置流程标题

if (StringUtils.isNotBlank(title)) {

vars.put("title", title);

}

// 启动流程

runtimeService.startProcessInstanceByKey(procDefKey, businessId, vars);

return null;

}

/**

* 获取流程表单(首先获取任务节点表单KEY，如果没有则取流程开始节点表单KEY)

*

* @return

*/

@Override

public String getFormKey(String procDefId, String taskDefKey) {

String formKey = "";

if (StringUtils.isNotBlank(procDefId)) {

if (StringUtils.isNotBlank(taskDefKey)) {

try {

formKey = formService.getTaskFormKey(procDefId, taskDefKey);

} catch (Exception e) {

formKey = "";

}

}

if (StringUtils.isBlank(formKey)) {

formKey = formService.getStartFormKey(procDefId);

}

if (StringUtils.isBlank(formKey)) {

formKey = "/404";

}

}

return formKey;

}

@SuppressWarnings("unused")

@Override

public InputStream tracePhoto(String xx, String pProcessInstanceId) {

// // ProcessInstance processInstance =

// runtimeService.createProcessInstanceQuery().processInstanceId(executionId).singleResult();

// BpmnModel bpmnModel =

// repositoryService.getBpmnModel(processDefinitionId);

//

// List activeActivityIds = new ArrayList();

// if

// (runtimeService.createExecutionQuery().executionId(executionId).count()

// > 0){

// activeActivityIds = runtimeService.getActiveActivityIds(executionId);

// }

//

// // 不使用spring请使用下面的两行代码

// // ProcessEngineImpl defaultProcessEngine =

// (ProcessEngineImpl)ProcessEngines.getDefaultProcessEngine();

// //

// Context.setProcessEngineConfiguration(defaultProcessEngine.getProcessEngineConfiguration());

//

// // 使用spring注入引擎请使用下面的这行代码

// Context.setProcessEngineConfiguration(processEngineFactory.getProcessEngineConfiguration());

// // return ProcessDiagramGenerator.generateDiagram(bpmnModel, "png",

// activeActivityIds);

// return

// processEngine.getProcessEngineConfiguration().getProcessDiagramGenerator()

// .generateDiagram(bpmnModel, "png", activeActivityIds);

// 获取历史流程实例

HistoricProcessInstance historicProcessInstance = historyService

.createHistoricProcessInstanceQuery()

.processInstanceId(pProcessInstanceId).singleResult();

if (historicProcessInstance != null) {

// 获取流程定义

ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)

.getDeployedProcessDefinition(historicProcessInstance

.getProcessDefinitionId());

// 获取流程历史中已执行节点，并按照节点在流程中执行先后顺序排序

List historicActivityInstanceList = historyService

.createHistoricActivityInstanceQuery()

.processInstanceId(pProcessInstanceId)

.orderByHistoricActivityInstanceId().asc().list();

// 已执行的节点ID集合

List executedActivityIdList = new ArrayList();

int index = 1;

// 获取已经执行的节点ID

for (HistoricActivityInstance activityInstance : historicActivityInstanceList) {

executedActivityIdList.add(activityInstance.getActivityId());

index++;

}

// 已执行的线集合

List flowIds = new ArrayList();

// 获取流程走过的线

flowIds = getHighLightedFlows(processDefinition,

historicActivityInstanceList);

BpmnModel bpmnModel = repositoryService

.getBpmnModel(historicProcessInstance

.getProcessDefinitionId());

// 获取流程图图像字符流

ProcessDiagramGenerator pec = processEngine

.getProcessEngineConfiguration()

.getProcessDiagramGenerator();

// 配置字体

InputStream imageStream = pec.generateDiagram(bpmnModel, "png",

executedActivityIdList, flowIds, "宋体", "微软雅黑", "黑体", null,

2.0);

return imageStream;

}

return null;

}

/**

* 获取需要高亮的线

*

* @param processDefinitionEntity

* @param historicActivityInstances

* @return

*/

private List getHighLightedFlows(

ProcessDefinitionEntity processDefinitionEntity,

List historicActivityInstances) {

List highFlows = new ArrayList();// 用以保存高亮的线flowId

for (int i = 0; i < historicActivityInstances.size() - 1; i++) {// 对历史流程节点进行遍历

ActivityImpl activityImpl = processDefinitionEntity

.findActivity(historicActivityInstances.get(i)

.getActivityId());// 得到节点定义的详细信息

List sameStartTimeNodes = new ArrayList();// 用以保存后需开始时间相同的节点

ActivityImpl sameActivityImpl1 = processDefinitionEntity

.findActivity(historicActivityInstances.get(i + 1)

.getActivityId());

// 将后面第一个节点放在时间相同节点的集合里

sameStartTimeNodes.add(sameActivityImpl1);

for (int j = i + 1; j < historicActivityInstances.size() - 1; j++) {

HistoricActivityInstance activityImpl1 = historicActivityInstances

.get(j);// 后续第一个节点

HistoricActivityInstance activityImpl2 = historicActivityInstances

.get(j + 1);// 后续第二个节点

if (activityImpl1.getStartTime().equals(

activityImpl2.getStartTime())) {

// 如果第一个节点和第二个节点开始时间相同保存

ActivityImpl sameActivityImpl2 = processDefinitionEntity

.findActivity(activityImpl2.getActivityId());

sameStartTimeNodes.add(sameActivityImpl2);

} else {

// 有不相同跳出循环

break;

}

}

List pvmTransitions = activityImpl

.getOutgoingTransitions();// 取出节点的所有出去的线

for (PvmTransition pvmTransition : pvmTransitions) {

// 对所有的线进行遍历

ActivityImpl pvmActivityImpl = (ActivityImpl) pvmTransition

.getDestination();

// 如果取出的线的目标节点存在时间相同的节点里，保存该线的id，进行高亮显示

if (sameStartTimeNodes.contains(pvmActivityImpl)) {

highFlows.add(pvmTransition.getId());

}

}

}

return highFlows;

}

}

package com.bootdo.activiti.service;

import com.bootdo.activiti.domain.SalaryDO;

import java.util.List;

import java.util.Map;

/**

* 审批流程测试表

*

* @author chglee

* @email 1992lcg@163.com

* @date 2017-11-25 13:33:16

*/

public interface SalaryService {

SalaryDO get(String id);

List list(Map map);

int count(Map map);

int save(SalaryDO salary);

int update(SalaryDO salary);

int remove(String id);

int batchRemove(String[] ids);

}

package com.bootdo.activiti.service.impl;

import com.bootdo.activiti.config.ActivitiConstant;

import com.bootdo.common.utils.StringUtils;

import org.activiti.engine.TaskService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import com.bootdo.activiti.dao.SalaryDao;

import com.bootdo.activiti.domain.SalaryDO;

import com.bootdo.activiti.service.SalaryService;

import org.springframework.transaction.annotation.Transactional;

@Service

public class SalaryServiceImpl implements SalaryService {

@Autowired

private SalaryDao salaryDao;

@Autowired

private ActTaskServiceImpl actTaskService;

@Override

public SalaryDO get(String id){

return salaryDao.get(id);

}

@Override

public List list(Map map){

return salaryDao.list(map);

}

@Override

public int count(Map map){

return salaryDao.count(map);

}

@Transactional(rollbackFor=Exception.class)

@Override

public int save(SalaryDO salary){

salary.setId(UUID.randomUUID().toString().replace("-",""));

actTaskService.startProcess(ActivitiConstant.ACTIVITI_SALARY[0],ActivitiConstant.ACTIVITI_SALARY[1],salary.getId(),salary.getContent(),new HashMap<>());

return salaryDao.save(salary);

}

@Transactional(rollbackFor=Exception.class)

@Override

public int update(SalaryDO salary){

Map vars = new HashMap<>(16);

vars.put("pass", salary.getTaskPass() );

vars.put("title","");

actTaskService.complete(salary.getTaskId(),vars);

return salaryDao.update(salary);

}

@Override

public int remove(String id){

return salaryDao.remove(id);

}

@Override

public int batchRemove(String[] ids){

return salaryDao.batchRemove(ids);

}

}