activiti6.0驳回到发起人

package com.sn.cloud.activiti6.controller;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.apache.commons.lang3.StringUtils;
import org.imeta.biz.base.BizException;
import org.imeta.orm.schema.QueryCondition;
import org.imeta.orm.schema.QueryConditionGroup;
import org.imeta.orm.schema.QuerySchema;
import org.imeta.spring.support.db.ModelManager;
import org.imeta.spring.support.db.OrmException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;

import com.sn.cloud.aa.user.User;
import com.sn.cloud.ac.taskinfo.TaskInfo;
import com.sn.cloud.ac.taskinfo.TaskStatus;
import com.sn.cloud.activiti6.cmd.RollbackFirstTaskCmd;
import com.sn.cloud.activiti6.rule.QueryTaskInfoRule;
import com.sn.cloud.base.BaseController;
import com.sn.cloud.base.database.DataOperator;
import com.sn.cloud.bill.aa.rule.FullnameEnum;
import com.sn.cloud.bill.base.dao.UpdateParamTool;
import com.sn.cloud.core.AppContext;
import com.sn.cloud.dao.sql.SqlHelper;
import com.sn.cloud.util.ResultMessage;

@Controller
@RequestMapping("/activiti")
public class ActivitiRejectController extends BaseController {
	@Autowired
	private ProcessEngine processEngine;
	@Autowired
	private QueryTaskInfoRule queryTaskinfoRule;

	/**
	 * 驳回到发起人
	 * 
	 * @throws Exception
	 */
	@RequestMapping("/reject")
	public void RollbackFirstTask(@RequestBody Map<Object, Object> bill,
			HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		User user = AppContext.getCurrentUser();
		String taskId = GetTaskId(bill);
		String taskinfoTaskId = getTaskinfoTaskId(bill);
		String auditopinion = bill.get("note").toString();
		RollbackFirstTaskCmd cmd = new RollbackFirstTaskCmd(taskId);
		cmd.deletereason = bill.get("note").toString();
		if (getWillRejectTask(bill, taskinfoTaskId) == null) {
			queryTaskinfoRule.updateTaskInfo();
		}
		processEngine.getManagementService().executeCommand(cmd);
		updateAuditOpinion(taskId, auditopinion);
		TaskInfo info = getWillRejectTask(bill, taskinfoTaskId);
		if (info == null) {
			throw new BizException("查询单据异常，请检查");
		}
		info.setTaskstatus(TaskStatus.reject);
		String taskContext = queryTaskinfoRule.getTaskContext(user.getName(),
				info);
		DataOperator.getInstance().updateOne(
				(long) info.getId(),
				FullnameEnum.TaskInfo.value(),
				UpdateParamTool.createParamlist()
						.add("taskstatus", TaskStatus.reject.getValue())
						.add("deleteReason", cmd.deletereason)
						.add("taskContext", taskContext).toList());
		System.out.println("驳回ID为" + taskId + "的任务");
		renderJson(response, ResultMessage.success());
	}

	/**
	 * 更新审核意见
	 * 
	 * @param taskId
	 * @param auditopinion
	 */
	public void updateAuditOpinion(String taskId, String auditopinion) {
		if (StringUtils.isNotBlank(auditopinion)) {
			Map<String, Object> paramMap = new HashMap<>();
			paramMap.put("auditopinion", auditopinion);
			paramMap.put("taskId", taskId);
			try {
				SqlHelper.update("updatedeletereason", paramMap);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 
	 * @param bill
	 * @param taskinfoTaskId
	 * @return
	 * @throws BizException
	 * @throws OrmException
	 */
	private TaskInfo getWillRejectTask(Map<Object, Object> bill,
			String taskinfoTaskId) throws BizException, OrmException {
		User user = AppContext.getCurrentUser();
		QuerySchema schema = QuerySchema
				.create()
				.addSelect("*")
				.addCondition(
						QueryConditionGroup.and(
								QueryCondition.name("assignee").eq(
										user.getId().toString()),
								QueryCondition.name("taskid")
										.eq(taskinfoTaskId),
								QueryCondition.name("tenant").eq(
										user.getTenant().toString())));
		List<TaskInfo> oldTaskInfos = ModelManager.getInstance().query(
				FullnameEnum.TaskInfo.value(), schema);
		if (!oldTaskInfos.isEmpty()) {
			return oldTaskInfos.get(0);
		}
		return null;
	}

	/**
	 * 
	 * @param bill
	 * @return
	 */
	private String getTaskinfoTaskId(Map<Object, Object> bill) {
		String bussinesskey = bill.get("id").toString();
		ProcessInstance pInstance = processEngine.getRuntimeService()
				.createProcessInstanceQuery()
				.processInstanceBusinessKey(bussinesskey).singleResult();
		User user = AppContext.getCurrentUser();
		String assignee = user.getId().toString();
		String processInstanceId = pInstance.getId();
		List<HistoricActivityInstance> allTaskInfos = processEngine
				.getHistoryService().createHistoricActivityInstanceQuery()
				.activityTenantId(user.getTenant().toString())
				.taskAssignee(assignee).processInstanceId(processInstanceId)
				.list();
		TaskService taskService = processEngine.getTaskService();
		Task task = taskService.createTaskQuery()
				// 创建任务查询对象
				.taskAssignee(assignee).processInstanceId(processInstanceId)
				.singleResult();
		HistoricActivityInstance instance = allTaskInfos
				.stream()
				.filter(item -> item.getTaskId() != null
						&& item.getTaskId().equals(task.getId())).findFirst()
				.get();
		return instance.getId();
	}
	/**
	 * 获取taskid
	 * 
	 * @param bill
	 * @return
	 */
	public String GetTaskId(Map<Object, Object> bill) {
		String bussinesskey = bill.get("id").toString();
		ProcessInstance pInstance = processEngine.getRuntimeService()
				.createProcessInstanceQuery()
				.processInstanceBusinessKey(bussinesskey).singleResult();
		User user = AppContext.getCurrentUser();
		String assignee = user.getId().toString();
		String processInstanceId = pInstance.getId();
		TaskService taskService = processEngine.getTaskService();
		Task task = taskService.createTaskQuery()
				// 创建任务查询对象
				.taskAssignee(assignee).processInstanceId(processInstanceId)
				.singleResult();
		return task.getId();
	}
}

package com.sn.cloud.activiti6.cmd;

import java.util.List;

import org.activiti.bpmn.model.FlowElement;
import org.activiti.bpmn.model.FlowNode;
import org.activiti.bpmn.model.Process;
import org.activiti.bpmn.model.SequenceFlow;
import org.activiti.bpmn.model.UserTask;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.impl.cmd.NeedsActiveTaskCmd;
import org.activiti.engine.impl.interceptor.CommandContext;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntityManager;
import org.activiti.engine.impl.util.ProcessDefinitionUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;



public class RollbackFirstTaskCmd extends NeedsActiveTaskCmd<Void> {
	private static Logger logger = LoggerFactory.getLogger(RollbackFirstTaskCmd.class);

    public RollbackFirstTaskCmd(String taskId){
        super(taskId);
    }
    public String deletereason;
    
	public Void execute(CommandContext commandContext, TaskEntity currentTask) {
		String processDefinitionId = currentTask.getProcessDefinitionId();
		String executionId = currentTask.getExecutionId();
		
        TaskEntityManager taskEntityManager = commandContext.getTaskEntityManager();
        taskEntityManager.deleteTask(currentTask, deletereason, false, false);

		FlowNode firstUserTask = this.findFirstActivity(processDefinitionId);
		ExecutionEntity executionEntity = commandContext.getExecutionEntityManager().findById(executionId);

		// 获取目标节点的来源连线
        List<SequenceFlow> flows = firstUserTask.getIncomingFlows();
        if (flows == null || flows.isEmpty()) {
            throw new ActivitiException("回退错误，目标节点没有来源连线");
        }
        // 随便选一条连线来执行，时当前执行计划为，从连线流转到目标节点，实现跳转
		executionEntity.setCurrentFlowElement(flows.get(0));
        commandContext.getAgenda().planTakeOutgoingSequenceFlowsOperation(executionEntity, true);

		// executionEntity.setCurrentFlowElement(flowElement);
		// commandContext.getAgenda().planContinueProcessOperation(executionEntity);

		return null;
    }

    public String getSuspendedTaskException() {
        return "挂起的任务不能跳转";
    }

    /**
     * 获得第一个节点.
     */
    public FlowNode findFirstActivity(String processDefinitionId) {
		Process process = ProcessDefinitionUtil.getProcess(processDefinitionId);
		FlowElement flowElement = process.getInitialFlowElement();
		FlowNode startActivity = (FlowNode) flowElement;

        if (startActivity.getOutgoingFlows().size() != 1) {
            throw new IllegalStateException(
                    "start activity outgoing transitions cannot more than 1, now is : "
                            + startActivity.getOutgoingFlows().size());
        }

        SequenceFlow sequenceFlow = startActivity.getOutgoingFlows()
                .get(0);
        FlowNode targetActivity = (FlowNode) sequenceFlow.getTargetFlowElement();

        if (!(targetActivity instanceof UserTask)) {
            logger.info("first activity is not userTask, just skip");

            return null;
        }

        return targetActivity;
    }
}