TaskService.java

package com.norteksoft.wf.engine.service;

import java.lang.reflect.InvocationTargetException;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jbpm.api.Execution;
import org.jbpm.api.JbpmException;
import org.jbpm.api.ProcessEngine;
import org.jbpm.api.ProcessInstance;
import org.jbpm.api.activity.ActivityExecution;
import org.jbpm.api.model.Activity;
import org.jbpm.api.model.OpenExecution;
import org.jbpm.pvm.internal.model.ExecutionImpl;
import org.jbpm.pvm.internal.task.ParticipationImpl;
import org.jbpm.pvm.internal.task.TaskImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import com.norteksoft.acs.api.AcsApi;
import com.norteksoft.acs.entity.authorization.BusinessSystem;
import com.norteksoft.acs.entity.authorization.Role;
import com.norteksoft.acs.entity.organization.User;
import com.norteksoft.acs.entity.organization.Workgroup;
import com.norteksoft.acs.service.AcsUtils;
import com.norteksoft.acs.service.authorization.BusinessSystemManager;
import com.norteksoft.acs.service.organization.UserManager;
import com.norteksoft.mms.base.utils.FreeMarkertUtils;
import com.norteksoft.mms.form.dao.GeneralDao;
import com.norteksoft.mms.form.entity.AutomaticallyFilledField;
import com.norteksoft.mms.form.entity.FormControl;
import com.norteksoft.mms.form.entity.FormView;
import com.norteksoft.mms.form.entity.TableColumn;
import com.norteksoft.mms.form.enumeration.DataType;
import com.norteksoft.mms.form.jdbc.JdbcSupport;
import com.norteksoft.mms.form.service.FormViewManager;
import com.norteksoft.mms.form.service.TableColumnManager;
import com.norteksoft.product.api.ApiFactory;
import com.norteksoft.product.api.entity.Department;
import com.norteksoft.product.api.impl.WorkflowClientManager;
import com.norteksoft.product.orm.Page;
import com.norteksoft.product.util.AsyncMailUtils;
import com.norteksoft.product.util.ContextUtils;
import com.norteksoft.product.util.PropUtils;
import com.norteksoft.product.web.struts2.Struts2Utils;
import com.norteksoft.task.base.enumeration.TaskProcessingMode;
import com.norteksoft.task.base.enumeration.TaskProcessingResult;
import com.norteksoft.task.base.enumeration.TaskSource;
import com.norteksoft.task.base.enumeration.TaskState;
import com.norteksoft.task.entity.TaskMark;
import com.norteksoft.task.entity.TaskSetting;
import com.norteksoft.task.entity.WorkflowTask;
import com.norteksoft.task.webservice.WorkflowTaskService;
import com.norteksoft.wf.base.enumeration.CommonStrings;
import com.norteksoft.wf.base.enumeration.CompleteTaskTipType;
import com.norteksoft.wf.base.enumeration.LogicOperator;
import com.norteksoft.wf.base.enumeration.ProcessState;
import com.norteksoft.wf.base.enumeration.TaskTransactorCondition;
import com.norteksoft.wf.base.enumeration.WorkflowTacheType;
import com.norteksoft.wf.base.exception.TransactorAssignmentException;
import com.norteksoft.wf.base.utils.BeanShellUtil;
import com.norteksoft.wf.base.utils.WebUtil;
import com.norteksoft.wf.engine.client.AfterTaskCompleted;
import com.norteksoft.wf.engine.client.BeforeTaskSubmit;
import com.norteksoft.wf.engine.client.FormFlowable;
import com.norteksoft.wf.engine.client.ReturnTaskInterface;
import com.norteksoft.wf.engine.client.OnStartingSubProcess;
import com.norteksoft.wf.engine.client.RetrieveTaskInterface;
import com.norteksoft.wf.engine.core.DefinitionXmlParse;
import com.norteksoft.wf.engine.core.ExecutionVariableCommand;
import com.norteksoft.wf.engine.core.GetBackCommand;
import com.norteksoft.wf.engine.core.SubProcessParse;
import com.norteksoft.wf.engine.core.TaskAssigneeCommand;
import com.norteksoft.wf.engine.core.TransactorConditionHandler;
import com.norteksoft.wf.engine.core.impl.UserParseCalculator;
import com.norteksoft.wf.engine.dao.OpinionDao;
import com.norteksoft.wf.engine.entity.InstanceHistory;
import com.norteksoft.wf.engine.entity.TrustRecord;
import com.norteksoft.wf.engine.entity.WorkflowDefinition;
import com.norteksoft.wf.engine.entity.WorkflowInstance;
import com.norteksoft.wf.engine.entity.WorkflowType;

/**
 * 工作流任务处理
 * 
 * @author Administrator
 *
 */
@Service
@Transactional
public class TaskService {
	
	private Log log = LogFactory.getLog(TaskService.class);
	private SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	private ProcessEngine processEngine;
	private WorkflowTaskService workflowTaskService;
	private WorkflowInstanceManager workflowInstanceManager;
	private InstanceHistoryManager instanceHistoryManager;
	private WorkflowDefinitionManager workflowDefinitionManager;
	private GeneralDao generalDao;
	private FormViewManager formViewManager;
	private WorkflowClientManager workflowClientManager ;
	private WorkflowTypeManager workflowTypeManager;
	private static final String PROCESS_WENT = "流程走过";
	private static final String PROCESS_ENTER = "流程进入";
	private static final String PROCESS_JUMPTASK = "流程跳转到";
	private static final String PROCESS_GOBACKTASK = "流程退回到";
	private static final String PROCESS_ADDTRANSACTOR = "增加办理人:";
	private static final String PROCESS_REMOVETRANSACTOR = "减少办理人:";
	private static final String PROCESS_LEAVE = "流程离开";
	private static final String PROCESS_END = "流程结束";
	private static final String PROCESS_END_EN = "process_is_end";
	//流转历史常量
	private static final String COMMA = ", ";
	private static final String DELTA_START = "[ ";
	private static final String DELTA_END = " ]";
	private static final String ACTION_START = "点击了[";
	private static final String ACTION_END = "]操作";
	
	private static final String TASK_CANCEL = "的任务被取消";
	private static final String TASK_BACK = "退回任务";
	
	
	public static final String DEFAULT_URL = "/engine/task!assignTransactor.htm";
	public static final String DEFAULT_URL_POP = "/engine/task!assignTransactorPop.htm";
	public static final String DEFAULT_DO_TASK_URL = "/engine/task!input.htm?taskId=";
	public static final String DEFAULT_CHOICE_TACHE_URL = "/engine/task!choiceTache.htm?taskId=";
	public static final String DEFAULT_CHOICE_TACHE_URL_POP = "/engine/task!choiceTachePop.htm?taskId=";
	public static final String PRE_TRANSACTOR_ASSIGN="${previousTransactorAssignment}";
	
	private static final String SQUARE_BRACKETS_LEFT = "[";
	private static final String SQUARE_BRACKETS_RIGHT = "]";
	private static final String TASK_CUSTOM_INFO="$custom";
	private static final String TASK_TITLE_INFO="$title";
	private DelegateMainManager delegateManager;
	
	private UserManager userManager;
	
	private WorkflowRightsManager workflowRightsManager;
	
	private BusinessSystemManager businessSystemManager;
	
	private TableColumnManager tableColumnManager;
	private OpinionDao opinionDao;
	
	private AcsUtils acsUtils;
	@Autowired
	public void setAcsUtils(AcsUtils acsUtils) {
		this.acsUtils = acsUtils;
	}
	
	public static Map<String,String> instanceIds=new HashMap<String, String>();
	
	
	@Transactional(readOnly=false)
	public void saveTask(WorkflowTask task){
		workflowTaskService.saveTask(task);
	}
	
	@Transactional(readOnly=false)
	public void saveTasks(List<WorkflowTask> tasks){
		workflowTaskService.saveTasks(tasks);
	}
	@Autowired
	public void setGeneralDao(GeneralDao generalDao) {
		this.generalDao = generalDao;
	}
	
	@Autowired
	public void setWorkflowTypeManager(WorkflowTypeManager workflowTypeManager) {
		this.workflowTypeManager = workflowTypeManager;
	}
	@Autowired
	public void setBusinessSystemManager(BusinessSystemManager businessSystemManager) {
		this.businessSystemManager = businessSystemManager;
	}
	@Autowired
	public void setTableColumnManager(TableColumnManager tableColumnManager) {
		this.tableColumnManager = tableColumnManager;
	}
	@Autowired
	public void setOpinionDao(OpinionDao opinionDao) {
		this.opinionDao = opinionDao;
	}

	public WorkflowTask getTask(Long taskId){
		Assert.notNull(taskId, "taskId不能为null");
		return workflowTaskService.getTask(taskId);
	}
	

	@SuppressWarnings("unchecked")
	@Transactional(readOnly=false)
	public List<WorkflowTask> generateFirstTask(String processId, String instanceId,int priority,boolean visible){
		List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
		OpenExecution execution = (OpenExecution)processEngine.getExecutionService().findExecutionById(instanceId);
		String creator =execution.getVariable(CommonStrings.CREATOR)==null?null:execution.getVariable(CommonStrings.CREATOR).toString();
		if(StringUtils.isNotEmpty(creator)){
			WorkflowTask task = generateFirstTask(processId,instanceId,creator, priority, visible); 
			task.setActive(TaskState.WAIT_TRANSACT.getIndex());
			tasks.add(task);
		}else{
			Set<String> creatorCandidates =  execution.getVariable(CommonStrings.CREATOR_CANDIDATES)==null?null:(Set<String>)execution.getVariable(CommonStrings.CREATOR_CANDIDATES);
			for(String transactor:creatorCandidates){
				WorkflowTask task = generateFirstTask(processId,instanceId,transactor, priority, visible); 
				task.setActive(TaskState.DRAW_WAIT.getIndex());
				tasks.add(task);
			}
		}
		this.saveTasks(tasks);
		return tasks;
	}
	/**
	 * 流程启动时生成第一个任务
	 * @param processId
	 * @param instanceId
	 * @param transactor
	 */
	@Transactional(readOnly=false)
	public WorkflowTask generateFirstTask(String processId, String instanceId, String transactor,int priority,boolean visible){
		log.debug("*** generateFirstTask 方法开始");
		
		String firstTaskName = DefinitionXmlParse.getFirstTaskName(processId);
		log.debug("第一环节名："+ firstTaskName);
		
		WorkflowInstance wi=workflowInstanceManager.getWorkflowInstance(instanceId);
		WorkflowTask task = new WorkflowTask();
		task.setCompanyId(wi.getCompanyId());
		task.setProcessInstanceId(instanceId);
		task.setExecutionId(instanceId);
		task.setName(firstTaskName);
		String code = DefinitionXmlParse.getTacheCode(processId, task.getName());
		task.setCode(code);
		task.setDistributable(false);
		task.setTransactor(transactor);
		task.setUrl(getTaskUrl(processId));
		task.setCreator(transactor);
		User user = userManager.getUserByLoginName(task.getTransactor());
		if(user!=null){
			task.setTransactorName(user.getName());
			task.setCreatorName(user.getName());
    	}
		task.setCreatedTime(new Date());
		task.setTaskMark(TaskMark.valueOf(priority));
		addTitle(task, processId,null);
		//FIXME 增加实例标题，实例中任务标题一样时有用，需要修改
		wi.setInstanceTitle(task.getTitle());
		workflowInstanceManager.saveWorkflowInstance(wi);
		
		String processingMode = DefinitionXmlParse.getTaskProcessingMode(
				processId, task.getName());
		boolean moreTransactor = DefinitionXmlParse.hasMoreTransactor(
				processId, task.getName());
		task.setProcessingMode(TaskProcessingMode.getTaskModeFromStringToEnum(processingMode));
		task.setMoreTransactor(moreTransactor);
		task.setRead(false);
		WorkflowDefinition wfDef = workflowDefinitionManager.getWorkflowDefinitionByProcessId(processId);
		//流程类型
		WorkflowType type=null;
		if(wfDef!=null){
			task.setGroupName(wfDef.getName());
			task.setCustomType(wfDef.getCustomType());
			//流程类型
			type=workflowTypeManager.getWorkflowType(wfDef.getTypeId());
			if(type!=null)task.setCategory(type.getName());
		}
		
		task.setVisible(visible);
		task.setUrl(getTaskUrl(processId));
		
		return task;
	}
	/*
	 * 创建任务 
	 * @param processInstanceId
	 * @param executionId
	 * @param transactor
	 * @param activityName
	 * @param processingMode
	 * @param moreTransactor
	 * @param isSendMsg
	 * @return
	 * createTask(task.getProcessInstanceId(), task.getExecutionId(), user, "title", TaskProcessingMode.TYPE_READ.toString(), true));
	 */
	@Transactional(readOnly=false)
	private WorkflowTask createTask(String processInstanceId, String executionId, String transactor, String taskName,Integer groupNum){
		String definitionId = processEngine.getExecutionService().findProcessInstanceById(processInstanceId).getProcessDefinitionId();
		WorkflowTask newTask = createTask(definitionId,processInstanceId,executionId,taskName,transactor, false,groupNum);
		return newTask;
	}
	@Transactional(readOnly=false)
	private WorkflowTask createDistributeTask(WorkflowTask task, String transactor, String processingMode,Integer groupNum){
		String definitionId = processEngine.getExecutionService().findProcessInstanceById(task.getProcessInstanceId()).getProcessDefinitionId();
		WorkflowTask newTask = createTask(definitionId,task.getProcessInstanceId(),task.getExecutionId(),task.getName(),transactor, true,groupNum);
		newTask.setProcessingMode(TaskProcessingMode.getTaskModeFromStringToEnum(processingMode));
		return newTask;
	}
	/*
	 * 创建任务
	 * @param processId 流程定义id
	 * @param workflowId 流程实例id
	 * @param executionId 
	 * @param taskName 任务名
	 * @param transactor 任务办理人
	 * @param isSendMsg 是否发送消息
	 * @return
	 */
	@Transactional(readOnly=false)
	private WorkflowTask createTask(String processId,String workflowId,String executionId,String taskName,String transactor,boolean isDistribute,Integer groupNum){
		log.debug(new StringBuilder("*** createTask parameter:[")
		.append("processId:").append(processId)
		.append(", workflowId:").append(workflowId)
		.append(", executionId:").append(executionId)
		.append(", taskName:").append(taskName)
		.append(", transactor:").append(transactor)
		.append("]").toString());
		
			WorkflowTask task = new WorkflowTask();
			WorkflowInstance  wi=workflowInstanceManager.getWorkflowInstance(workflowId,ContextUtils.getCompanyId());
			if(wi.getProcessState()!=ProcessState.END&&wi.getProcessState()!=ProcessState.MANUAL_END){//流程实例没有结束或强制结束则执行以下语句，因为jbpm4.4中当实例结束后删除该实例，执行processEngine.getExecutionService().getVariable时报异常
				Object creator = processEngine.getExecutionService().getVariable(executionId, CommonStrings.CREATOR);
				if(creator != null){
					User user = userManager.getUserByLoginName(creator.toString());
					task.setCreator(user.getLoginName());
					task.setCreatorName(user.getName());
				}
			}
			wi=workflowInstanceManager.getWorkflowInstance(workflowId,ContextUtils.getCompanyId());
			task.setCompanyId(ContextUtils.getCompanyId());
			task.setProcessInstanceId(workflowId);
			task.setExecutionId(executionId);
			task.setDistributable(isDistribute);
			log.info("taskService 设置办理人"+transactor);
			String titleInfo=setTaskTransactorInfo(transactor, task);
			 String delegateTransactor = delegateManager.getDelegateMainName(
					 wi.getCompanyId(), transactor,wi.getProcessDefinitionId() , taskName);
			 boolean moreTransactor = DefinitionXmlParse.hasMoreTransactor(
					 processId, taskName);
			 boolean shouldSaveTask =  shouldSaveTask(wi.getCompanyId(),task.getTransactor(),null,wi.getProcessInstanceId(),delegateTransactor,moreTransactor);
			 User user = userManager.getUserByLoginName(task.getTransactor());
			 if(user!=null){//如果办理人transactor存在才生成任务
				 task.setTransactorName(user.getName());
			 }else{
				 return null;
			 }
			 task.setName(taskName);
			 String code = DefinitionXmlParse.getTacheCode(processId, taskName);
			 task.setCode(code);
			 task.setCreatedTime(new Date());
			 
			 if(wi.getProcessState()!=ProcessState.END&&wi.getProcessState()!=ProcessState.MANUAL_END){//流程实例没有结束或强制结束则执行以下语句，因为jbpm4.4中当实例结束后删除该实例，执行processEngine.getExecutionService().getVariable时报异常
				 Object priorityObject = processEngine.getExecutionService().getVariable(executionId, CommonStrings.PRIORITY);
				 if(priorityObject != null){
					 int priority = Integer.valueOf(priorityObject.toString());
					 task.setTaskMark(TaskMark.valueOf(priority));
				 }
			 }
			 addTitle(task, processId,titleInfo);
			 //FIXME 增加实例标题,实例中任务标题一样时有用，需要修改
			 wi.setInstanceTitle(task.getTitle());
			 workflowInstanceManager.saveWorkflowInstance(wi);
			 
			 String processingMode = DefinitionXmlParse.getTaskProcessingMode(
					 processId, taskName);
			 log.debug("办理模式："+processingMode);
			 log.debug("是否多人办理："+moreTransactor);
			 task.setProcessingMode(TaskProcessingMode.getTaskModeFromStringToEnum(processingMode));
			 task.setMoreTransactor(moreTransactor);
			 task.setActive(TaskState.WAIT_TRANSACT.getIndex());
			 task.setUrl(getTaskUrl(processId));
			 task.setRead(false);
			 Map<String,String > buttonNameSetting = DefinitionXmlParse.getButtonNameByProcessMode(processId, task.getName(),TaskProcessingMode.getTaskModeFromStringToEnum(processingMode));
			 setButtonName(TaskProcessingMode.getTaskModeFromStringToEnum(processingMode),task,buttonNameSetting);
			 Map<String,String > reminderSetting = DefinitionXmlParse.getReminderSetting(processId, task.getName());
			 task.setReminderStyle(reminderSetting.get(DefinitionXmlParse.REMIND_STYLE));
			 if(reminderSetting.get(DefinitionXmlParse.REMIND_REPEAT)!=null)task.setRepeat(Long.valueOf(reminderSetting.get(DefinitionXmlParse.REMIND_REPEAT)));
			 if(reminderSetting.get(DefinitionXmlParse.REMIND_DUEDATE)!=null)task.setDuedate(Long.valueOf(reminderSetting.get(DefinitionXmlParse.REMIND_DUEDATE)));
			 if(reminderSetting.get(DefinitionXmlParse.REMIND_TIME)!=null)task.setReminderLimitTimes(Integer.valueOf(reminderSetting.get(DefinitionXmlParse.REMIND_TIME)));
			 if(reminderSetting.get(DefinitionXmlParse.REMIND_NOTICE_TYPE)!=null)task.setReminderNoticeStyle(reminderSetting.get(DefinitionXmlParse.REMIND_NOTICE_TYPE));
			 if(reminderSetting.get(DefinitionXmlParse.REMIND_NOTICE_USER_CONDITION)!=null)task.setReminderNoticeUser(parseUserCondition( task,reminderSetting.get(DefinitionXmlParse.REMIND_NOTICE_USER_CONDITION)));
			 task.setSendingMessage(ApiFactory.getAcsService().isRtxEnable());
			 WorkflowDefinition wfDef = workflowDefinitionManager.getWorkflowDefinitionByProcessId(processId);
			 
			 //流程类型
			 WorkflowType type=null;
			 if(wfDef!=null){
				 task.setGroupName(wfDef.getName());
				 task.setCustomType(wfDef.getCustomType());
				 //流程类型
				 type=workflowTypeManager.getWorkflowType(wfDef.getTypeId());
				 if(type!=null)task.setCategory(type.getName());
			 }
			 if(delegateTransactor != null){
				 task.setTrustor(task.getTransactor());
				 user = userManager.getUserByLoginName(task.getTransactor());
				 if(user!=null)task.setTrustorName(user.getName());
				 task.setTransactor(delegateTransactor);
				 user = userManager.getUserByLoginName(task.getTransactor());
				 if(user!=null){
					 task.setTransactorName(user.getName());
				 }
				 //生成委托流转历史
				 generateDelegateHistory(task);
			 }
			 //设置"任务组编号"
			 task.setGroupNum(groupNum);
			//是否显示，bkyoa特制功能
			task.setVisible(shouldSaveTask);
			 //*******************消息提醒*************************
			 sendMessage(task,type);
			 //*******************邮件通知*************************
			 sendMail(task,processId);
			 return task;
	}
	//委托人和受托人是否是同一部门
	private boolean trustorTransactorSameDept(String trustor,String delegateTransactor){
		String bkySpecial=PropUtils.getProp("bky.special");
		boolean isSameDept=false;
		if("true".equals(bkySpecial)){//是否是bky特制的功能,当受托人和委托人是同一部门时不生成委托任务
			//trustor和delegateTransactor是否是同一部门
			//委托人部门列表
			List<Department> trustorDepts = ApiFactory.getAcsService().getDepartments(trustor);
			//受托人部门列表
			List<Department> delegateDepts = ApiFactory.getAcsService().getDepartments(delegateTransactor);
			for(Department dept:delegateDepts){
				for(Department trustorDept:trustorDepts){
					if(dept.getName().equals(trustorDept.getName())){
						isSameDept=true;
						break;
					}
				}
				if(isSameDept)break;
			}
		}
		return isSameDept;
	}
	
	/**
	 * 生成委托流转历史
	 * @param task
	 * @param type
	 */
	private void generateDelegateHistory(WorkflowTask task) {
		StringBuilder historyMessage = new StringBuilder();
		historyMessage.append(dateFormat.format(new Date())).append(COMMA)
		.append(acsUtils.getUserByLoginName(task.getTrustor()).getName())
		.append("已把任务委托给了")
		.append(task.getTransactorName()).append("。\n");
		
		InstanceHistory history = new InstanceHistory(task.getCompanyId(), task.getProcessInstanceId(), InstanceHistory.TYPE_TASK, historyMessage.toString(), task.getName());
		history.setEffective(false);
		history.setCreatedTime(new Date());
		history.setExecutionId(task.getProcessInstanceId());
		
        instanceHistoryManager.saveHistory(history);
		
	}

	/**
	 * 消息提醒
	 * @param task
	 * @param type
	 */
	private void sendMessage(WorkflowTask task,WorkflowType type){
		saveTask(task);
		try {
			ApiFactory.getPortalService().addMessage("task", ContextUtils.getUserName(), ContextUtils.getLoginName(), task.getTransactor(),type==null?"待办任务":type.getName(), task.getTitle(), "/task/message-task.htm?id="+task.getId());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	private void sendMail(WorkflowTask task,String processId){
	    try{
	        boolean isMailNotice=DefinitionXmlParse.isMailNotice(processId, task.getName());
	        if(isMailNotice){
	            String mailContent=PropUtils.getProp("mail.properties", "task.notice.content");
	            if(StringUtils.isNotEmpty(mailContent)){
	                mailContent=mailContent.replace("${url}", workflowTaskService.getTaskUrl(task));
	            }
	            com.norteksoft.product.api.entity.User user=ApiFactory.getAcsService().getUserByLoginName(task.getTransactor());
	            if(user==null){
	                throw new RuntimeException("用户不存在："+task.getTransactor());
	            }else if(StringUtils.isEmpty(user.getEmail())){
	                throw new RuntimeException("用户邮件地址没有输入："+task.getTransactor());
	            }else{
	                AsyncMailUtils.sendMail(user.getEmail(), task.getTitle(),mailContent );
	            }
	        }
	    }catch (Exception e) {
	        e.printStackTrace();
            log.error(PropUtils.getExceptionInfo(e));
        }
	}
	
	private void setButtonName(TaskProcessingMode processModel,WorkflowTask task,Map<String,String > buttonNameSetting){
		if(TaskProcessingMode.TYPE_EDIT.equals(processModel)){
			task.setSubmitButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.SUBMIT_NAME),"提交"));
		}else if(TaskProcessingMode.TYPE_APPROVAL.equals(processModel)){
			task.setAgreeButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.APPROVE_NAME),"同意"));
			task.setDisagreeButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.REFUSE_NAME),"不同意"));
		}else if(TaskProcessingMode.TYPE_COUNTERSIGNATURE.equals(processModel)){
			task.setAgreeButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.APPROVE_NAME),"同意"));
			task.setDisagreeButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.REFUSE_NAME),"不同意"));
			task.setAddSignerButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.ADD_COUNTER_NAME),"加签"));
			task.setRemoveSignerButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.DEL_COUNTER_NAME),"减签"));
		}else if(TaskProcessingMode.TYPE_SIGNOFF.equals(processModel)){
			task.setSignForButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.SIGNOFF_NAME),"签收"));
		}else if(TaskProcessingMode.TYPE_VOTE.equals(processModel)){
			task.setApproveButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.AGREEMENT_NAME),"赞成"));
			task.setOpposeButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.OPPOSE_NAME),"反对"));
			task.setAbstainButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.KIKEN_NAME),"弃权"));
		}else if(TaskProcessingMode.TYPE_ASSIGN.equals(processModel)){
			task.setAbstainButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.ASSIGN_NAME),"交办"));
		}else if(TaskProcessingMode.TYPE_DISTRIBUTE.equals(processModel)){
			task.setSubmitButton(getButtonValue(buttonNameSetting.get(DefinitionXmlParse.SUBMIT_NAME),"提交"));
		}
	}
	/*
	 * 处理按钮名称，当是空时用默认的名字
	 */
	private String getButtonValue(String buttonValue,String initValue){
		if(StringUtils.isNotEmpty(buttonValue)){
			return buttonValue;
		}
		return initValue;
	}
	
	public String parseUserCondition(WorkflowTask task,String userCondition){
		Set<String> set = new HashSet<String>();
		StringBuilder builder = new StringBuilder();
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		WorkflowDefinition definition = workflowDefinitionManager.getWfDefinition(instance.getWorkflowDefinitionId());
		FormView form = formViewManager.getFormView(instance.getFormId());
		UserParseCalculator upc = new UserParseCalculator();
		upc.setDataId(instance.getDataId());
		upc.setFormView(form);
		upc.setDocumentCreator(instance.getCreator());
		upc.setCurrentTransactor(task.getTransactor());
		upc.setProcessAdmin(definition.getAdminLoginName());
		set.addAll(upc.getUsers(userCondition,instance.getSystemId(),instance.getCompanyId()));
		for(String str:set){
			builder.append(str).append(",");
		}
		return  StringUtils.removeEnd(builder.toString(), ",");
	}
	/*
	 *创建特事特办任务
	 */
	@Transactional(readOnly=false)
	private WorkflowTask createSpecialTask(WorkflowInstance workflow,String executionId,String transactor,String taskName,String title){
		String delegateTransactor = delegateManager.getDelegateMainName(
				workflow.getCompanyId(), transactor,workflow.getProcessDefinitionId() , taskName);
		boolean moreTransactor = DefinitionXmlParse.hasMoreTransactor(
				workflow.getProcessDefinitionId(), taskName);
		 boolean shouldSaveTask =  shouldSaveTask(workflow.getCompanyId(),transactor,null,workflow.getProcessInstanceId(),delegateTransactor,moreTransactor);
		 if(title==null) title = taskName;
		 final String processId = workflow.getProcessDefinitionId();
		 WorkflowTask task = new WorkflowTask();
		 task.setCompanyId(workflow.getCompanyId());
		 task.setProcessInstanceId(workflow.getProcessInstanceId());
		 task.setExecutionId(executionId);
		 log.info("taskService 设置办理人"+transactor);
		 task.setTransactor(transactor);
		 User user = userManager.getUserByLoginName(task.getTransactor());
		 if(user!=null){
			 task.setTransactorName(user.getName());
		 }
		 task.setName(taskName);
		 String code = DefinitionXmlParse.getTacheCode(processId, task.getName());
		 task.setCode(code);
		 task.setCreatedTime(new Date());
		 Object obj = processEngine.getExecutionService().getVariable(executionId, "creator");
		 if(obj != null){
			 user = userManager.getUserByLoginName(obj.toString());
			 task.setCreator(obj.toString());
			 task.setCreatorName(user.getName());
		 }
		 task.setTitle(title);
		 String processingMode = DefinitionXmlParse.getTaskProcessingMode(
				 processId, taskName);
		 log.debug("办理模式："+processingMode);
		 log.debug("是否多人办理："+moreTransactor);
		 task.setProcessingMode(TaskProcessingMode.getTaskModeFromStringToEnum(processingMode));
		 task.setMoreTransactor(moreTransactor);
		 task.setActive(TaskState.WAIT_TRANSACT.getIndex());
		 task.setUrl(getTaskUrl(processId));
		 task.setRead(false);
		 task.setSendingMessage(true);
		 task.setSpecialTask(true);
		 WorkflowDefinition wfDef = workflowDefinitionManager.getWorkflowDefinitionByProcessId(processId);
		 task.setGroupName(wfDef.getName());
		 if(delegateTransactor != null){
			 task.setTrustor(task.getTransactor());
			 task.setTransactor(delegateTransactor);
			 user = userManager.getUserByLoginName(task.getTransactor());
			 if(user!=null){
				 task.setTransactorName(user.getName());
			 }
			 //生成委托流转历史
			 generateDelegateHistory(task);
		 }
		//是否显示，bkyoa特制功能
		 task.setVisible(shouldSaveTask);
		 return task;
	}
	
	/*
	 * 解析标题表达式
	 */
	@SuppressWarnings("unchecked")
	private String parseTitleExpression(String expression ,WorkflowInstance workflow,String titleInfo){
		if(StringUtils.isEmpty(expression)) return null;
		Long dataId=null;
		if(workflow==null) return null;
		FormView form = formViewManager.getFormView(workflow.getFormId());
		if(form==null){log.debug("解析标题表达式时，表单不能为null");throw new RuntimeException("解析标题表达式时，表单不能为null");}
		Map dataMap = null;
		Object entity = null;
		if(workflow.getDataId()!=null){
			dataId=workflow.getDataId();
		}else{
			dataId=processEngine.getExecutionService().getVariable(workflow.getProcessInstanceId(), CommonStrings.FORM_DATA_ID)==null?null:(Long)processEngine.getExecutionService().getVariable(workflow.getProcessInstanceId(), CommonStrings.FORM_DATA_ID);
			//去变量
		}
		if(dataId==null)return null;
		boolean isSql=true;
		if(form.getDataTable()==null){log.debug("解析标题表达式时，表单对应的数据表不能为null");}
		if(!form.isStandardForm()){
			//自定义表单
			dataMap = formViewManager.getDataMap(form.getDataTable().getName(), dataId);
		}else if(form.isStandardForm()){
			//标准表单
			try{
				Class.forName(form.getDataTable().getEntityName());//判断是否
				entity = this.generalDao.getObject(form.getDataTable().getEntityName(),dataId);
				isSql=false;
			}catch(ClassNotFoundException e){
				dataMap = formViewManager.getDataMap(form.getDataTable().getName(), dataId);
			}
		}
		
		StringBuilder title = new StringBuilder();
		expression = StringUtils.removeStart(expression, "${");
		expression = StringUtils.removeEnd(expression, "}");
		String[] subExpressions = expression.split("\\}\\$\\{");
		for(String subExpression:subExpressions){
			if(subExpression.startsWith("writeTitle")){
				title.append(subExpression.substring( subExpression.indexOf("[")+1, subExpression.lastIndexOf("]")));
			}else if(subExpression.startsWith("titleInfo")){
				if(StringUtils.isNotEmpty(titleInfo))title.append(titleInfo);
			}else if(subExpression.startsWith("field")){
				String field=subExpression.substring(subExpression.lastIndexOf("[")+1, subExpression.indexOf("]"));
				String enName = field;
				String dataType=null;
				String dbName=null;
				if(enName.contains(":")){
					enName=field.substring(0,field.indexOf(":"));
					String dataTypeAndDbName=field.substring(field.indexOf(":")+1);
					if(dataTypeAndDbName.contains(":")){
						dataType=dataTypeAndDbName.substring(0,dataTypeAndDbName.indexOf(":"));
						dbName=dataTypeAndDbName.substring(dataTypeAndDbName.indexOf(":")+1);
					}else{//兼容bkyoa xml
						dataType=dataTypeAndDbName;
						TableColumn column=tableColumnManager.getTableColumnByColName(form.getDataTable().getId(), enName);
						if(column!=null){
							dbName=column.getDbColumnName();
						}
					}
				}else{//兼容bkyoa xml
					TableColumn column=tableColumnManager.getTableColumnByColName(form.getDataTable().getId(), enName);
					if(column!=null){
						dataType=column.getDataType().getCode();
						dbName=column.getDbColumnName();
					}
				}
				if(isSql){
					Object value = null;
					if(!form.isStandardForm()){
						//自定义表单
						value = dataMap.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+enName);
					}else{
						//标准表单
						if(StringUtils.isNotEmpty(dbName))value = dataMap.get(dbName);
					}
					if(value==null)continue;
					if(dataType==null){
						title.append(value.toString());
						continue;
					}
					title.append(getSqlFormFieldValue(value.toString(),dataType));
				}else{
					//标准表单
					try {
						Object value=PropertyUtils.getProperty(entity, enName);
						if(value==null)continue;
						if(dataType==null){
							title.append(value.toString());
							continue;
						}
						title.append(getFormFieldValue(value,dataType));
					} catch (IllegalAccessException e) {
						log.debug(e.getMessage());
						throw new RuntimeException(e);
					} catch (InvocationTargetException e) {
						log.debug(e.getMessage());
						throw new RuntimeException(e);
					} catch (NoSuchMethodException e) {
						log.debug(e.getMessage());
						throw new RuntimeException(e);
					}
				}
				
			}
		}
		return title.toString();
	}
	
	private String getSqlFormFieldValue(String value,String dataType){
		if("DATE".equals(dataType)){
			value=value.split(" ")[0];
			return value;
		}else if("TIME".equals(dataType)){
			value=value.split(":")[0]+":"+value.split(":")[1];
			return value;
		}else{
			return value.toString();
		}
	}
	
	private String getFormFieldValue(Object value,String dataType){
		if("DATE".equals(dataType)){
			SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd");
			return format.format(value);
		}else if("TIME".equals(dataType)){
			SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm");
			return format.format(value);
		}else{
			return value.toString();
		}
	}
	
	/*
	 * 设置任务标题
	 */
	@Transactional(readOnly=false)
	public void addTitle(WorkflowTask task, String definitionId,String titleInfo){
		String value = DefinitionXmlParse.getTaskTitle(definitionId, task.getName());
		
		String title = "";
		if(StringUtils.isNotBlank(value)){
			WorkflowInstance workflow = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId(),task.getCompanyId());
			title = parseTitleExpression(value,workflow,titleInfo);
		}
		if(StringUtils.isNotBlank(title)){
			task.setTitle(title);
		}else{
			task.setTitle(task.getName());
		}
	}
	
	
	public String getTaskUrl(String processId){
		Map<String,String> parameterSetting = DefinitionXmlParse.getParameterSetting(processId);
		String doTaskUrl = parameterSetting.get(DefinitionXmlParse.DO_TASK_URL);
		Map<String, String> defBasicInfo=DefinitionXmlParse.getWorkFlowBaseInfo(processId);
		String parameterName = parameterSetting.get(DefinitionXmlParse.DO_TASK_URL_PARAMETER_NAME);
		if(StringUtils.isEmpty(doTaskUrl)){
			doTaskUrl = PropUtils.getProp(CommonStrings.WORKFLOW_PARAMETER_URL, CommonStrings.PROCESS_TASK_URL);
		}
		if(StringUtils.isEmpty(parameterName)){
			parameterName = PropUtils.getProp(CommonStrings.WORKFLOW_PARAMETER_URL, CommonStrings.PROCESS_TASK_PARAMTER_NAME);
		}
		if(StringUtils.isEmpty(doTaskUrl)){
			doTaskUrl = DEFAULT_DO_TASK_URL;
		}else{
			String joinSign = StringUtils.contains(doTaskUrl, "?") ? "&" : "?";
			doTaskUrl = doTaskUrl + joinSign + parameterName + "=";
		}
		String systemCode=defBasicInfo.get(DefinitionXmlParse.SYSTEM_CODE);
		String code=ContextUtils.getSystemCode();
		if(StringUtils.isNotEmpty(systemCode)){
			code=systemCode;
		}
		
		return code+doTaskUrl;
	}
	
	
	public List<WorkflowTask> getCompletedTasks(String workflowId){
		WorkflowInstance workflowInstance=workflowInstanceManager.getWorkflowInstance(workflowId);
		return workflowTaskService.getCompletedTasks( workflowId,workflowInstance.getCompanyId());
	}
	
	/**
	 * 流程实例能退回到的环节名称
	 * @param instanceId
	 * @return
	 */
	public List<String> canBackNames(String workflowId){
		List<String> result = new ArrayList<String>();
		WorkflowInstance workflowInstance=workflowInstanceManager.getWorkflowInstance(workflowId);
		if(workflowInstance==null){log.debug("获得流程实例能退回到的环节名称时,流程实例不能为null");throw new RuntimeException("获得流程实例能退回到的环节名称时,流程实例不能为null");}
		ProcessInstance instance = processEngine.getExecutionService().findProcessInstanceById(workflowId);
		//有并发不能退回
		if(instance==null || ((ExecutionImpl)instance).getSubProcessInstance() != null) 
			return result;
		List<WorkflowTask> tasks = workflowTaskService.getActivityTasks(workflowId, workflowInstance.getCompanyId());
		List<WorkflowTask> completedTasks = getCompletedTasks(workflowId);
		if((tasks != null && !tasks.isEmpty())||(tasks.size()==0&&workflowInstance.getProcessState()==ProcessState.END)){//当前不为并发
			for(WorkflowTask task: completedTasks){
				//排除同名和和当前环节的任务
				if(!result.contains(task.getName())&&!containTheSameTaskName(tasks,task.getName())) {
					result.add(task.getName());
				}
			}
		}
		return result;
	}
	private boolean containTheSameTaskName(List<WorkflowTask> tasks,String taskName){
		for(WorkflowTask task:tasks){
			if(task.getName().trim().equals(taskName.trim())) return true;
		}
		return false;
	}
	
	/**
	 * 退回到某环节
	 * @param instanceId
	 * @param backTo
	 */
	@Transactional(readOnly=false)
	public String goBack(String workflowId, String backTo){
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(workflowId);
		if(instance==null){log.debug("退回到某环节时，流程实例不能为null");throw new RuntimeException("退回到某环节时，流程实例不能为null");}
		List<WorkflowTask> needSaveTasks = new ArrayList<WorkflowTask>();
		List<WorkflowTask> tasks = workflowTaskService.getActivityTasks(workflowId, instance.getCompanyId());
		//取消所有当前的环节
		for(WorkflowTask task :tasks){
			if(!task.isSpecialTask()) {
				task.setActive(TaskState.CANCELLED.getIndex());
				task.setEffective(false);      //设置任务失效
				needSaveTasks.add(task);
				taskJumpHistoryProcess(workflowId, task, backTo);
			}
		}
		
		//得到所有已完成的任务
		List<WorkflowTask> completedTasks = getCompletedTasks(workflowId);
		List<WorkflowTask> backToTasks = new ArrayList<WorkflowTask>();
		for(WorkflowTask task:completedTasks){
			if(task.getName().trim().equals(backTo.trim())){
				backToTasks.add(task);
			}
		}
		//生成退回环节任务
		for(WorkflowTask task :getTaskNameFilter(backToTasks)){
			needSaveTasks.add(cloneTask(instance,task));
		}
		//将jbpm退回到backto环节
		processEngine.execute(new GetBackCommand(instance.getProcessInstanceId(), backTo));
		if(instance.getProcessState()==ProcessState.END){
			instance.setProcessState(ProcessState.SUBMIT);
			instance.setEndTime(null);
		}
		instance.setCurrentActivity(backTo);
		FormView form = formViewManager.getFormView(instance.getFormId());
		if(form==null){log.debug("退回到某环节时，流程对应的表单不能为null");throw new RuntimeException("退回到某环节时，流程对应的表单不能为null");}
		//如果表单是实体表单，同步实体的当前环节
		if(form.isStandardForm()){
			try {
				if(form.getDataTable()==null){log.debug("退回到某环节时，表单对应的数据表不能为null");throw new RuntimeException("退回到某环节时，表单对应的数据表不能为null");}
				if(form.getDataTable().getEntityName()==null){log.debug("退回到某环节时，表单对应的数据表的实体类名不能为null");throw new RuntimeException("退回到某环节时，表单对应的数据表的实体类名不能为null");}
				Object entity = generalDao.getObject(form.getDataTable().getEntityName(), instance.getDataId());
				BeanUtils.setProperty(entity, "workflowInfo.currentActivityName", backTo);
				generalDao.save(entity);
			} catch (IllegalAccessException e) {
				log.error("为bean设置属性异常:" + e.getMessage());
			} catch (InvocationTargetException e) {
				log.error("为bean设置属性异常:" +e.getMessage());
			}
		}
		workflowInstanceManager.saveWorkflowInstance(instance);
		this.saveTasks(needSaveTasks);
		return null;
	}
	private static final String LINK_SIGN = "-";
	private List<WorkflowTask> getTaskNameFilter(List<WorkflowTask> tasks){
		List<String> targetTasks = new ArrayList<String>(); 
		List<WorkflowTask> result = new ArrayList<WorkflowTask>();
		StringBuilder temp = new StringBuilder(); 
		for(WorkflowTask task :tasks){
			temp.append(task.getName()).append(LINK_SIGN).append(task.getTransactor());
			if(!task.isSpecialTask()&&!targetTasks.contains(temp.toString())){
				result.add(task);
				targetTasks.add(temp.toString());
			}
			temp.delete(0, temp.length());
		}
		return result;
	}
	private WorkflowTask cloneTask(WorkflowInstance instance,WorkflowTask task){
		WorkflowTask targetTask = task.clone();
		targetTask.setCreatedTime(new Date());
		targetTask.setId(null);
		targetTask.setActive(TaskState.WAIT_TRANSACT.getIndex());
		targetTask.setRead(false);
		targetTask.setTransactDate(null);
		targetTask.setTaskProcessingResult(null);
		targetTask.setSendingMessage(true);
		targetTask.setVisible(true);
		targetTask.setUrl(getTaskUrl(instance.getProcessDefinitionId()));
		return targetTask;
	}
	/*
	 * 退回流转历史处理
	 * @param instanceId
	 * @param currentTaskName
	 * @param historyNames
	 */
	@Transactional(readOnly=false)
	private void taskJumpHistoryProcess(String instanceId, WorkflowTask task, String currentTaskName){
		List<InstanceHistory> resultHistories = new ArrayList<InstanceHistory>(); 
		String historyMessage = new StringBuilder(dateFormat.format(new Date()))
			.append(COMMA).append(PROCESS_JUMPTASK).append(DELTA_START)
			.append(currentTaskName).append(DELTA_END).append("\n")
			.append(dateFormat.format(new Date())).append(COMMA).append(task.getTransactorName()).append(TASK_CANCEL).toString();
		//流程退回到
		InstanceHistory history = new InstanceHistory(task.getCompanyId(), instanceId, InstanceHistory.TYPE_TASK, historyMessage, task.getName());
		history.setEffective(false);
		history.setCreatedTime(new Date());
		history.setExecutionId(instanceId);
		resultHistories.add(history);
		
		historyMessage = new StringBuilder(dateFormat.format(new Date()))
			.append(COMMA).append(PROCESS_LEAVE).append(DELTA_START)
			.append(task.getName()).append(DELTA_END).toString();
		//流程离开
		history = new InstanceHistory(task.getCompanyId(), instanceId, InstanceHistory.TYPE_FLOW_LEAVE, historyMessage, task.getName());
		history.setCreatedTime(new Date());
		history.setExecutionId(instanceId);
		resultHistories.add(history);
		instanceHistoryManager.saveHistories(resultHistories);
		//流程进入
		generateFlowHistory(instanceId, instanceId, currentTaskName, PROCESS_ENTER);
	}
	
	/*
	 * 退回流转历史处理
	 * @param instanceId
	 * @param currentTaskName
	 * @param historyNames
	 */
	private void gobackTaskHistoryProcess(String instanceId, WorkflowTask task, String currentTaskName){
		List<InstanceHistory> resultHistories = new ArrayList<InstanceHistory>(); 
		String historyMessage = new StringBuilder(dateFormat.format(new Date()))
			.append(COMMA).append(PROCESS_GOBACKTASK).append(DELTA_START)
			.append(currentTaskName).append(DELTA_END).append("\n")
			.append(dateFormat.format(new Date())).append(COMMA).append(task.getTransactorName()).append(TASK_BACK).toString();
		//流程退回到
		InstanceHistory history = new InstanceHistory(task.getCompanyId(), instanceId, InstanceHistory.TYPE_TASK, historyMessage, task.getName());
		history.setEffective(false);
		history.setCreatedTime(new Date());
		history.setExecutionId(instanceId);
		resultHistories.add(history);
		
		historyMessage = new StringBuilder(dateFormat.format(new Date()))
			.append(COMMA).append(PROCESS_LEAVE).append(DELTA_START)
			.append(task.getName()).append(DELTA_END).toString();
		//流程离开
		history = new InstanceHistory(task.getCompanyId(), instanceId, InstanceHistory.TYPE_FLOW_LEAVE, historyMessage, task.getName());
		history.setCreatedTime(new Date());
		history.setExecutionId(instanceId);
		resultHistories.add(history);
		instanceHistoryManager.saveHistories(resultHistories);
		
		//流程进入
		generateFlowHistory(instanceId, instanceId, currentTaskName, PROCESS_ENTER);
	}
	
	
	/**
	 * 完成任务
	 * @param taskId
	 * @param operation
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeWorkflowTask(Long taskId, TaskProcessingResult operation,TaskSetting setting){
		WorkflowTask task = getTask(taskId);
		return completeWorkflowTask(task, operation,setting);
	}
	/**
	 * 完成任务
	 * @param task
	 * @param operation
	 * @param isCreateSpecialTask
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeWorkflowTask(WorkflowTask task, TaskProcessingResult operation,TaskSetting setting){
		return complete(task,operation,setting);
	}
	
	/**
	 * 完成任务
	 * @param task
	 * @param operation
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeWorkflowTaskAndSaveData(WorkflowTask task, TaskProcessingResult operation,TaskSetting setting){
		workflowInstanceManager.saveData(task, null);
		return completeWorkflowTask(task,operation,setting);
	}
	
	/**
	 * 完成任务
	 * @param task
	 * @param operation
	 * @param isCreateSpecialTask
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeWorkflowTask(WorkflowTask task, TaskProcessingResult operation){
		Assert.notNull(task,"task任务不能为null");
		return complete(task,operation,TaskSetting.getTaskSettingInstance());
	}
	/**
	 * 完成交互的任务
	 * @param task
	 * @param operation
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeInteractiveWorkflowTask(Long taskId){
		WorkflowTask task = getTask(taskId);
		return completeInteractiveWorkflowTask(task);
	}
	
	/**
	 * 完成交互的任务
	 * @param task
	 * @param operation
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeInteractiveWorkflowTask(WorkflowTask task ){
		return completeInteractiveWorkflowTask(task,TaskSetting.getTaskSettingInstance());
	}
	/**
	 * 完成交互的任务
	 * @param task
	 * @param operation
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeInteractiveWorkflowTask(WorkflowTask task, TaskSetting setting){
		return complete(task,task.getTaskProcessingResult(),setting.setReturnUrl(false));
	}
	
	
	
	
	/**
	 * 完成交互的任务
	 * @param task
	 * @param operation
	 * @param transcators 下一环节办理人
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeInteractiveWorkflowTask(Long taskId, String allOriginalUsers,String... transcators){
		WorkflowTask task = getTask(taskId);
		return completeInteractiveWorkflowTask(task,allOriginalUsers,transcators);
	}
	/**
	 * 完成交互的任务
	 * @param task
	 * @param allOriginalUsers 原办理人
	 * @param transcators 下一环节办理人
	 * @return
	 */

	@Transactional(readOnly=false)
	public CompleteTaskTipType completeInteractiveWorkflowTask(WorkflowTask task,String allOriginalUsers, String... transcators){
		return completeInteractiveWorkflowTask(task,Arrays.asList(transcators),allOriginalUsers);
	}
	
	
	/**
	 * 完成交互的任务
	 * @param task
	 * @param operation
	 * @param transcators 下一环节办理人
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeInteractiveWorkflowTask(Long taskId, Collection<String> transcators,String allOriginalUsers ){
		WorkflowTask task = getTask(taskId);
		return completeInteractiveWorkflowTask(task,transcators,allOriginalUsers);
	}
	
		
	/**
	 * 完成交互的任务(调用)
	 * @param task
	 * @param operation
	 * @param transcators 下一环节办理人
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeInteractiveWorkflowTask(WorkflowTask task, Collection<String> transcators,String allOriginalUsers){
		return completeInteractiveWorkflowTask(task, transcators,TaskSetting.getTaskSettingInstance().setAllOriginalUsers(allOriginalUsers));
	}
	
	/**
	 * 完成交互的任务(调用)
	 * @param task
	 * @param operation
	 * @param transcators 下一环节办理人
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeInteractiveWorkflowTask(WorkflowTask task,TaskSetting setting, String... transcators){
		return completeInteractiveWorkflowTask(task,Arrays.asList(transcators),setting);
	}
	/**
	 * 完成交互的任务
	 * @param task
	 * @param operation
	 * @param transcators 下一环节办理人
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeInteractiveWorkflowTask(WorkflowTask task, Collection<String> transcators,TaskSetting setting){
		log.debug(PropUtils.LOG_METHOD_BEGIN+"完成任务,TaskService+completeInteractiveWorkflowTask(WorkflowTask task, Collection<String> transcators,TaskSetting setting)"+PropUtils.LOG_FLAG);
		//当线程1执行到put，线程2执行到get判断是否为null时，会出现value值不为同一对象的问题，如果此处不加锁，会影响下面的锁【synchronized (instanceIds.get(task.getProcessInstanceId()))】失败，所以要在此处以TaskService对象加锁。
		synchronized(this){
			//将实例id放入map中，用于同步处理时调用
			if(instanceIds.get(task.getProcessInstanceId())==null){
				instanceIds.put(task.getProcessInstanceId(), task.getProcessInstanceId());
			}
		}
		//以实例id为锁，只锁定完成同一个实例的不同任务的线程，如果锁定整个方法会导致所有的任务均变慢（包括不同实例的任务）
		synchronized (instanceIds.get(task.getProcessInstanceId())) {
			String bkySpecial=PropUtils.getProp("bky.special");
			if("true".equals(bkySpecial)){//是否是bky特制的功能,当受托人和委托人是同一部门时不生成委托任务
				if(task.getMoreTransactor()){//是多人办理环节才需自动完成该办理人的其他未显示的委托任务
					//根据办理人查待办理的委托任务
					List<WorkflowTask> tasks = workflowTaskService.getActivityTrustorTasksByTransactor(task.getProcessInstanceId(), task.getTransactor(),task.getId());
					for(WorkflowTask wt:tasks){
						complete(wt,task.getTaskProcessingResult(),setting.setReturnUrl(false));
					}
				}
			}
			//完成自己当前的任务
			CompleteTaskTipType completeTaskTipType = complete(task,task.getTaskProcessingResult(),setting.setReturnUrl(false));
			Execution exec=processEngine.getExecutionService().findExecutionById(task.getExecutionId());
			log.debug(PropUtils.LOG_CONTENT+"processEngine.getExecutionService().findExecutionById(task.getExecutionId())"+PropUtils.LOG_FLAG+exec);
			if(exec!=null){
				Object assign=processEngine.getExecutionService().getVariable(task.getExecutionId(), CommonStrings.TRANSACTOR_ASSIGNMENT);
				log.debug(PropUtils.LOG_CONTENT+"指定的办理人"+PropUtils.LOG_FLAG+assign);
				if(assign!=null && PRE_TRANSACTOR_ASSIGN.equals(assign.toString())){//子流程/上一环节办理人指定时
					SubProcessParse subprocessParse=(SubProcessParse)processEngine.getExecutionService().getVariable(task.getExecutionId(),CommonStrings.SUBPROCESS_PARSE);
					ActivityExecution execution=(ActivityExecution)processEngine.getExecutionService().findExecutionById(subprocessParse.getExecutionId());
					execution.removeVariable(CommonStrings.TRANSACTOR_ASSIGNMENT);
					execution.removeVariable(CommonStrings.SUBPROCESS_PARSE);
					completeTask(task);
					Map<TaskTransactorCondition, String> transactor = DefinitionXmlParse.getTaskTransactor(subprocessParse.getParentDefinitionId(),subprocessParse.getActivityName());
					log.debug(PropUtils.LOG_CONTENT+"发起子流程开始"+PropUtils.LOG_FLAG);
					this.startSubProcessWorkflow(transactor, subprocessParse,transcators);
					log.debug(PropUtils.LOG_CONTENT+"发起子流程结束"+PropUtils.LOG_FLAG);
					log.debug(PropUtils.LOG_CONTENT+"完成任务返回值"+PropUtils.LOG_FLAG+completeTaskTipType);
					log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completeInteractiveWorkflowTask(WorkflowTask task, Collection<String> transcators,TaskSetting setting)"+PropUtils.LOG_FLAG);
					return CompleteTaskTipType.OK.setContent("子流程已创建");
				}else{
					if(completeTaskTipType==CompleteTaskTipType.RETURN_URL||completeTaskTipType==CompleteTaskTipType.SINGLE_TRANSACTOR_CHOICE) {
						this.setTasksTransactor(task, transcators);
						return CompleteTaskTipType.OK.setContent("办理人已指定");
					}
					log.debug(PropUtils.LOG_CONTENT+"完成任务返回值"+PropUtils.LOG_FLAG+completeTaskTipType);
					log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completeInteractiveWorkflowTask(WorkflowTask task, Collection<String> transcators,TaskSetting setting)"+PropUtils.LOG_FLAG);
					return completeTaskTipType;
				}
			}else{
				log.debug(PropUtils.LOG_CONTENT+"完成任务返回值"+PropUtils.LOG_FLAG+completeTaskTipType);
				log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completeInteractiveWorkflowTask(WorkflowTask task, Collection<String> transcators,TaskSetting setting)"+PropUtils.LOG_FLAG);
				return completeTaskTipType;
			}
		}
	}
	
	@Transactional(readOnly=false)
	  public CompleteTaskTipType assignTask(Long taskId, String transcator)
	  {
		WorkflowTask task = getTask(taskId);
    	//被指派人的新任务
    	WorkflowTask targetTask = task.clone();
    	//设置指派人任务已完成
    	task.setTaskProcessingResult(null);
    	task.setActive(TaskState.ASSIGNED.getIndex());
    	task.setTransactDate(new Date());
    	task.setNextTasks("assign to:" + transcator);
    	//新任务办理人
    	targetTask.setId(null);
		targetTask.setTransactor(transcator);
		User user = userManager.getUserByLoginName(transcator);
		if(user!=null){
			targetTask.setTransactorName(user.getName());
		}
    	targetTask.setRead(false);
    	List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
    	tasks.add(task);
    	tasks.add(targetTask);
    	saveTasks(tasks);
	    generateAssignTaskHistory(task, targetTask.getTransactorName());
	    this.log.debug("*** assignTask 方法结束");
	    return CompleteTaskTipType.ASSIGN_TASK;
	  }
	@Deprecated
	@Transactional(readOnly=false)
	  public CompleteTaskTipType assignTask(Long taskId, Collection<String> transactors)
	  {
		WorkflowTask task = getTask(taskId);
    	//被指派人的新任务
    	WorkflowTask targetTask = task.clone();
    	//设置指派人任务已完成
    	task.setTaskProcessingResult(null);
    	task.setActive(TaskState.ASSIGNED.getIndex());
    	task.setTransactDate(new Date());
    	task.setNextTasks("assign to:" + transactors);
    	//新任务办理人
    	targetTask.setId(null);
    	for(String transactor:transactors){
    		targetTask.setTransactor(transactor);
    		User user = userManager.getUserByLoginName(transactor);
    		if(user!=null){
    			targetTask.setTransactorName(user.getName());
    		}
    	}
    	targetTask.setRead(false);
    	List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
    	tasks.add(task);
    	tasks.add(targetTask);
    	saveTasks(tasks);
	      generateAssignTaskHistory(task, targetTask.getTransactorName());
	      this.log.debug("*** assignTask 方法结束");
	      return CompleteTaskTipType.ASSIGN_TASK;
	  }

	@Transactional(readOnly=false)
	  private void generateAssignTaskHistory(WorkflowTask task,String transcator)
	  {
	    InstanceHistory ih = new InstanceHistory();
	    ih.setCompanyId(task.getCompanyId());
	    ih.setType(InstanceHistory.TYPE_TASK);
	    ih.setInstanceId(task.getProcessInstanceId());
	    ih.setExecutionId(task.getExecutionId());
	    ih.setTaskName(task.getName());
	    ih.setTaskId(task.getId());
	    ih.setCreatedTime(new Date());
	    ih.setSpecialTask(task.isSpecialTask());
	    StringBuilder msg = new StringBuilder();
	    msg.append(dateFormat.format(ih.getCreatedTime())).append
	      (", ").append(ContextUtils.getUserName()).append("指派给了[").append
	      (transcator.replace("[", "").replace("]", "")).append("]");
	    ih.setTransactionResult(msg.toString());
	    ih.setTransactor(ContextUtils.getUserName() + "[ " + task.getTransactor() + " ]");
	    instanceHistoryManager.saveHistory(ih);
	  }
	private static final String AND = "&&";
	private static final String OR = "||";
	private boolean parseCondition(String express,TaskProcessingResult operation,UserParseCalculator upc){
		//${user} operator.text.et '吴荣[wurong]' condition.operator.and ${department} operator.text.et 'EIT业务部' condition.operator.and ${role} operator.text.et '普通员工'
			if(StringUtils.isEmpty(express)) return false;
			if(express.trim().equalsIgnoreCase("true")) return true;
			String temp = express;
			String[] strs = BeanShellUtil.splitExpression(express);
			log.info("分割后的原子表达式为：" + Arrays.toString(strs));
			
			Boolean result = false;
			for(int i=0;i<strs.length;i++){
				log.info("开始分析原子表达式：" + strs[i]);
				result = computeAtomicExpression(strs[i],operation,upc);
				log.info("原子表达式：" + strs[i] + "的分析结果为 " + result);
				temp = StringUtils.replace(temp, strs[i].trim(), result.toString());
				log.info("将原子表达式替换为它的结果后：" + temp );
			}
			temp = temp.replaceAll(LogicOperator.AND.getCode(), AND);
			temp = temp.replaceAll(LogicOperator.OR.getCode(), OR);
			log.info("最终该流向的表达式为：" + temp);
			boolean expressResult = BeanShellUtil.evel(temp);
			return expressResult;
	}
	private boolean computeAtomicExpression(String atomicExpress,TaskProcessingResult operation,UserParseCalculator upc){
		if(StringUtils.isEmpty(atomicExpress)) return false;
		boolean result = false;
		atomicExpress = atomicExpress.trim();
		if(StringUtils.contains(atomicExpress, CommonStrings.DOCUMENT_CREATOR_NAME)
			||StringUtils.contains(atomicExpress, CommonStrings.DOCUMENT_CREATOR_ROLE)
			||StringUtils.contains(atomicExpress, CommonStrings.DOCUMENT_CREATOR_DEPARTMENT)
			||StringUtils.contains(atomicExpress, CommonStrings.DOCUMENT_SUPERIOR_DEPARTMENT)
			||StringUtils.contains(atomicExpress, CommonStrings.DOCUMENT_CREATOR_UPSTAGE_DEPARTMENT)
			||StringUtils.contains(atomicExpress, CommonStrings.DOCUMENT_CREATOR_WORKGROUP)
			||StringUtils.contains(atomicExpress, CommonStrings.CURRENT_TRANSACTOR_NAME)
			||StringUtils.contains(atomicExpress, CommonStrings.CURRENT_TRANSACTOR_ROLE)
			||StringUtils.contains(atomicExpress, CommonStrings.CURRENT_TRANSACTOR_DEPARTMENT)
			||StringUtils.contains(atomicExpress, CommonStrings.CURRENT_TRANSACTOR_SUPERIOR_DEPARTMENT)
			||StringUtils.contains(atomicExpress, CommonStrings.CURRENT_TRANSACTOR_UPSTAGE_DEPARTMENT)
			||StringUtils.contains(atomicExpress, CommonStrings.CURRENT_TRANSACTOR_WORKGROUP)
			||StringUtils.contains(atomicExpress, CommonStrings.PREVIOUS_TRANSACTOR_NAME)
			||StringUtils.contains(atomicExpress, CommonStrings.PREVIOUS_TRANSACTOR_ROLE)
			||StringUtils.contains(atomicExpress, CommonStrings.PREVIOUS_TRANSACTOR_DEPARTMENT)
			||StringUtils.contains(atomicExpress, CommonStrings.PREVIOUS_TRANSACTOR_SUPERIOR_DEPARTMENT)
			||StringUtils.contains(atomicExpress, CommonStrings.PREVIOUS_TRANSACTOR_UPSTAGE_DEPARTMENT)
			||StringUtils.contains(atomicExpress, CommonStrings.PREVIOUS_TRANSACTOR_WORKGROUP)){
			result = upc.execute(atomicExpress);
		}else if(StringUtils.contains(atomicExpress, CommonStrings.APPROVAL_RESULT)){
			result = BeanShellUtil.execute(atomicExpress,DataType.TEXT,CommonStrings.APPROVAL_RESULT,operation.getName());
		}else{
			if(upc.getFormView().isStandardForm()){
				log.info("标准表单");
				//标准表单的处理
				
				//根据表单id获得对应的类
				String className = upc.getFormView().getDataTable().getEntityName();
				log.info("实体类名：" + className);
				//根据表名和id获得实体
				Object entity = generalDao.getObject(className, upc.getDataId());
				log.info("查询得到的实体:" + entity);
				String name = StringUtils.substringBetween(atomicExpress, SQUARE_BRACKETS_LEFT, SQUARE_BRACKETS_RIGHT);
				log.info("字段名：" + name);
				FormControl field = getFormControl(name,upc.getFormView());
				log.info("对应字段为：" + field);
				try {
					Object value = BeanUtils.getProperty(entity, name);
					if(value==null) throw new RuntimeException("Field:"+field.getTitle()+" no value.");
					log.info("自动对应的值" + value.toString());
					result = BeanShellUtil.execute(atomicExpress,field.getDataType(),field.getTitle()+SQUARE_BRACKETS_LEFT+name+SQUARE_BRACKETS_RIGHT,value.toString());
					log.info("判断结果为：" + result);
				} catch (Exception e) {
					throw new RuntimeException(e);
				} 
				
			}else if(!upc.getFormView().isStandardForm()){
				log.info("自定义表单处理");
			//自定义表单的处理
				//根据表单id获得对应的表名
				String tableName = upc.getFormView().getDataTable().getName();
				log.info("表名：" + tableName);
				log.info("数据ID：" + upc.getDataId());
				//根据表名和id获得对应记录数据封装的MAP
				Map dataMap = formViewManager.getDataMap(tableName,upc.getDataId());
				log.info("数据map：" + dataMap);
				String ch_name = StringUtils.substringBefore(atomicExpress, SQUARE_BRACKETS_LEFT);
				String name =StringUtils.substringBetween(atomicExpress, SQUARE_BRACKETS_LEFT, SQUARE_BRACKETS_RIGHT);
				FormControl field = getFormControl(name,upc.getFormView());
				String value = "";
				if(dataMap.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+name)==null){
						if(field.getDataType()==DataType.AMOUNT||field.getDataType()==DataType.NUMBER){
							value = "0";
						}else if(field.getDataType().equals(DataType.DATE.toString())||field.getDataType().equals(DataType.TIME.toString())){
							if(dataMap.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+name)==null) throw new RuntimeException("Field:"+ch_name+" no value.");
						}
				}else{
					value = dataMap.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+name).toString();
				}
				log.info("对应值为：" + value);
				result = BeanShellUtil.execute(atomicExpress,field.getDataType(),ch_name + SQUARE_BRACKETS_LEFT+name+SQUARE_BRACKETS_RIGHT,value);
				log.info("判断结果为：" + result);
			}
		}
		return result;
	}
	
	private FormControl getFormControl(String name,FormView form){
		List<FormControl> fields = formViewManager.getControls(form.getId());
		for(FormControl formControl : fields){
			if(formControl.getName().equals(name)) return formControl;
		}
		return null;
	}
	
	/**
	 * 完成自由流的任务
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeCustomProcess(Long taskId,TaskProcessingResult operation,TaskSetting setting){
		return this.completeCustomProcess(this.getTask(taskId), operation, setting);
	}
	/**
	 * 完成自由流的任务
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeCustomProcess(WorkflowTask task,TaskProcessingResult operation,TaskSetting setting){
		task.setActive(TaskState.COMPLETED.getIndex());
		task.setTaskProcessingResult(operation);
		task.setTransactDate(new Date());
		this.saveTask(task);
		return CompleteTaskTipType.OK.setContent("已完成");
	}
	
	/*
	 *@param isReturnUrl 是否执行返回url
	 */
	@Transactional(readOnly=false)
	private CompleteTaskTipType complete(WorkflowTask task, TaskProcessingResult operation,TaskSetting setting){
		if(task==null){log.debug("complete中，task任务不能为null");throw new RuntimeException("complete中，task任务不能为null");}
		log.debug(PropUtils.LOG_METHOD_BEGIN+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
		log.debug(PropUtils.LOG_CONTENT+"当前任务"+PropUtils.LOG_FLAG+task);
		log.debug(PropUtils.LOG_CONTENT+"当前操作"+PropUtils.LOG_FLAG+operation);
		log.debug(PropUtils.LOG_CONTENT+"任务设置的信息TaskSetting"+PropUtils.LOG_FLAG+setting);
		if(!task.getTransactor().equals(ContextUtils.getLoginName())){
			log.debug(PropUtils.LOG_CONTENT+"当前登录名和当前任务办理人不同。当前登录名为"+ContextUtils.getLoginName()+",当前任务办理人为"+task.getTransactor()+PropUtils.LOG_FLAG);
			log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
			return CompleteTaskTipType.MESSAGE.setContent("当前登录名和当前任务办理人不同");
		}
		CompleteTaskTipType result = null;
		if(task.getActive().equals(TaskState.CANCELLED.getIndex())){
			log.debug(PropUtils.LOG_CONTENT+"该任务已失效"+PropUtils.LOG_FLAG);
			log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
			return CompleteTaskTipType.MESSAGE.setContent("该任务已失效！");
		}
		if(task.getActive().equals(TaskState.COMPLETED.getIndex())){
			log.debug(PropUtils.LOG_CONTENT+"该任务已完成"+PropUtils.LOG_FLAG);
			log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
			return CompleteTaskTipType.MESSAGE.setContent("该任务已完成！");
		}
		if(task.getActive().equals(TaskState.ASSIGNED.getIndex())){
			log.debug(PropUtils.LOG_CONTENT+"该任务已指派"+PropUtils.LOG_FLAG);
			log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
			return CompleteTaskTipType.MESSAGE.setContent("该任务已指派！");
		}
		if(task.getActive().equals(TaskState.HAS_DRAW_OTHER.getIndex())){
			log.debug(PropUtils.LOG_CONTENT+"该任务他人已领取"+PropUtils.LOG_FLAG);
			log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
			return CompleteTaskTipType.MESSAGE.setContent("该任务他人已领取！");
		}
		if(operation!=null){
			task.setTaskProcessingResult(operation);
			this.saveTask(task);
		}
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		if(instance==null){
			log.debug("流程实例不能为null");
			throw new RuntimeException("流程实例不能为null");
		}
		//阅办环节,不影响流程流转
		if(TaskProcessingMode.TYPE_READ.equals(task.getProcessingMode())){
			log.debug(PropUtils.LOG_CONTENT+"任务为阅办环节"+PropUtils.LOG_FLAG);
			log.debug(PropUtils.LOG_CONTENT+"任务信息"+PropUtils.LOG_FLAG+task.getTransactor()+"的任务："+task.getName()+"为阅办环节,当前已阅完");
			task.setTaskProcessingResult(operation);
			task.setTransactDate(new Date());
			task.setActive(TaskState.COMPLETED.getIndex());
			this.saveTask(task);
			//人工环节历史记录
    		generateTaskHistory(task, operation);
    		log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
			return CompleteTaskTipType.OK.setContent("已阅完");
		}
		if(instance!=null){
			log.debug(PropUtils.LOG_CONTENT+"当前任务对应的实例ID"+PropUtils.LOG_FLAG+instance.getProcessInstanceId());
			log.debug(PropUtils.LOG_CONTENT+"当前任务对应的实例"+PropUtils.LOG_FLAG+instance);
			processEngine.getExecutionService().setVariable(task.getExecutionId(), CommonStrings.PRIORITY, instance.getPriority());
		}
		if( instance.getFirstTaskId()==null){
			//主要用于第一环节任务需要领取时，一般出现在子流程中
			instance.setCreator(task.getCreator());
			instance.setCreatorName(task.getCreatorName());
			instance.setFirstTaskId(task.getId());
			workflowInstanceManager.saveWorkflowInstance(instance);
			executionVariableCommand(new ExecutionVariableCommand(task.getExecutionId(),CommonStrings.CREATOR,task.getCreator()));
		}
		
		
		if((result=isNeedChoiceTache(task))!=null){
			log.debug(PropUtils.LOG_CONTENT+"需要选择环节result"+PropUtils.LOG_FLAG+task.getTransactor()+"的任务："+task.getName()+"需要选择环节。可选择的环节个数为:"+result.getCanChoiceTaches().size());
			log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
			return result;
		}
		//办理前是否需要指定办理人
		result = getBeforeTaskSubmitUrl(task,operation,setting);
		log.debug(PropUtils.LOG_CONTENT+"办理前是否需要指定办理人result"+PropUtils.LOG_FLAG+result);
		if(result!=null){
			log.debug(PropUtils.LOG_CONTENT+"办理前需要指定办理人的信息"+PropUtils.LOG_FLAG+task.getTransactor()+"的任务："+task.getName()+"在提交前需要返回url。方法返回url为:"+result.getContent());
			log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
			return result;
		}
		result=isNeedAssigningTransactor(instance,task);
		log.debug(PropUtils.LOG_CONTENT+"环节是否需要指定办理人result"+PropUtils.LOG_FLAG+result);
		if(result!=null){
			log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
    		return result;
		}
		//办理前执行事件处理
		result = beforSubmit(task,operation);
		log.debug(PropUtils.LOG_CONTENT+"办理前执行事件处理result"+PropUtils.LOG_FLAG+result);
		if(result!=null){
			log.debug(PropUtils.LOG_CONTENT+"办理前执行事件处理信息"+PropUtils.LOG_FLAG+task.getTransactor()+"的任务："+task.getName()+"在提交前执行出错。方法返回信息为:"+result.getContent());
			log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
			return result;
		}
		//人工环节任务历史 
    	if(operation != null){
    		executionVariableCommand(new ExecutionVariableCommand(task.getExecutionId(),CommonStrings.ALL_ORIGINAL_USERS,setting.getAllOriginalUsers()));
    		task.setTaskProcessingResult(operation);
    		//自动填写域
			log.debug(PropUtils.LOG_CONTENT+"办理后自动填写域开始..."+PropUtils.LOG_FLAG);
			saveAutomaticallyFilledField(task.getProcessInstanceId(),task.getName(), Struts2Utils.getText(operation.getName()));
			log.debug(PropUtils.LOG_CONTENT+"办理后自动填写域结束..."+PropUtils.LOG_FLAG);
			result=executionCompanyTask(task, operation,setting);
			return result;
    	}else{
    		log.debug(PropUtils.LOG_CONTENT+"请在完成任务时，传入办理任务时执行的操作"+PropUtils.LOG_FLAG);
    		log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+completecomplete(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
    		return CompleteTaskTipType.MESSAGE.setContent("请在完成任务时，传入办理任务时执行的操作");
    	}
    	
	}
	
	/*
	 *执行任务提交前事件 
	 */
	@Transactional(readOnly=false)
	private CompleteTaskTipType beforSubmit(WorkflowTask task, TaskProcessingResult operation){
		Assert.notNull(task,"task任务不能为null");
		WorkflowInstance wi = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		if(wi==null){
			log.debug("流程实例不能为null");
			throw new RuntimeException("流程实例不能为null");
		}
		String beanName = DefinitionXmlParse.getBeforeTaskSubmitImpClassName(wi.getProcessDefinitionId(), task.getName());
		if(StringUtils.isNotEmpty(beanName)){
			BeforeTaskSubmit obj = (BeforeTaskSubmit) ContextUtils.getBean(beanName);
			if(obj==null){log.debug("执行任务提交前事件 时,bean不能为null"); throw new RuntimeException("执行任务提交前事件 时,bean不能为null");}
			boolean result = obj.execute(wi.getDataId(),operation);
			if(!result){
				return CompleteTaskTipType.MESSAGE.setContent(DefinitionXmlParse.getBeforeTaskSubmitResultMessage(wi.getProcessDefinitionId(), task.getName()));
			}
		}
		return null;
	}
	/*
	 * 检查办理任务前，是否需要返回用户设定的url
	 */
	@Transactional(readOnly=false)
	private CompleteTaskTipType getBeforeTaskSubmitUrl(WorkflowTask task,TaskProcessingResult operation,TaskSetting setting){
		Assert.notNull(task,"任务不能为null");
		WorkflowInstance wi = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		if(setting.isReturnUrl()){
			List<String[]> urls = DefinitionXmlParse.getBeforeTaskSubmitUrl(wi.getProcessDefinitionId(), task.getName());
			if(urls!=null){
				Assert.notNull(wi.getFormId(),"表单id不能为null");
				FormView form = formViewManager.getFormView(wi.getFormId());
				if(form==null){
					log.debug("FormView表单不能为null");
					throw new RuntimeException("FormView表单不能为null");
				}
				UserParseCalculator upc = new UserParseCalculator();
				upc.setDataId(wi.getDataId());
				upc.setFormView(form);
				upc.setDocumentCreator(wi.getCreator());
				if(StringUtils.isEmpty(task.getTrustor())){
					upc.setCurrentTransactor(task.getTransactor());
				}else{//当是委托任务时，当前办理人为委托人
					String delegateTransactor = delegateManager.getDelegateMainName(
							task.getCompanyId(), task.getTrustor(),wi.getProcessDefinitionId() , task.getName());
					if(StringUtils.isNotEmpty(delegateTransactor)&&delegateTransactor.equals(task.getTransactor())){
						upc.setCurrentTransactor(task.getTrustor());
					}else{
						task.setTrustor(null);
						task.setTrustorName(null);
						upc.setCurrentTransactor(task.getTransactor());
					}
				}
				for(String[] urlArray:urls){
					if(parseCondition(urlArray[0],operation,upc)){
						task.setTaskProcessingResult(operation);
						this.saveTask(task);
						return CompleteTaskTipType.RETURN_URL.setContent(urlArray[1]);
					}
				}
			}
		}
		return null;
	}
	
	/**
	 * 完成环节选择
	 * @param taskId
	 * @param map
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeTacheChoice(Long taskId, String transitionName) {
		Assert.notNull(taskId,"完成环节选择任务时，任务id不能为null");
		CompleteTaskTipType completeTaskTipType = null;
		WorkflowTask task = this.getTask(taskId);
		Assert.notNull(task,"完成环节选择任务时，任务不能为null");
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		Assert.notNull(instance,"完成环节选择任务时，流程实例不能为null");
		String originalActivityName=instance.getCurrentActivity();
		processEngine.getExecutionService().signalExecutionById(task.getExecutionId(), transitionName);
		String parentExecutionId = null;
		Execution execution = processEngine.getExecutionService().findExecutionById(task.getExecutionId());
		Assert.notNull(execution,"完成环节选择任务时，execution不能为null");
		Execution parentExecution = execution.getParent();
		if(parentExecution != null){
			parentExecutionId = parentExecution.getId();
		}
		task.setNextTasks(((ActivityExecution)execution).getActivityName());
		completeTaskTipType  = completeWfTask(instance,task, parentExecutionId);
		saveTask(task);
		if(completeTaskTipType==null){
			//影响setInstanceCurrentActivity方法中获得activityNames的值
			instance.setCurrentActivity(originalActivityName);
			setInstanceCurrentActivity(instance, task);
			completeTaskTipType = CompleteTaskTipType.OK.setContent("你已完成了任务");
			if(instance.getProcessState()==ProcessState.UNSUBMIT){
				instance.setProcessState(ProcessState.SUBMIT);
				instance.setSubmitTime(new Timestamp(System.currentTimeMillis()));
				this.workflowInstanceManager.saveWorkflowInstance(instance);
				FormView form = formViewManager.getFormView(instance.getFormId());
				Assert.notNull(form,"完成环节选择任务时，流程对应的表单不能为null");
				if(form.isStandardForm()){
					Assert.notNull(form.getDataTable(),"完成环节选择任务时，表单对应的数据表不能为null");
					Assert.notNull(form.getDataTable().getEntityName(),"完成环节选择任务时，表单对应的数据表实体类名不能为null");
					Object entity = generalDao.getObject(form.getDataTable().getEntityName(), instance.getDataId());
					try {
						BeanUtils.setProperty(entity, "workflowInfo.processState", ProcessState.SUBMIT);
						generalDao.save(entity);
					} catch (IllegalAccessException e) {
						log.debug(e);
						throw new RuntimeException();
					} catch (InvocationTargetException e) {
						log.debug(e);
						throw new RuntimeException();
					}
				}else{
					jdbcDao.updateTable("UPDATE "+form.getDataTable().getName()+" SET PROCESS_STATE="+ProcessState.SUBMIT.getIndex()+" WHERE  ID="+instance.getDataId());
				}
			}
		}
    	
    	return completeTaskTipType;
	}
	
	@Transactional(readOnly=false)
	private CompleteTaskTipType executionCompanyTask(WorkflowTask task, TaskProcessingResult operation,TaskSetting setting){
		log.debug(PropUtils.LOG_METHOD_BEGIN+"完成任务,TaskService+executionCompanyTask(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
		/* 如果是多人办理环节，最后一个人办理完，任务才算完成。
		 * 如果是单人办理环节，第一个办理的人领取任务。
		 * 
		 */
		if(task==null){log.debug("executionCompanyTask中，task任务不能为null");throw new RuntimeException("executionCompanyTask中，task任务不能为null");}
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		if(instance==null){log.debug("executionCompanyTask中，流程实例不能为null");throw new RuntimeException("executionCompanyTask中，流程实例不能为null");}
		log.debug(PropUtils.LOG_CONTENT+"该任务对应的实例"+PropUtils.LOG_FLAG+instance);
		CompleteTaskTipType completeTaskTipType = null;
    	String parentExecutionId = null;
    	if(task.getMoreTransactor()){
    		log.debug(PropUtils.LOG_CONTENT+"任务信息"+PropUtils.LOG_FLAG+task.getTransactor()+"的任务："+task.getName()+"为多人办理环节");
        	if(isCompleteJbpmTask(task,instance)){
        		log.debug(PropUtils.LOG_CONTENT+"可以完成JBPM任务"+PropUtils.LOG_FLAG);
        		log.debug(PropUtils.LOG_CONTENT+"完成JBPM任务开始"+PropUtils.LOG_FLAG);
        		parentExecutionId = completeJbpmTask(task, CommonStrings.COLLECTIVE_OPERATION,setting);
        		log.debug(PropUtils.LOG_CONTENT+"完成JBPM任务结束"+PropUtils.LOG_FLAG);
        		completeTaskTipType = isNeedChoiceTache(task);
        		log.debug(PropUtils.LOG_CONTENT+"是否需要选择环节"+PropUtils.LOG_FLAG+completeTaskTipType);
    			if(completeTaskTipType!=null){
    				log.debug(PropUtils.LOG_CONTENT+"需要选择环节"+PropUtils.LOG_FLAG+"需要选择环节。可选择的环节个数为:"+completeTaskTipType.getCanChoiceTaches().size());
    				log.debug(PropUtils.LOG_METHOD_BEGIN+"完成任务,TaskService+executionCompanyTask(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
    				return completeTaskTipType;
    			}
    			completeTaskTipType = completeWfTask(instance,task, parentExecutionId);
        	}else{
        		if(task.getActive()!=1){// 不是 “等待设置办理人”
        			generateTaskHistory(task);
        		}
        	}
    	}else{
    		log.debug(PropUtils.LOG_CONTENT+"任务信息"+PropUtils.LOG_FLAG+task.getTransactor()+"的任务："+task.getName()+"为单人办理环节");
    		//完成JBPM所对应的任务
    		if(isOneCompleteJbpmTask(task,instance)){
    			log.debug(PropUtils.LOG_CONTENT+"可以完成JBPM任务"+PropUtils.LOG_FLAG);
        		log.debug(PropUtils.LOG_CONTENT+"完成JBPM任务开始"+PropUtils.LOG_FLAG);
    			parentExecutionId = completeJbpmTask(task, operation.toString(),setting);
    			log.debug(PropUtils.LOG_CONTENT+"完成JBPM任务结束"+PropUtils.LOG_FLAG);
    			completeTaskTipType = isNeedChoiceTache(task);
    			log.debug(PropUtils.LOG_CONTENT+"是否需要选择环节"+PropUtils.LOG_FLAG+completeTaskTipType);
    			if(completeTaskTipType!=null){
    				log.debug(PropUtils.LOG_CONTENT+"需要选择环节"+PropUtils.LOG_FLAG+"需要选择环节。可选择的环节个数为:"+completeTaskTipType.getCanChoiceTaches().size());
    				log.debug(PropUtils.LOG_METHOD_BEGIN+"完成任务,TaskService+executionCompanyTask(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
    				return completeTaskTipType;
    			}
    			log.debug(PropUtils.LOG_CONTENT+"完成任务开始"+PropUtils.LOG_FLAG);
    			completeTaskTipType = completeWfTask(instance,task, parentExecutionId);
    			log.debug(PropUtils.LOG_CONTENT+"完成任务返回值"+PropUtils.LOG_FLAG+completeTaskTipType);
    			log.debug(PropUtils.LOG_CONTENT+"完成任务结束"+PropUtils.LOG_FLAG);
    		}else{
        		if(task.getActive()!=1){// 不是 “等待设置办理人”
        			generateTaskHistory(task);
        		}
        	}
    	}
    	
    	saveTask(task);
    	if(completeTaskTipType==null){
    		setInstanceCurrentActivity(instance, task);
    		completeTaskTipType = CompleteTaskTipType.OK.setContent("你已完成了任务");
    		if(instance.getProcessState()==ProcessState.UNSUBMIT){
    			instance.setProcessState(ProcessState.SUBMIT);
    			instance.setSubmitTime(new Timestamp(System.currentTimeMillis()));
    			
        		this.workflowInstanceManager.saveWorkflowInstance(instance);
        		FormView form = formViewManager.getFormView(instance.getFormId());
        		if(form.isStandardForm()){
        			Object entity = generalDao.getObject(form.getDataTable().getEntityName(), instance.getDataId());
        			try {
    					BeanUtils.setProperty(entity, "workflowInfo.processState", ProcessState.SUBMIT);
    					generalDao.save(entity);
    				} catch (IllegalAccessException e) {
    					log.debug(e);
    					throw new RuntimeException();
    				} catch (InvocationTargetException e) {
    					log.debug(e);
    					throw new RuntimeException();
    				}
        		}else{
        			jdbcDao.updateTable("UPDATE "+form.getDataTable().getName()+" SET PROCESS_STATE="+ProcessState.SUBMIT.getIndex()+" WHERE  ID="+instance.getDataId());
        		}
        	}
    	}
    	log.debug(PropUtils.LOG_CONTENT+"完成任务返回值"+PropUtils.LOG_FLAG+completeTaskTipType);
    	log.debug(PropUtils.LOG_METHOD_END+"完成任务,TaskService+executionCompanyTask(WorkflowTask task, TaskTransact operation,TaskSetting setting)"+PropUtils.LOG_FLAG);
    	return completeTaskTipType;
	}
	
	/*
	 * 是否需要选择环节
	 */
	public CompleteTaskTipType isNeedChoiceTache(WorkflowTask task){
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		if(instance==null){
			log.debug("流程实例不能为null");
			throw new RuntimeException("流程实例不能为null");
		}
		Assert.notNull(instance.getFormId(),"表单id不能为null");
		FormView form = formViewManager.getFormView(instance.getFormId());
		Execution execution = processEngine.getExecutionService().findExecutionById(task.getExecutionId());
		if(execution!=null){
			for(String activityName:execution.findActiveActivityNames()){
				String tacheType = DefinitionXmlParse.getCurrentTacheType(instance.getProcessDefinitionId(),activityName);
				if(StringUtils.isNotEmpty(tacheType)&&tacheType.equals(WorkflowTacheType.CHOICE_TACHE.getCode())){
					task.setActive(TaskState.WAIT_CHOICE_TACHE.getIndex());
					this.saveTask(task);
					return  CompleteTaskTipType.TACHE_CHOICE_URL.setContent(!form.isStandardForm()?DEFAULT_CHOICE_TACHE_URL:DEFAULT_CHOICE_TACHE_URL_POP)
					.setCanChoiceTaches(DefinitionXmlParse.getChoiceTaches(instance.getProcessDefinitionId(),activityName));
				}
			}
		}
		return null;
	}
	/*
	 * 子流程是否设置了上一环节办理人设置
	 */
	public CompleteTaskTipType isSubProcessNeedChoiceTransactor(WorkflowTask task ){
		CompleteTaskTipType result = null;
		Execution execution=processEngine.getExecutionService().findExecutionById(task.getExecutionId());
		//判断是子流程
		if(execution!=null ){
			ProcessInstance jbpmInstance=processEngine.getExecutionService().findProcessInstanceById(task.getProcessInstanceId());
			//判断子流程没有结束
			if(jbpmInstance!=null){
				Object assign=processEngine.getExecutionService().getVariable(task.getExecutionId(), CommonStrings.TRANSACTOR_ASSIGNMENT);
				if(assign!=null && "${previousTransactorAssignment}".equals(assign.toString()) ){
					WorkflowInstance instance=workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
					String url = DefinitionXmlParse.getPreviousTransactorAssignmentUrl(instance.getProcessDefinitionId(),task.getNextTasks());
					url = StringUtils.isEmpty(url)?DEFAULT_URL:url;
		    		result = CompleteTaskTipType.RETURN_URL.setContent(url);
				}
			}
		}
		return result;
	}
	
	
	/*
	 * 单人办理环节是否可以完成jbpm任务 
	 */
	private boolean isOneCompleteJbpmTask(WorkflowTask task , WorkflowInstance instance){
		List<WorkflowTask> parallelTasks = workflowTaskService.getTasksByActivity(
    			task.getCompanyId(), task.getExecutionId(), task.getName());
		return parallelTasks.size() == 1&¶llelTasks.get(0).getTransactor().equals(ContextUtils.getLoginName())&&(!parallelTasks.get(0).isSpecialTask()||parallelTasks.get(0).getName().equals(instance.getCurrentActivity()));
	}
	
	//如果任务只有一个而且办理人是自己的时候，完成任务。主要防止调用两次完成任务导致把别人的任务完成的情况
	private boolean isCompleteJbpmTask(WorkflowTask task , WorkflowInstance instance){
		if(task==null){log.debug("isCompleteJbpmTask方法中，任务参数不能为null");throw new RuntimeException("isCompleteJbpmTask方法中，任务参数不能为null");}
		if(instance==null){log.debug("isCompleteJbpmTask方法中，流程实例参数不能为null");throw new RuntimeException("isCompleteJbpmTask方法中，流程实例参数不能为null");}
		List<WorkflowTask> parallelTasks = workflowTaskService.getTasksByActivity(
    			task.getCompanyId(), task.getExecutionId(), task.getName());
		List<WorkflowTask> allTask = workflowTaskService.getWorkflowTasks(instance.getProcessInstanceId(),task.getName());
		double passNum = 1,totle=0;
		WorkflowTask tempTask;
		if(task.getProcessingMode()==TaskProcessingMode.TYPE_COUNTERSIGNATURE&&task.getTaskProcessingResult()==TaskProcessingResult.APPROVE){
			int passSetting = DefinitionXmlParse.getTransactPassRate(instance.getProcessDefinitionId(), task.getName());
			if(passSetting!=0){
				for(int i=0;i<allTask.size();i++){
					tempTask = allTask.get(i);
					if(!tempTask.isSpecialTask()&&(tempTask.getActive().equals(TaskState.WAIT_TRANSACT.getIndex())||tempTask.getActive().equals(TaskState.COMPLETED.getIndex())))totle++;
					if(!tempTask.isSpecialTask()&&tempTask.getActive().equals(TaskState.COMPLETED.getIndex())&&tempTask.getTaskProcessingResult()==TaskProcessingResult.APPROVE){
						passNum++;
					}
				}
				
				if(Math.round(passNum/totle*100)>=passSetting){
					cancelOtherTask(parallelTasks,task);
					return true;
				}
			}
		}else if(task.getProcessingMode()==TaskProcessingMode.TYPE_VOTE&&task.getTaskProcessingResult()==TaskProcessingResult.AGREEMENT){
			int passSetting = DefinitionXmlParse.getTransactPassRate(instance.getProcessDefinitionId(), task.getName());
			if(passSetting!=0){
				for(int i=0;i<allTask.size();i++){
					tempTask = allTask.get(i);
					if(!tempTask.isSpecialTask()&&(tempTask.getActive().equals(TaskState.WAIT_TRANSACT.getIndex())||tempTask.getActive().equals(TaskState.COMPLETED.getIndex())))totle++;
					if(!tempTask.isSpecialTask()&&tempTask.getActive().equals(TaskState.COMPLETED.getIndex())&&tempTask.getTaskProcessingResult()==TaskProcessingResult.AGREEMENT){
						passNum++;
					}
				}
				if(Math.round(passNum/totle*100)>=passSetting){
					cancelOtherTask(parallelTasks,task);
					return true;
				}
			}
		}
		return parallelTasks.size() == 1&¶llelTasks.get(0).getTransactor().equals(ContextUtils.getLoginName())&&(!parallelTasks.get(0).isSpecialTask()||parallelTasks.get(0).getName().equals(instance.getCurrentActivity()));
	}
	
	@Transactional(readOnly=false)
	private void cancelOtherTask(List<WorkflowTask> activityTasks ,WorkflowTask task){
		for(WorkflowTask tsk:activityTasks){
			if(!tsk.equals(task)){
				tsk.setActive(TaskState.CANCELLED.getIndex());
				this.saveTask(tsk);
			} 
		}
	}
	
	/**
	 * 完成分发任务
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeDistributeTask(Long taskId, List<String> receivers){
		Assert.notNull(taskId,"完成分发任务时，任务id不能为null");
		WorkflowTask task = getTask(taskId);
		Assert.notNull(task,"完成分发任务时，任务不能为null");
		
		List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
		if(receivers.size()>0 && receivers.get(0).equals(CommonStrings.ALL_USER)){
			receivers.remove(0);
			List<com.norteksoft.product.api.entity.User> users = ApiFactory.getAcsService().getUsersByCompany(task.getCompanyId());
			for(com.norteksoft.product.api.entity.User user:users){
				receivers.add(user.getLoginName());
			}
		}
		Set<String> receiverSet = new HashSet<String>(receivers);
		Integer groupNum=getTaskMaxGroupNum(task.getProcessInstanceId(), task.getName(),task.getCompanyId());
		groupNum++;
		for(String user : receiverSet){
			tasks.add(createDistributeTask(task, user, TaskProcessingMode.TYPE_READ.toString(),groupNum));
		}
		saveTasks(tasks);
		return complete(task,TaskProcessingResult.DISTRIBUTE,TaskSetting.getTaskSettingInstance().setReturnUrl(false));
	}
	
	/**
	 * 设置任务是否已阅
	 * @param task
	 */
	@Transactional(readOnly=false)
	public void updateTaskIsRead(WorkflowTask task){
		boolean isNeedSave = false;
		if(!task.getRead()){
			task.setRead(true);
			isNeedSave = true;
		}
		if(isNeedSave){
			saveTask(task);
		}
	}

	/*
	 * 设置流程实例当前环境 
	 */
	@Transactional(readOnly=false)
	private void setInstanceCurrentActivity(WorkflowInstance instance, WorkflowTask task){
		if(task==null){log.debug("设置流程实例当前环节时，任务参数不能为null");throw new RuntimeException("设置流程实例当前环节时，任务参数不能为null");}
		if(instance==null){log.debug("设置流程实例当前环节时，流程实例参数不能为null");throw new RuntimeException("设置流程实例当前环节时，流程实例参数不能为null");}
		//if(task.isSpecialTask()) return ;
		String activityNames = instance.getCurrentActivity();
		if(StringUtils.isNotEmpty(activityNames)){
			if(task.getNextTasks() != null){
				activityNames = activityNames.replace(task.getName(), task.getNextTasks());
			}
		}else{
			activityNames = task.getNextTasks();
		}
		instance.setCurrentActivity(activityNames);
		FormView form =formViewManager.getFormView(instance.getFormId());
		if(form==null){log.debug("设置流程实例当前环节时，表单不能为null");throw new RuntimeException("设置流程实例当前环节时，表单不能为null");}
		if(form.isStandardForm()){
			log.info("标准表单");
			//标准表单的处理
			//根据表单id获得对应的类
			try {
				if(form.getDataTable()==null){log.debug("设置流程实例当前环节时，表单对应的数据表不能为null");throw new RuntimeException("设置流程实例当前环节时，表单对应的数据表不能为null");}
				String className = form.getDataTable().getEntityName();
				log.info("实体类名：" + className);
				//根据表名和id获得实体
				Object entity = generalDao.getObject(className, instance.getDataId());
				log.info("查询得到的实体:" + entity);
				BeanUtils.setProperty(entity, "workflowInfo.currentActivityName", activityNames);
				generalDao.save(entity);
			} catch (Exception e) {
				new RuntimeException(e);
			}
		}
	}
	
	/**
	 * 领取
	 * @param taskId
	 */
	@Transactional(readOnly=false)
	public String receive(Long taskId){
		return workflowTaskService.receive(taskId);
	}
	
	/**
	 * 放弃领取
	 * @param taskId
	 */
	@Transactional(readOnly=false)
	public String abandonReceive(Long taskId){
		return workflowTaskService.abandonReceive(taskId);
	}
	
	
	/*
	 * 生成任务历史记录
	 * @param instanceId
	 * @param activityName
	 */
	@Transactional(readOnly=false)
	private void generateTaskHistory(WorkflowTask task,TaskProcessingResult result){
		InstanceHistory ih = new InstanceHistory();
		ih.setCompanyId(task.getCompanyId());
		ih.setType(InstanceHistory.TYPE_TASK);
		ih.setInstanceId(task.getProcessInstanceId());
		ih.setExecutionId(task.getExecutionId());
		ih.setTaskName(task.getName());
		ih.setTaskId(task.getId());
		ih.setCreatedTime(new Date());
		ih.setSpecialTask(task.isSpecialTask());
		StringBuilder msg = new StringBuilder();
		msg.append(dateFormat.format(ih.getCreatedTime()))
			.append(COMMA).append(ContextUtils.getUserName()).append(ACTION_START)
			.append(result.getName()).append(ACTION_END);
		ih.setTransactionResult(msg.toString());
		ih.setTransactor(new StringBuilder(ContextUtils.getUserName()).append(DELTA_START).append(task.getTransactor()).append(DELTA_END).toString());
		instanceHistoryManager.saveHistory(ih);
	}
	
	/*
	 * 完成Workflow任务
	 * @param task
	 * @param parentExecutionId
	 * @return
	 */
	@Transactional(readOnly=false)
	private CompleteTaskTipType completeWfTask(WorkflowInstance instance,WorkflowTask task, String parentExecutionId){
		log.debug("*** completeWfTask 方法开始");
		CompleteTaskTipType isNeedAssign = isNeedAssigningTransactor(instance, task);
		if(isNeedAssign==null){
			//判断子流程是否需要设置办理人
			isNeedAssign=isSubProcessNeedChoiceTransactor(task);
		}
		
		if(isNeedAssign==null){
			//生成新任务
			generateTask(instance, task.getExecutionId(), parentExecutionId);
			
			//特事特办
			doSpecialTask(task);
			//完成任务，生成流转历史
			completeTask(task);
			generateHistory(task, parentExecutionId);
			//设置流程实例上一环节相关信息
			setWorkflowPreviousAcitivity(instance,task);
		}else{
			task.setTransactDate(new Date());
        	task.setActive(TaskState.WAIT_DESIGNATE_TRANSACTOR.getIndex());
		}
		return isNeedAssign;
	}
	
	private void setWorkflowPreviousAcitivity(WorkflowInstance instance,WorkflowTask task){
		instance.setPreviousActivity(task.getName());
		instance.setPreviousActivityTitle(task.getTitle());
		workflowInstanceManager.saveWorkflowInstance(instance);
	}
	
	private void generateTaskHistory(WorkflowTask task){
		// 完成任务
		task.setTransactDate(new Date());
    	task.setActive(TaskState.COMPLETED.getIndex());
    	//人工环节流转历史
    	generateTaskHistory(task, task.getTaskProcessingResult());
		saveTask(task);
	}
	
	private void completeTask(WorkflowTask task){
		generateTaskHistory(task);
		executeAfterTaskCompleted(task);
	}
	
	@SuppressWarnings("unchecked")
	@Transactional(readOnly=false)
	private void doSpecialTask(WorkflowTask task){
		//判断是否特事特办
		WorkflowInstance workflow = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		FormView form = formViewManager.getFormView(workflow.getFormId());
		String titleExpression = DefinitionXmlParse.getSpecialTaskTitle(workflow.getProcessDefinitionId(), task.getName());
		String title = this.parseTitleExpression(titleExpression, workflow,null);
		String specialTaskName = DefinitionXmlParse.getSpecialTaskProperties(workflow.getProcessDefinitionId(), task.getName());
		if(!form.isStandardForm()){
			//自定义表单
			Map map = formViewManager.getDataMap(form.getDataTable().getName(), workflow.getDataId());
			Object value = map.get(JdbcSupport.FILED_NAME_IS_CREATE_SPECIAL_TASK);
			if(value!=null&& "1".equals(value.toString()) && DefinitionXmlParse.isHaveSpecialTask(workflow.getProcessDefinitionId(), task.getName())){
				//获得特事特办任务 并创建
				Object specialTaskTransactor = map.get(JdbcSupport.FILED_NAME_IS_SPECIAL_TASK_TRANSACTOR);
				String json;
				if(specialTaskTransactor!=null){
					json = specialTaskTransactor.toString();
					createSpecialTask(workflow, task.getExecutionId(), json.split(","), specialTaskName,title);
				}else{
					//JPDL定义扩展参数
					Map<TaskTransactorCondition, String> conditions = 
						DefinitionXmlParse.getTaskTransactor(workflow.getProcessDefinitionId(), specialTaskName);
					
					Execution execution = processEngine.getExecutionService().findExecutionById(task.getExecutionId());
					OpenExecution openExeccution = ((OpenExecution)execution);
					String processInstanceId = ((ActivityExecution)execution).getProcessInstance().getId();
					String creator = openExeccution.getVariable("creator").toString();
					//根据条件选定办理人
					log.info("办理人设置条件为:"+conditions);
					Map<String,String> paramMap = new HashMap<String,String>();
					paramMap.put(TransactorConditionHandler.DOCUMENT_CREATOR, creator);
					paramMap.put(TransactorConditionHandler.PROCESS_INSTANCEID, processInstanceId);
					Object obj = openExeccution.getVariable(CommonStrings.PREVIOUS_TASK_TRANSACTOR);
					if(obj!=null){
						paramMap.put(TransactorConditionHandler.PREVIOUS_TRANSACTOR, obj.toString());
					}
					
					Set<String> candidates = TransactorConditionHandler.processCondition(conditions, openExeccution,paramMap);
					if(candidates.isEmpty() || (candidates.size()==1 && candidates.iterator().next().equals(CommonStrings.TRANSACTOR_ASSIGNMENT)))return;//如果没有办理人。将不特办
					createSpecialTask(workflow, task.getExecutionId(), candidates, specialTaskName,title);
				} 
					
			}
		}else if(form.isStandardForm()){
			//标准表单
			FormFlowable entity = (FormFlowable)generalDao.getObject(form.getDataTable().getEntityName(), workflow.getDataId());
			boolean isCreateSpecialTask = entity.getWorkflowInfo().getCreateSpecialTask();
			if(isCreateSpecialTask&& DefinitionXmlParse.isHaveSpecialTask(workflow.getProcessDefinitionId(), task.getName())){
				//获得特事特办任务 并创建
				String specialTaskTransactor = entity.getWorkflowInfo().getSpecialTaskTransactor();
				if(specialTaskTransactor!=null){
					//TODO 如果特事特办流向没有设定办理人，就用那个环节条件选的办理人
					
					createSpecialTask(workflow, task.getExecutionId(), specialTaskTransactor.split(","), specialTaskName,title);
				}else{
					//JPDL定义扩展参数
					Map<TaskTransactorCondition, String> conditions = 
						DefinitionXmlParse.getTaskTransactor(workflow.getProcessDefinitionId(), specialTaskName);
					
					Execution execution = processEngine.getExecutionService().findExecutionById(task.getExecutionId());
					OpenExecution openExeccution = ((OpenExecution)execution);
					String processInstanceId = ((ActivityExecution)execution).getProcessInstance().getId();
					String creator = openExeccution.getVariable("creator").toString();
					//根据条件选定办理人
					log.info("办理人设置条件为:"+conditions);
					Map<String,String> paramMap = new HashMap<String,String>();
					paramMap.put(TransactorConditionHandler.DOCUMENT_CREATOR, creator);
					paramMap.put(TransactorConditionHandler.PROCESS_INSTANCEID, processInstanceId);
					Object obj = openExeccution.getVariable(CommonStrings.PREVIOUS_TASK_TRANSACTOR);
					if(obj!=null){
						paramMap.put(TransactorConditionHandler.PREVIOUS_TRANSACTOR, obj.toString());
					}
					
					Set<String> candidates = TransactorConditionHandler.processCondition(conditions, openExeccution,paramMap);
					if(candidates.isEmpty())return;//如果没有办理人。将不特办
					createSpecialTask(workflow, task.getExecutionId(), candidates, specialTaskName,title);
				} 
			}
		}
	}
	
	@Transactional(readOnly=false)
	private void createSpecialTask(WorkflowInstance workflow,String executionId,Set<String> users,String taskName,String title){
		for(String user:users){
			WorkflowTask specialTask = createSpecialTask(workflow, executionId, user, taskName,title);
			this.saveTask(specialTask);
		}
	}
	
	@Transactional(readOnly=false)
	private void createSpecialTask(WorkflowInstance workflow,String executionId,String[] users,String taskName,String title){
		for(String user:users){
			WorkflowTask specialTask = createSpecialTask(workflow, executionId, user, taskName,title);
			this.saveTask(specialTask);
		}
	}
	
	/**
	 * 任务完成后执行
	 */
	@Transactional(readOnly=false)
	private void executeAfterTaskCompleted(WorkflowTask task){
		if(task==null){log.debug("任务完成后执行bean时，任务参数不能为null");throw new RuntimeException("任务完成后执行bean时，任务参数不能为null");}
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		if(instance==null){log.debug("任务完成后执行bean时，流程实例不能为null");throw new RuntimeException("任务完成后执行bean时，流程实例不能为null");}
		String beanName = DefinitionXmlParse.getAfterTaskCompletedBean(
				instance.getProcessDefinitionId(), task.getName());
		if(!StringUtils.isEmpty(beanName)){
			AfterTaskCompleted bean = (AfterTaskCompleted) ContextUtils.getBean(beanName);
			if(bean==null){log.debug("任务完成后执行bean时，bean不能为null");throw new RuntimeException("任务完成后执行bean时，bean不能为null");}
			bean.execute(instance.getDataId(), task.getTaskProcessingResult());
		}
	}
	
    /*
     * 生成流转历史
     * @param task
     */
	@Transactional(readOnly=false)
    private void generateHistory(WorkflowTask task, String parentExecutionId){
    	log.debug("*** generateHistory 方法开始");
		log.debug(new StringBuilder("*** Received parameter:[")
			.append("task:").append(task)
			.append(", parentExecutionId:").append(parentExecutionId)
			.append("]").toString());
		
    	generateFlowHistory(task.getProcessInstanceId(), task.getExecutionId(), task.getName(), PROCESS_LEAVE);
		Execution execution = processEngine.getExecutionService().findExecutionById(task.getExecutionId());
		String nextTasks = "";
		if(execution == null){
			if(parentExecutionId != null){
				// 并发join时取主流程的任务  (不考虑合并后还需要选择办理人)
				log.debug("parentExecutionId:"+parentExecutionId);
				Execution parentExecution = processEngine.getExecutionService().findExecutionById(parentExecutionId);
				log.debug("parentExecution:" + parentExecution);
				if(parentExecution == null){ //汇聚后流程直接结束
					InstanceHistory ih = new InstanceHistory(task.getCompanyId(), task.getProcessInstanceId(), 
							InstanceHistory.TYPE_FLOW_END, PROCESS_END);
					instanceHistoryManager.saveHistory(ih);
					workflowInstanceManager.setWorkflowInstanceEnd(task.getProcessInstanceId());
					nextTasks = PROCESS_END_EN;
				}else{
					String activityName = ((ActivityExecution)parentExecution).getActivityName();
	        		generateFlowHistory(task.getProcessInstanceId(), parentExecution.getId(), activityName, PROCESS_ENTER);
	        		nextTasks = activityName;
				}
			}else{
				ProcessInstance instance = processEngine.getExecutionService().findProcessInstanceById(task.getProcessInstanceId());
				// 当 execution 和 instance 同时为null时，流程结束
				if(instance == null){
					InstanceHistory ih = new InstanceHistory(task.getCompanyId(), task.getProcessInstanceId(), 
							InstanceHistory.TYPE_FLOW_END, PROCESS_END);
					instanceHistoryManager.saveHistory(ih);
					//设置流程结束
					workflowInstanceManager.setWorkflowInstanceEnd(task.getProcessInstanceId());
					nextTasks = PROCESS_END_EN;
				}
			}
		}else{
			Collection<? extends Execution> subExecutions = execution.getExecutions();
			List<Execution> executions = new ArrayList<Execution>();
			if(subExecutions == null || subExecutions.size() < 1){
				if(Execution.STATE_INACTIVE_JOIN.equals(execution.getState())){//并发汇聚
					//String activityName = ((ActivityExecution)execution).getActivityName();
	        		//generateFlowHistory(task.getProcessInstanceId(), activityName, PROCESS_TRANSACT);
				}else{
					ExecutionImpl subInstance = ((ExecutionImpl)execution.getProcessInstance()).getSubProcessInstance();
					if(subInstance != null){//子流程
						String activityName = subInstance.getActivityName();
		        		generateFlowHistory(subInstance.getProcessInstance().getId(), subInstance.getId(), activityName, PROCESS_ENTER);
		        		//executions.add(subInstance);
		        		nextTasks = activityName;
					}else{
		    			String activityName = ((ActivityExecution)execution).getActivityName();
		    			WorkflowInstance wi=workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId(),task.getCompanyId());
		    			if(wi.getProcessState()==ProcessState.END){
		    				InstanceHistory ih = new InstanceHistory(task.getCompanyId(), task.getProcessInstanceId(), 
		    						InstanceHistory.TYPE_FLOW_END, PROCESS_END);
		    				instanceHistoryManager.saveHistory(ih);
		    				//设置流程结束
		    				workflowInstanceManager.setWorkflowInstanceEnd(task.getProcessInstanceId());
		    			}else{
		    				generateFlowHistory(task.getProcessInstanceId(), execution.getId(), activityName, PROCESS_ENTER);
		    			}
		    			executions.add(execution);
		        		nextTasks = activityName;
					}
				}
			}else{
				// 并发流程的流转历史
				for(Execution e : subExecutions){
					String activityName = ((ActivityExecution)e).getActivityName();
            		generateFlowHistory(task.getProcessInstanceId(), e.getId(), activityName, PROCESS_ENTER);
            		executions.add(e);
            		nextTasks = nextTasks + "," + activityName;
				}
			}
			
		}
		//任务完成时修改任务下一环节的任务(含并发)
		nextTasks = nextTasks.replaceFirst(",", "");
		task.setNextTasks(nextTasks);
		
		log.debug("*** generateHistory 方法结束");
    }

	/*
	 * 生成流转历史记录
	 * @param instanceId
	 * @param activityName
	 */
	@Transactional(readOnly=false)
	private void generateFlowHistory(String instanceId, String executionId, String activityName, String state){
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(instanceId);
		InstanceHistory ih = new InstanceHistory();
		ih.setCompanyId(instance.getCompanyId());
		if(PROCESS_ENTER.equals(state)){
			ih.setType(InstanceHistory.TYPE_FLOW_INTO);
		}else if(PROCESS_LEAVE.equals(state)){
			ih.setType(InstanceHistory.TYPE_FLOW_LEAVE);
		}
		ih.setInstanceId(instanceId);
		ih.setExecutionId(executionId);
		ih.setCreatedTime(new Date());
		ih.setTransactionResult(new StringBuilder(dateFormat.format(new Date()))
			.append(COMMA).append(state).append(DELTA_START)
			.append(activityName).append(DELTA_END).toString());
		ih.setTaskName(activityName);
		instanceHistoryManager.saveHistory(ih);
	}
	
	/*
	 * 提取需要生成新任务的JBPM task
	 * @param jbpmTasks
	 * @param taskNames
	 */
	@Transactional(readOnly=false)
	private List<org.jbpm.api.task.Task> extractTask(List<org.jbpm.api.task.Task> jbpmTasks, List<String> taskNames){
		if(taskNames != null){
			List<org.jbpm.api.task.Task> targetTasks = new ArrayList<org.jbpm.api.task.Task>();
			for(org.jbpm.api.task.Task t : jbpmTasks){
				if(!taskNames.contains(t.getName())){
					targetTasks.add(t);
				}
			}
			return targetTasks;
		}
		return jbpmTasks;
	}
	
	/**
	 * 生成任务
	 * @param processId
	 * @param instanceId
	 * @param transactor
	 */
	@Transactional(readOnly=false)
	public void generateTask(WorkflowInstance instance, String executionId, String parentExecutionId){
		log.debug("*** generateTask 方法开始");

		String instanceId=instance.getProcessInstanceId();
		List<org.jbpm.api.task.Task> jbpmTasks = processEngine.getTaskService().createTaskQuery()
			.processInstanceId(instanceId).list();
		ActivityExecution execution = (ActivityExecution) processEngine.getExecutionService().findExecutionById(executionId);
		if(execution != null){
			if(jbpmTasks.isEmpty() && !Execution.STATE_INACTIVE_CONCURRENT_ROOT.equals(execution.getState())){
				return;
			}
//			if(jbpmTasks.isEmpty() && !Execution.STATE_ACTIVE_ROOT.equals(execution.getState())){//流程结束,流程并发
//				WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(execution.getProcessInstance().getId());
//				instanceId = instance.getParentProcessId();
//				jbpmTasks = processEngine.getTaskService().createTaskQuery().processInstanceId(instanceId).list();
//			}
			if(jbpmTasks.isEmpty()&&Execution.STATE_INACTIVE_JOIN.equals(execution.getState())){
				return ;
			}
			List<String> taskNames = workflowTaskService.getTaskNamesByInstance(instance.getCompanyId(), instanceId);// 查询流程实例所有已经生成的任务
			jbpmTasks = extractTask(jbpmTasks, taskNames);
			List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
			boolean isSameGroup=false;
			for(org.jbpm.api.task.Task task : jbpmTasks){
				Integer groupNum=getTaskMaxGroupNum(instanceId,task.getActivityName(),instance.getCompanyId());
				if(!isSameGroup)groupNum++;
				isSameGroup=true;
				if(task.getAssignee() == null){//任务有多个办理人
					Iterator<ParticipationImpl> it = ((TaskImpl)task).getParticipations().iterator();
					WorkflowTask wfTask = null;
					while(it.hasNext()){
						wfTask = createTask(instanceId, task.getExecutionId(), it.next().getUserId(), task.getActivityName(),groupNum);
						//审批任务有多个办理人时设置为待领取
						if(!wfTask.getMoreTransactor()){
							wfTask.setActive(TaskState.DRAW_WAIT.getIndex());
						}
						tasks.add(wfTask);
					}
				}else{//任务只有一个办理人
					tasks.add(createTask(instanceId, task.getExecutionId(), task.getAssignee(), task.getActivityName(),groupNum));
				}
			}
			if(!tasks.isEmpty()) saveTasks(tasks);
		}else if(execution == null && StringUtils.isNotEmpty(parentExecutionId)){//并发Execution结束，进入parent Execution
			generateTask(instance, parentExecutionId, "");
		}
		log.debug("*** generateTask 方法结束");
	}
	
	/*
	 * 获取任务完成后流程的Execution
	 * @param execution
	 * @param parentExecutionId
	 * @return
	 */
	private Map<ActivityExecution, String> getCurrentExecutions(ActivityExecution execution, String parentExecutionId){
		Map<ActivityExecution, String> result = new HashMap<ActivityExecution,String>();
		if(execution == null){
			if(parentExecutionId != null){
				ActivityExecution parentExecution = (ActivityExecution)processEngine.getExecutionService().findExecutionById(parentExecutionId);
				String activityName = parentExecution.getActivityName();
				result.put(parentExecution, activityName);
			}
		}else{
			Collection<? extends Execution> executions = execution.getExecutions();
			if(executions.isEmpty()){
				String activityName = execution.getActivityName();
				result.put(execution, activityName);
			}else{
				for(Execution ex : executions){
					String activityName = ((ActivityExecution)ex).getActivityName();
					result.put((ActivityExecution)ex, activityName);
				}
			}
		}
		return result;
	}
    
    /**
     * 判断环节是否需要指定办理人
     * @param taskId
     * @return
     */
	public CompleteTaskTipType isNeedAssigningTransactor(WorkflowInstance instance, WorkflowTask task){
		Assert.notNull(instance,"流程实例不能为null");
		Assert.notNull(task,"task任务不能为null");
    	log.debug("*** isNeedAssigningTransactor 方法开始");
    	CompleteTaskTipType result = null;
		//直接为上一环节办理人指定
    	List<org.jbpm.api.task.Task> assignmentList = processEngine.getTaskService().createTaskQuery()
    		.assignee(CommonStrings.TRANSACTOR_ASSIGNMENT)
    		.processInstanceId(instance.getProcessInstanceId()).list();
    	
    	if(assignmentList.size() > 0){
    		String url = DefinitionXmlParse.getPreviousTransactorAssignmentUrl(instance.getProcessDefinitionId(),task.getNextTasks());
    		url = StringUtils.isEmpty(url)?DEFAULT_URL:url;
    		result = CompleteTaskTipType.RETURN_URL.setContent(url);
    	}else{
    		//附加条件中需要唯一指定办理人
    		//直流候选人
    		OpenExecution execution = (OpenExecution)processEngine.getExecutionService()
							.findExecutionById(task.getExecutionId());
    		Object condidates = null;
    		if(execution != null){
    			condidates = processEngine.getExecutionService().getVariable(task.getExecutionId(), CommonStrings.TRANSACTOR_SINGLE_CANDIDATES);
    			boolean moreTransactor = DefinitionXmlParse.hasMoreTransactor(
    					instance.getProcessDefinitionId(), task.getNextTasks());
	    		if(condidates != null){
	        		result = CompleteTaskTipType.SINGLE_TRANSACTOR_CHOICE.setCanChoiceTransactor((Set<String>)condidates).setContent(moreTransactor+"");
	    		}else{
	    			//并发流程候选人
	    			Collection<? extends Execution> executions = execution.getExecutions();
	    			for(Execution e : executions){
	    				condidates = ((OpenExecution)e).getVariable(CommonStrings.TRANSACTOR_SINGLE_CANDIDATES);
	    				if(condidates != null){
	    					result = CompleteTaskTipType.SINGLE_TRANSACTOR_CHOICE.setCanChoiceTransactor((Set<String>)condidates).setContent(moreTransactor+"");
	    	    			break;
	    	    		}
	    			}
	    		}
    		}
    	}
    	return result;
    }

    /**
     * 完成JBPM所对应的任务
     * @param task
     */
    @Transactional(readOnly=false)
    private String completeJbpmTask(WorkflowTask task, String operation,TaskSetting setting){
    	log.debug("*** completeJbpmTask 方法开始");
		log.debug(new StringBuilder("*** Received parameter:[")
			.append("task:").append(task)
			.append(", operation:").append(operation)
			.append("]").toString());
		
    	//if(task.isSpecialTask()) return null;
    	
		if(task == null){log.debug("completeJbpmTask方法中，task任务不能为null");throw new RuntimeException("completeJbpmTask方法中，task任务不能为null");}
    	// 个人任务
    	org.jbpm.api.task.Task jbpmTask = processEngine.getTaskService().createTaskQuery()
			.processInstanceId(task.getProcessInstanceId())
    		.activityName(task.getName()).uniqueResult();
    	// 组任务
    	if(jbpmTask == null){
    		jbpmTask = processEngine.getTaskService().createTaskQuery()
				.processInstanceId(task.getProcessInstanceId())
				.candidate(ContextUtils.getLoginName())
				.activityName(task.getName()).uniqueResult();
    	}
    	if(jbpmTask == null){log.debug("completeJbpmTask方法中，jbpmTask任务不能为null");throw new RuntimeException("completeJbpmTask方法中，jbpmTask任务不能为null");}
    	String parentExecutionId = null;
    	Execution execution = processEngine.getExecutionService().findExecutionById(jbpmTask.getExecutionId());
    	if(execution == null){log.debug("completeJbpmTask方法中，execution不能为null");throw new RuntimeException("completeJbpmTask方法中，jexecution不能为null");}
    	Execution parentExecution = execution.getParent();
    	if(parentExecution != null){
    		parentExecutionId = parentExecution.getId();
    	}
    	
    	// execution变量，供后面的Decision使用
    	Map<String, String> variables = new HashMap<String, String>();
    	variables.put(CommonStrings.CURRENT_OPERATTION_STRING, operation);//本环节办理人执行的操作
    	variables.put(CommonStrings.PREVIOUS_TASK_NAME, task.getName());//本环节任务名
    	variables.put(CommonStrings.PREVIOUS_TASK_TRANSACTOR, task.getTransactor());//本环节办理人（受托人）
    	variables.put(CommonStrings.PREVIOUS_TASK_PRINCI_TRANSACTOR, task.getTrustor());//本环节办理人委托人
    	variables.put(CommonStrings.TRANSITION_NAME, setting.getTransitionName());//指定的流向名
    	variables.put(CommonStrings.NEW_TRANSACTOR, setting.getAssignmentTransactors());//指定的办理人
    	executionVariableCommand(new ExecutionVariableCommand(execution.getId(),variables));
		try {
			processEngine.getTaskService().completeTask(jbpmTask.getId());
			WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId(),task.getCompanyId());
			//以下执行两遍completeAutoTache，completeCopyTache的原因是因为流程图中连续的【自动、抄送】环节。先【自动】再【抄送】或先【抄送】再【自动】均包括在内。
			completeAutoTache(instance, execution);//完成自动环节
			completeCopyTache(instance, execution);//完成抄送环节
			completeAutoTache(instance, execution);//完成自动环节
			completeCopyTache(instance, execution);//完成抄送环节
			task.setNextTasks(((ActivityExecution)execution).getActivityName());
		} catch (JbpmException e) {
			if(e.getMessage().endsWith(TransactorAssignmentException.NO_TRANSACTOR)){
				throw new TransactorAssignmentException(TransactorAssignmentException.NO_TRANSACTOR);
			}
		}
		log.debug("*** completeJbpmTask 方法结束");
		
    	return parentExecutionId;
    }
    
    
    /*
     * 递归完成抄送环节。可以完成过个抄送环节串联的情况
     */
    private void completeCopyTache(WorkflowInstance instance ,Execution execution){
    	if(execution!=null){
    		if(execution.getState().equals(Execution.STATE_ENDED)&&!execution.getProcessInstance().getState().equals(Execution.STATE_ENDED)){
				execution = processEngine.getExecutionService().findExecutionById(execution.getProcessInstance().getId());
			}
			for(String activityName:execution.findActiveActivityNames()){
				String tacheType = DefinitionXmlParse.getCurrentTacheType(instance.getProcessDefinitionId(),activityName);
				if(StringUtils.isNotEmpty(tacheType)&&tacheType.equals(WorkflowTacheType.COPY_TACHE.getCode())){
					Execution tempExecution = execution.findActiveExecutionIn(activityName);
					createCopyTask(instance,tempExecution,activityName);//创建抄送任务
					processEngine.getExecutionService().signalExecutionById(tempExecution.getId());
					generateCopyTaskHistory(instance.getProcessInstanceId(),tempExecution.getId(),activityName);
					completeCopyTache(instance,execution);
				}
			}
		}
    }
    
    @Transactional(readOnly=false)
	private void createCopyTask(WorkflowInstance instance,Execution execution,String taskName){
    	Object creatorObj = processEngine.getExecutionService().getVariable(execution.getId(), "creator");
    	User creator = userManager.getUserByLoginName(creatorObj.toString());
    	if(creator == null){log.debug("createCopyTask方法中，文档创建人不能为null");throw new RuntimeException("createCopyTask方法中，文档创建人不能为null");}
    	//分析本环节办理人的
    	//JPDL定义扩展参数
		Map<TaskTransactorCondition, String> conditions = 
			DefinitionXmlParse.getTaskTransactor(instance.getProcessDefinitionId(), taskName);
		
		
		//根据条件选定办理人
		log.info("办理人设置条件为:"+conditions);
		Map<String,String> paramMap = new HashMap<String,String>();
		paramMap.put(TransactorConditionHandler.DOCUMENT_CREATOR, creator.getLoginName());
		paramMap.put(TransactorConditionHandler.PROCESS_INSTANCEID, instance.getProcessInstanceId());
		Object previousTaskTransactorObj = ((OpenExecution) execution).getVariable(CommonStrings.PREVIOUS_TASK_TRANSACTOR);
		if(previousTaskTransactorObj!=null){
			paramMap.put(TransactorConditionHandler.PREVIOUS_TRANSACTOR, previousTaskTransactorObj.toString());
		}
		
		Set<String> candidates = TransactorConditionHandler.processCondition(conditions, (OpenExecution) execution,paramMap);
    	List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
    	for(String transactor:candidates){
        	WorkflowTask task = createTask(instance.getProcessDefinitionId(),instance.getProcessInstanceId(),execution.getId(),taskName,transactor,false,1);
        	if(task!=null){
        		task.setProcessingMode(TaskProcessingMode.TYPE_READ);
        		task.setActive(TaskState.WAIT_TRANSACT.getIndex());
        		task.setMoreTransactor(true);
        		task.setRead(false);
        		task.setSendingMessage(true);
        		tasks.add(task);
        	}
    	}
    	this.saveTasks(tasks);
	}
    /*
     * 递归完成自动环节。可以完成多个自动环节串连的情况
     */
    @Transactional(readOnly=false)
    private void completeAutoTache(WorkflowInstance instance ,Execution execution){
		if(execution!=null){
			if(execution.getState().equals(Execution.STATE_ENDED)&&!execution.getProcessInstance().getState().equals(Execution.STATE_ENDED)){
				//如果参数的execution已经结束，那么重新从实例中查找当前的execution
				execution = processEngine.getExecutionService().findExecutionById(execution.getProcessInstance().getId());
			}
			for(String activityName:execution.findActiveActivityNames()){
				String tacheType = DefinitionXmlParse.getCurrentTacheType(instance.getProcessDefinitionId(),activityName);
				if(StringUtils.isNotEmpty(tacheType)&&tacheType.equals(WorkflowTacheType.AUTO_TACHE.getCode())){
					Execution tempExecution = execution.findActiveExecutionIn(activityName);
					processEngine.getExecutionService().signalExecutionById(tempExecution.getId());
					generateTaskHistory(instance.getProcessInstanceId(),tempExecution.getId(),activityName);
					completeAutoTache(instance,execution);
				}
			}
		}
    }
    
    /*
	 * 生成自动环节的历史记录
	 * @param instanceId
	 * @param activityName
	 */
	@Transactional(readOnly=false)
	private void generateTaskHistory(String instanceId,String excuteId,String tacheName){
		WorkflowInstance instance=workflowInstanceManager.getWorkflowInstance(instanceId);
		InstanceHistory ih = new InstanceHistory();
		ih.setCompanyId(instance.getCompanyId());
		ih.setType(InstanceHistory.TYPE_TASK);
		ih.setInstanceId(instanceId);
		ih.setExecutionId(excuteId);
		ih.setTaskName(tacheName);
		ih.setCreatedTime(new Date());
		StringBuilder msg = new StringBuilder();
		msg.append(dateFormat.format(ih.getCreatedTime()))
			.append(COMMA).append(PROCESS_WENT).append(tacheName);
		ih.setTransactionResult(msg.toString());
		instanceHistoryManager.saveHistory(ih);
	}
	
	/*
	 * 生成自动环节的历史记录
	 * @param instanceId
	 * @param activityName
	 */
	@Transactional(readOnly=false)
	private void generateCopyTaskHistory(String instanceId,String excuteId,String tacheName){
		WorkflowInstance instance=workflowInstanceManager.getWorkflowInstance(instanceId);
		InstanceHistory ih = new InstanceHistory();
		ih.setCompanyId(instance.getCompanyId());
		ih.setType(InstanceHistory.TYPE_AUTO);
		ih.setInstanceId(instanceId);
		ih.setExecutionId(excuteId);
		ih.setTaskName(tacheName);
		ih.setCreatedTime(new Date());
		StringBuilder msg = new StringBuilder();
		msg.append(dateFormat.format(ih.getCreatedTime()))
			.append(COMMA).append(PROCESS_WENT).append(tacheName);
		ih.setTransactionResult(msg.toString());
		instanceHistoryManager.saveHistory(ih);
	}
    
    
    @Transactional(readOnly=false)
    public void executionVariableCommand(ExecutionVariableCommand executionVariableCommand){
    	processEngine.execute(executionVariableCommand);
    }
    
    /**
     * 根据前一任务的ID查询需要指定任务的办理人的任务
     * 说明：暂时不支持并发汇聚后需要指定办理人
     * @param taskId
     * @return
     */
	public Map<String[], List<String[]>> getNextTasksCandidates(WorkflowTask task){
		if(task==null){log.debug("getNextTasksCandidates中，任务不能为null");throw new RuntimeException("getNextTasksCandidates中，任务不能为null");}
		log.debug("*** getNextTasksCandidates 方法开始");
		log.debug(new StringBuilder("*** Received parameter:[")
			.append("task:").append(task)
			.append("]").toString());
		
		
		
    	//直接为上一环节办理人指定//附加条件中需要唯一指定办理人
		Map<String[], List<String[]>> result = new HashMap<String[], List<String[]>>();
		ActivityExecution execution = (ActivityExecution) processEngine.getExecutionService().findExecutionById(task.getExecutionId());
		if(execution==null){log.debug("getNextTasksCandidates中，execution不能为null");throw new RuntimeException("getNextTasksCandidates中，execution不能为null");}
		Collection<? extends Execution> executions = execution.getExecutions();
		if(executions.isEmpty()){//同级Execution
			String activityName = execution.getActivityName();
			getCondidates(result, execution, task.getProcessInstanceId(), activityName);
		}else{//下级Execution
			for(Execution ex : executions){
				String activityName = ((ActivityExecution)ex).getActivityName();
				getCondidates(result, ex, task.getProcessInstanceId(), activityName);
			}
		}
		
		log.debug("*** getNextTasksCandidates 方法结束");
    	return result;
    }
    
	/*
	 * 根据Task查询Task的办理人
	 * @param task
	 * @param result
	 */
    @SuppressWarnings("unchecked")
	private void getCondidates(Map<String[], List<String[]>> result, Execution ex, String instanceId, String activityName){
    	log.debug("*** getCondidates 方法开始");
		log.debug(new StringBuilder("*** Received parameter:[")
			.append("execution:").append(ex)
			.append(", instanceId:").append(instanceId)
			.append(", activityName:").append(activityName)
			.append("]").toString());
		WorkflowInstance instance=workflowInstanceManager.getWorkflowInstance(instanceId);
		if(instance==null){log.debug("getCondidates中，流程实例不能为null");throw new RuntimeException("getCondidates中，流程实例不能为null");}
    	//上一环节指定
    	org.jbpm.api.task.Task jbpmTask = processEngine.getTaskService().createTaskQuery()
			.processInstanceId(instanceId).activityName(activityName).uniqueResult();
    	String isMoreTransactor = ""+DefinitionXmlParse.hasMoreTransactor(
    			ex.getProcessDefinitionId(), activityName);
    	Object assign=processEngine.getExecutionService().getVariable(ex.getId(), CommonStrings.TRANSACTOR_ASSIGNMENT);
		if(assign!=null && PRE_TRANSACTOR_ASSIGN.equals(assign.toString())){
			result.put(new String[]{isMoreTransactor, activityName},  AcsApi.getAllUsers(instance.getCompanyId()));
		}else{
			if(jbpmTask==null){log.debug("getCondidates中，jbpmTask不能为null");throw new RuntimeException("getCondidates中，jbpmTask不能为null");}
			if(CommonStrings.TRANSACTOR_ASSIGNMENT.equals(jbpmTask.getAssignee())){
				result.put(new String[]{isMoreTransactor, activityName},  AcsApi.getAllUsers(instance.getCompanyId()));
			}else if(CommonStrings.TRANSACTOR_SINGLE.equals(jbpmTask.getAssignee())){
				//附加条件指定唯一
				List<String[]> condidates = (List<String[]>) ((OpenExecution)ex).getVariable(CommonStrings.TRANSACTOR_SINGLE_CANDIDATES);
				result.put(new String[]{isMoreTransactor, activityName}, condidates );
			}
		}
    	
		
		log.debug("*** getCondidates 方法结束");
    }
    
    @Transactional(readOnly=false)
    public void setTasksTransactor(Long taskId,List<String> transcators){
    	WorkflowTask task = getTask(taskId);
    	Object assign=processEngine.getExecutionService().getVariable(task.getExecutionId(), CommonStrings.TRANSACTOR_ASSIGNMENT);
		if(assign!=null && PRE_TRANSACTOR_ASSIGN.equals(assign.toString())){
			SubProcessParse subprocessParse=(SubProcessParse)processEngine.getExecutionService().getVariable(task.getExecutionId(),CommonStrings.SUBPROCESS_PARSE);
			ActivityExecution execution=(ActivityExecution)processEngine.getExecutionService().findExecutionById(subprocessParse.getExecutionId());
			execution.removeVariable(CommonStrings.TRANSACTOR_ASSIGNMENT);
			execution.removeVariable(CommonStrings.SUBPROCESS_PARSE);
			Map<TaskTransactorCondition, String> transactor = DefinitionXmlParse.getTaskTransactor(subprocessParse.getParentDefinitionId(),subprocessParse.getActivityName());
			completeTask(task);
			this.startSubProcessWorkflow(transactor, subprocessParse,transcators);
		}else{
			setTasksTransactor(task,transcators);
		}
    }
    
    
    /**
     * 为某个环节设置办理人
     * @param task 任务
     * @param transcators 办理人列表
     */
    @Transactional(readOnly=false)
    public void setTasksTransactor(WorkflowTask task,Collection<String> transcators){
    	log.debug("*** setTasksTransactor 方法开始");
		log.debug(new StringBuilder("*** Received parameter:[")
			.append("task:").append(task)
			.append("]").toString());
		if(task==null){log.debug("为某环节设置办理人时，任务不能为null");throw new RuntimeException("为某环节设置办理人时，任务不能为null");}
		if(transcators==null){log.debug("为某环节设置办理人时，办理人集合不能为null");throw new RuntimeException("为某环节设置办理人时，办理人集合不能为null");}
		Set<String> transcatorsSet = new HashSet<String>();
		transcatorsSet.addAll(transcators);
    	ActivityExecution execution = (ActivityExecution) processEngine.getExecutionService().findExecutionById(task.getExecutionId());
    	org.jbpm.api.task.Task jbpmTask = processEngine.getTaskService().createTaskQuery()
		.processInstanceId(task.getProcessInstanceId())
		.activityName(execution.getActivityName()).uniqueResult();   
    	if(jbpmTask==null){log.debug("为某环节设置办理人时，jbpmTask不能为null");throw new RuntimeException("为某环节设置办理人时，jbpmTask不能为null");}
    	if(transcatorsSet.size()>0)((OpenExecution)processEngine.getExecutionService()
				.findExecutionById(jbpmTask.getExecutionId())).removeVariable(CommonStrings.TRANSACTOR_SINGLE_CANDIDATES);
    	
    	Integer groupNum=getTaskMaxGroupNum(task.getProcessInstanceId(),jbpmTask.getActivityName(),task.getCompanyId());
    	groupNum++;
    	for(String transcator:transcatorsSet){
    		if(transcator.contains(":")){
    			String[] transacts=transcator.split(":");
    			WorkflowTask wfTask=createTask(task.getProcessInstanceId(), jbpmTask.getExecutionId(), transacts[0] ,jbpmTask.getActivityName(),groupNum);
    			String titleInfo=setTaskTransactorInfo(transcator, wfTask);
    			String processId= processEngine.getExecutionService().findProcessInstanceById(wfTask.getProcessInstanceId()).getProcessDefinitionId();
    			addTitle(wfTask, processId, titleInfo);
    			saveTask(wfTask);
    		}else{
    			saveTask(createTask(task.getProcessInstanceId(), jbpmTask.getExecutionId(), transcator ,jbpmTask.getActivityName(),groupNum));
    		}
    		if(jbpmTask.getAssignee().equals(CommonStrings.TRANSACTOR_ASSIGNMENT)||jbpmTask.getAssignee().equals(CommonStrings.TRANSACTOR_SINGLE)){
        		processEngine.getTaskService().assignTask(jbpmTask.getId(),transcator);
        	}
    	}
    	
    	task.setActive(TaskState.COMPLETED.getIndex());// 任务完成状态
    	saveTask(task);
    	//特事特办
		doSpecialTask(task);
		//完成任务并生成wf任务流转历史
		completeTask(task);
    	// 保存流转历史
    	generateHistory(task, null);
    	WorkflowInstance wi = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId(),task.getCompanyId());
    	if(wi==null){log.debug("为某环节设置办理人时，流程实例不能为null");throw new RuntimeException("为某环节设置办理人时，流程实例不能为null");}
    	//设置流程实例当前环节
    	
    	if(wi.getProcessState()==ProcessState.UNSUBMIT){
    		wi.setProcessState(ProcessState.SUBMIT);
    		this.workflowInstanceManager.saveWorkflowInstance(wi);
    		FormView form = formViewManager.getFormView(wi.getFormId());
    		if(form==null){log.debug("为某环节设置办理人时，表单不能为null");throw new RuntimeException("为某环节设置办理人时，表单不能为null");}
    		if(form.isStandardForm()){
    			if(form.getDataTable()==null){log.debug("为某环节设置办理人时，表单对应的数据表不能为null");throw new RuntimeException("为某环节设置办理人时，表单对应的数据表不能为null");}
    			Object entity = generalDao.getObject(form.getDataTable().getEntityName(), wi.getDataId());
    			try {
					BeanUtils.setProperty(entity, "workflowInfo.processState", ProcessState.SUBMIT);
					generalDao.save(entity);
				} catch (IllegalAccessException e) {
					log.debug(e);
					throw new RuntimeException();
				} catch (InvocationTargetException e) {
					log.debug(e);
					throw new RuntimeException();
				}
    		}else{
    			jdbcDao.updateTable("UPDATE "+form.getDataTable().getName()+" SET PROCESS_STATE="+ProcessState.SUBMIT.getIndex()+" WHERE  ID="+wi.getDataId());
    		}
    	}
    	
    	setInstanceCurrentActivity(wi, task);
    	//设置流程实例上一环节相关信息
		setWorkflowPreviousAcitivity(wi,task);
    	executeAfterTaskCompleted(task);
    	
    	log.debug("*** setTasksTransactor 方法结束");
    } 
    
    /**
     * 当办理人为”上一环节办理人指定“时，调用此方法修改办理人
     * @param task
     * @param transactor
     */
    @Transactional(readOnly=false)
    public void setTasksTransactor(Long preTaskId, Map<String, List<String>> taskCondidates){
    	WorkflowTask task = getTask(preTaskId);
    	completeTask(task);
    	Object assign=processEngine.getExecutionService().getVariable(task.getExecutionId(), CommonStrings.TRANSACTOR_ASSIGNMENT);
		if(assign!=null && PRE_TRANSACTOR_ASSIGN.equals(assign.toString())){
			SubProcessParse subprocessParse=(SubProcessParse)processEngine.getExecutionService().getVariable(task.getExecutionId(),CommonStrings.SUBPROCESS_PARSE);
			ActivityExecution execution=(ActivityExecution)processEngine.getExecutionService().findExecutionById(subprocessParse.getExecutionId());
			execution.removeVariable(CommonStrings.TRANSACTOR_ASSIGNMENT);
			execution.removeVariable(CommonStrings.SUBPROCESS_PARSE);
			Map<TaskTransactorCondition, String> transactor = DefinitionXmlParse.getTaskTransactor(subprocessParse.getParentDefinitionId(),subprocessParse.getActivityName());
			Collection<String> transactors=new ArrayList<String>();
			for(Map.Entry<String, List<String>> candidates : taskCondidates.entrySet()){
				if(subprocessParse.getActivityName().equals(candidates.getKey().toString()))transactors=candidates.getValue();
	    	}
			this.startSubProcessWorkflow(transactor, subprocessParse,transactors);
		}else{
			setTasksTransactors(preTaskId,taskCondidates);
		}
    }
    
    /**
     * 当办理人为”上一环节办理人指定“时，调用此方法修改办理人
     * @param task
     * @param transactor
     */
    @Transactional(readOnly=false)
    public void setTasksTransactors(Long preTaskId, Map<String, List<String>> taskCondidates){
    	log.debug("*** setTasksTransactor 方法开始");
		log.debug(new StringBuilder("*** Received parameter:[")
			.append("preTaskId:").append(preTaskId)
			.append("]").toString());
    	
    	WorkflowTask task = getTask(preTaskId);
    	ActivityExecution execution = (ActivityExecution) processEngine.getExecutionService().findExecutionById(task.getExecutionId());
    	List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
    	StringBuilder taskNames = new StringBuilder();
    	for(Map.Entry<String, List<String>> candidates : taskCondidates.entrySet()){
    		taskNames.append(candidates.getKey()).append(",");
    		org.jbpm.api.task.Task jbpmTask = processEngine.getTaskService().createTaskQuery()
				.processInstanceId(task.getProcessInstanceId())
	    		.activityName(candidates.getKey()).uniqueResult();
    		generateTask(tasks, task.getProcessInstanceId(), jbpmTask.getExecutionId(), candidates.getKey(), candidates.getValue(),task.getCompanyId());
			processEngine.execute(new TaskAssigneeCommand(jbpmTask, ""));
	    	//清除execution变量
	    	((OpenExecution)processEngine.getExecutionService()
				.findExecutionById(jbpmTask.getExecutionId())).removeVariable(CommonStrings.TRANSACTOR_SINGLE_CANDIDATES);
    	}
    	boolean isSameGroup=false;
    	//并发任务的其他任务
    	Map<ActivityExecution, String> map = getCurrentExecutions(execution, null);
    	for(String taskName : map.values()){
    		Integer groupNum=getTaskMaxGroupNum(task.getProcessInstanceId(), taskName,task.getCompanyId());
    		if(!isSameGroup)groupNum++;
    		isSameGroup=true;
    		if(!taskNames.toString().contains(taskName+',')){
    			List<org.jbpm.api.task.Task> jbpmList = processEngine.getTaskService().createTaskQuery()
	        		.activityName(taskName).processInstanceId(execution.getProcessInstance().getId()).list();
    			String processingMode = DefinitionXmlParse.getTaskProcessingMode(
    					execution.getProcessDefinitionId(), taskName);
    			for(org.jbpm.api.task.Task t: jbpmList){
    				WorkflowTask newtask = createTask(task.getProcessInstanceId(), t.getExecutionId(), t.getAssignee(), taskName, processingMode, false,groupNum);
    	    		if(newtask!=null) tasks.add(newtask);
    			}
    		}
    	}
    	saveTasks(tasks);
    	task.setActive(TaskState.COMPLETED.getIndex());// 任务完成状态
    	saveTask(task);
    	
    	// 保存流转历史
    	generateHistory(task, null);
    	WorkflowInstance wi = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId(),task.getCompanyId());
    	//设置流程实例当前环节
    	
    	if(wi.getProcessState()==ProcessState.UNSUBMIT){
    		wi.setProcessState(ProcessState.SUBMIT);
    		this.workflowInstanceManager.saveWorkflowInstance(wi);
    		FormView form = formViewManager.getFormView(wi.getFormId());
    		if(form.isStandardForm()){
    			Object entity = generalDao.getObject(form.getDataTable().getEntityName(), wi.getDataId());
    			try {
					BeanUtils.setProperty(entity, "workflowInfo.processState", ProcessState.SUBMIT);
					generalDao.save(entity);
				} catch (IllegalAccessException e) {
					log.debug(e);
					throw new RuntimeException();
				} catch (InvocationTargetException e) {
					log.debug(e);
					throw new RuntimeException();
				}
    		}else{
    			jdbcDao.updateTable("UPDATE "+form.getDataTable().getName()+" SET PROCESS_STATE="+ProcessState.SUBMIT.getIndex()+" WHERE  ID="+wi.getDataId());
    		}
    	}
    	
    	setInstanceCurrentActivity(wi, task);
    	//设置流程实例上一环节相关信息
		setWorkflowPreviousAcitivity(wi,task);
    	executeAfterTaskCompleted(task);
    	
    	log.debug("*** setTasksTransactor 方法结束");
    }
    
    @Transactional(readOnly=false)
    private void generateTask(List<WorkflowTask> tasks, String instanceId, 
    		String executionId, String activityName, List<String> taskCondidates,Long companyId){
    	WorkflowTask targetTask = null;
    	Integer groupNum=getTaskMaxGroupNum(instanceId, activityName,companyId);
    	groupNum++;
    	for(String condidate : taskCondidates){
    		targetTask = createTask(instanceId, executionId, condidate, activityName,groupNum);
    		tasks.add(targetTask);
    	}
    }
    
    
    /**
     * 办理人更改
     * @param taskId
     * @param transactor
     */
    @Transactional(readOnly=false)
    public void changeTransactor(Long taskId, String transactor){
    	WorkflowTask task = getTask(taskId);
		//被指派人的新任务
    	WorkflowTask targetTask = task.clone();
    	//设置指派人任务已完成
    	task.setActive(TaskState.CANCELLED.getIndex());
    	//新任务办理人
    	targetTask.setId(null);
    	targetTask.setRead(false);
    	targetTask.setCreatedTime(new Date());
    	targetTask.setTransactor(transactor);
    	User user = userManager.getUserByLoginName(transactor);
		if(user!=null){
			targetTask.setTransactorName(user.getName());
    	}
    	//任务委托设置
		String processId= processEngine.getExecutionService().findProcessInstanceById(task.getProcessInstanceId()).getProcessDefinitionId();
		String delegateTransactor = delegateManager.getDelegateMainName(
				task.getCompanyId(), transactor, processId, task.getName());
		if(delegateTransactor != null){
			targetTask.setTrustor(transactor);
			targetTask.setTrustorName(ApiFactory.getAcsService().getUserByLoginName(transactor).getName());
			targetTask.setTransactor(delegateTransactor);
			User targetUser = userManager.getUserByLoginName(delegateTransactor);
			if(targetUser!=null){
				targetTask.setTransactorName(targetUser.getName());
	    	}
		}
    	targetTask.setSendingMessage(true);
    	saveTask(task);
    	saveTask(targetTask);
    	
    	WorkflowDefinition wfDef = workflowDefinitionManager.getWorkflowDefinitionByProcessId(processId);
    	WorkflowType type=workflowTypeManager.getWorkflowType(wfDef.getTypeId());
    	//消息提醒
		sendMessage(targetTask, type);
		//*******************邮件通知*************************
		sendMail(task,processId);
		//*******************生成更改办理人和委托流转历史*************************
		generateChangeTransactorHistory(task,transactor,targetTask,delegateTransactor);
    }
    
    /**
     * 生成更改办理人流转历史
     * @param taskId
     * @param transactor
     */
    private void generateChangeTransactorHistory(WorkflowTask task,
			String transactor,WorkflowTask delegateTask,String trustee) {
	        StringBuilder historyMessage = new StringBuilder();
			if(StringUtils.isNotEmpty(trustee)){//生成更改办理人和委托的流转历史
				historyMessage.append(acsUtils.getUserByLoginName(delegateTask.getTrustor()).getName())
				.append("已把任务委托给了")
				.append(delegateTask.getTransactorName()).append("。\n")
				.append(dateFormat.format(new Date()))
				.append(COMMA).append(ContextUtils.getUserName()).append("把办理人")
			    .append(task.getTransactorName()).append("更改成")
			    .append(acsUtils.getUserByLoginName(transactor).getName()).append(DELTA_START)
			    .append(task.getName()).append(DELTA_END).append("\n");
			}else{//生成指派流转历史
				historyMessage.append(dateFormat.format(new Date()))
				.append(COMMA).append(ContextUtils.getUserName()).append("把办理人")
			    .append(task.getTransactorName()).append("更改成")
			    .append(acsUtils.getUserByLoginName(transactor).getName()).append(DELTA_START)
			    .append(task.getName()).append(DELTA_END).append("\n");
			}
			
			InstanceHistory history = new InstanceHistory(task.getCompanyId(), task.getProcessInstanceId(), InstanceHistory.TYPE_TASK, historyMessage.toString(), task.getName());
			history.setEffective(false);
			history.setCreatedTime(new Date());
			history.setExecutionId(task.getProcessInstanceId());
			
	        instanceHistoryManager.saveHistory(history);
		
	}

	/**
     * 交办任务
     * @param taskId
     * @param transactor
     */
    @Transactional(readOnly=false)
    public void assign(Long taskId, String transactor){
    	workflowTaskService.assign(taskId, transactor);
    }
    
    /**
     * 交办任务
     * @param taskId
     * @param transactor
     */
    @Transactional(readOnly=false)
    public void assign(Long taskId, List<String> transactors){
    	WorkflowTask task = getTask(taskId);
    	List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
    	for(String transactor:transactors){
			//被指派人的新任务
        	WorkflowTask targetTask = task.clone();
        	//新任务办理人
        	targetTask.setId(null);
        	targetTask.setRead(false);
        	targetTask.setProcessingMode(TaskProcessingMode.TYPE_EDIT);
        	targetTask.setCreatedTime(new Date());
        	targetTask.setTransactor(transactor);
        	User targetUser = userManager.getUserByLoginName(targetTask.getTransactor());
        	if(targetUser!=null){
        		targetTask.setTransactorName(targetUser.getName());
        	}
        	tasks.add(targetTask);
    	}
    	saveTasks(tasks);
    	//设置指派人任务已完成
    	task.setTaskProcessingResult(TaskProcessingResult.ASSIGN);
    	task.setActive(TaskState.ASSIGNED.getIndex());
    	task.setTransactDate(new Date());
    	StringBuilder result=new StringBuilder(CommonStrings.ASSIGN_TO);
    	for(WorkflowTask wfTask:tasks){
    		result.append(wfTask.getId()).append(",");
    	}
    	if(result.lastIndexOf(",")>=0){
    		task.setNextTasks(result.substring(0, result.lastIndexOf(",")));
    	}
    	saveTask(task);
    }
    
    /**
     * 通过自定义实体获取填写了数据的HTML片段
     * @param entity extends FormFlowable
     * @param htmlParameterName html片段中变量的key eg: obj.name,则htmlParameterName为obj
     * @return
     */
    public String getHtmlByData(FormFlowable entity){
    	WorkflowInstance wi = workflowInstanceManager.getWorkflowInstance(entity.getWorkflowInfo().getWorkflowId(),entity.getCompanyId());
    	FormView form = formViewManager.getFormView(wi.getFormId());
    	
    	String html = form.getHtml();
    	return FreeMarkertUtils.render(entity, html);
    }
    
    /**
	 * 根据流程名称查询最新的流程定义表单
	 * @param workflowDefinitionName
	 * @return
	 */
    public String getLastHtmlByWorkflowDefinitionName(FormFlowable entity, String processDefinitionName){
    	WorkflowDefinition defintion = workflowDefinitionManager.getLatestVersion(processDefinitionName, entity.getCompanyId());
    	String html = formViewManager.getCurrentFormViewByCodeAndVersion(defintion.getFormCode(), defintion.getVersion()).getHtml();
    	return FreeMarkertUtils.render(entity, html);
    }
    
    /**
     * 环节办理过程中办理人是否可以删除流程实例
     * @return
     */
    public boolean canDeleteByTask(WorkflowInstance workflow, String taskName){
    	return workflowRightsManager.workflowDeleteRight(workflow, taskName);
    }
    
    /**
	 * 加签
	 */
    @Transactional(readOnly=false)
	public void generateTask(Long taskId,Collection<String> transacts,TaskSource taskSource){
		WorkflowTask task = getTask(taskId);
		if(task==null){log.debug("加签时，任务不能为null");throw new RuntimeException("加签时，任务不能为null");}
		Set<String> transactors=new HashSet<String>();
		if(transacts!=null)transactors.addAll(transacts);
		//得到当前办理人集合
		List<String[] > currentTransactors=workflowTaskService.getActivityTaskTransactors(task.getProcessInstanceId(), task.getCompanyId());
		//得到当前委托人集合
		List<String> currentPrincipals=workflowTaskService.getActivityTaskPrincipals(task.getProcessInstanceId(), task.getCompanyId());
		
		//得到所有当前办理人和委托人集合
		Set<String> currentTransacts=new HashSet<String>();
		for(int i=0;i<currentTransactors.size();i++){
			Object[] transactor1=currentTransactors.get(i);
			currentTransacts.add(transactor1[0].toString());
		}
		if(currentPrincipals!=null)currentTransacts.addAll(currentPrincipals);
		
		List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
		Integer groupNum=getTaskMaxGroupNum(task.getProcessInstanceId(), task.getName(),task.getCompanyId());
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		String processId= instance.getProcessDefinitionId();
		Assert.notNull( ContextUtils.getCompanyId(),"加签时，公司id不能为null");
		//根据受托人获得委托人集合
		List<String> consigners=delegateManager.getConsignerByTrustee(task.getTransactor(), ContextUtils.getCompanyId(), processId, task.getName());
		//得到受托人姓名的集合
		List<String> historyTransactors = new ArrayList<String>();
		
		for(String transactor:transactors){
			if(StringUtils.isNotEmpty(transactor)){
				if(CommonStrings.ALL_USER.equals(transactor)){//加签所有人
					allUsersGenerateTask(task,tasks,groupNum,currentTransacts,consigners,historyTransactors,taskSource);
				}else{
					//如果当前环节办理人包括当前用户，并且任务未完成，则不生成加签任务！0:等待处理  1:等待设置办理人  4:待领取  6：待选择环节
					if(currentTransacts.contains(transactor)&&ContextUtils.getLoginName().equals(transactor) && (task.getActive()==0 || task.getActive()==1 || task.getActive()==4 || task.getActive()==6)){
						continue;
					}
					//如果是委托任务，且委托人等于选择的人transactor，则不生成任务（bkyoa要求的）
					if(transactor.equals(task.getTrustor()))continue;
					//判断用户是否已有任务，若没有则生成任务,或者当前办理人加签给自己并且任务状态为已完成时也可生成任务
					if(!currentTransacts.contains(transactor)||ContextUtils.getLoginName().equals(transactor)){
						//判断用户是否已有任务，若没有则生成任务
						if(!consigners.contains(transactor)||StringUtils.isEmpty(task.getTrustor())){//源任务不是委托任务或transactor不是当前用户的委托人则生成任务
							//生成任务
							usersGenerateTask(task,tasks,transactor,groupNum,historyTransactors,taskSource,transactors);
						}
					}
				}
			}
		}
		saveTasks(tasks);
		//生成加签流转历史
		generateAddSignerHistory(task,historyTransactors);
	}
    
    
    /**
	 *生成加签流转历史
	 * @param task
	 * @param transactor
	 */
	private void generateAddSignerHistory(WorkflowTask task, 
			List<String> historyTransactors) {
		
		StringBuilder historyMessage = new StringBuilder();
		historyMessage.append(dateFormat.format(new Date()))
		.append(COMMA).append(ContextUtils.getUserName()).append("给:")
		.append(getTansactorNames(historyTransactors)).append("加签。")
		.append(DELTA_START)
		.append(task.getName()).append(DELTA_END).append("\n");
		
		InstanceHistory history = new InstanceHistory(task.getCompanyId(), task.getProcessInstanceId(), InstanceHistory.TYPE_TASK, historyMessage.toString(), task.getName());
		history.setEffective(false);
		history.setCreatedTime(new Date());
		history.setExecutionId(task.getProcessInstanceId());
		
        instanceHistoryManager.saveHistory(history);
		
	}
    
    private String getTansactorNames(List<String> historyTransactors) {
		String result = "";
		for(String name : historyTransactors ){
			result+=name+",";
		}
		return StringUtils.isEmpty(result)?"":result.substring(0,result.length()-1);
	}

	private void allUsersGenerateTask(WorkflowTask task,
    		List<WorkflowTask> tasks,
    		Integer groupNum,
    		Set<String> currentTransacts,
    		List<String> consigners,
    		List<String> historyTransactors,TaskSource taskSource){
    	WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
    	String processId= instance.getProcessDefinitionId();
		List<com.norteksoft.product.api.entity.User> users=ApiFactory.getAcsService().getUsersByCompany(task.getCompanyId());
    	for(com.norteksoft.product.api.entity.User user:users){
    		//如果用户是当前办理人，并且任务未完成，则不生成加签任务！0:等待处理  1:等待设置办理人  4:待领取  6：待选择环节
    		if(currentTransacts.contains(user.getLoginName())&&ContextUtils.getLoginName().equals(user.getLoginName()) && (task.getActive()==0 || task.getActive()==1 || task.getActive()==4 || task.getActive()==6)){
    			continue;
    		}
    		//判断用户是否已有任务，若没有则生成任务,或者当前办理人加签给自己并且任务状态为已完成时也可生成任务
    		if(!currentTransacts.contains(user.getLoginName())||ContextUtils.getLoginName().equals(user.getLoginName())){
    			if(!consigners.contains(user.getLoginName())||StringUtils.isEmpty(task.getTrustor())){//源任务不是委托任务或user不是当前用户的委托人则生成任务
    				//任务委托设置
    				String delegateTransactor = delegateManager.getDelegateMainName(
    						task.getCompanyId(), user.getLoginName(), processId, task.getName());
    				boolean shouldSaveTask = true;
    				WorkflowTask targetTask = task.clone();
    				targetTask.setId(null);
    				String titleInfo=setTaskTransactorInfo(user.getLoginName(), targetTask);
    				if(delegateTransactor != null){
    					boolean isSameDept=trustorTransactorSameDept(targetTask.getTransactor(),delegateTransactor);
    					if(isSameDept){//如果委托人、受托人是同一部门，且当前传过来的人员列表包含受托人时，则委托人不再生成任务（当然受托人也不用生成了）,因为是所有人，所以只需判断委托人、受托人是否是同一部门
							shouldSaveTask=false;
    					}
    				}
					User targetUser = userManager.getUserByLoginName(targetTask.getTransactor());
					if(targetUser!=null){
						String userName = targetUser.getName();
						targetTask.setTransactorName(userName);
						historyTransactors.add(userName);
					}
					targetTask.setCreatedTime(new Date());
					targetTask.setSendingMessage(true);
					//设置标题
					addTitle(targetTask, processId,titleInfo);
					WorkflowDefinition wfDef = workflowDefinitionManager.getWorkflowDefinitionByProcessId(processId);
					//流程类型
					WorkflowType type=null;
					if(wfDef!=null){
						targetTask.setGroupName(wfDef.getName());
						targetTask.setCustomType(wfDef.getCustomType());
						//流程类型
						type=workflowTypeManager.getWorkflowType(wfDef.getTypeId());
						if(type!=null)targetTask.setCategory(type.getName());
					}
					targetTask.setTrustor(null);
					targetTask.setTrustorName(null);
					if(delegateTransactor != null){
						targetTask.setTrustor(targetTask.getTransactor());
						User targetTaskUser = userManager.getUserByLoginName(targetTask.getTransactor());
						if(targetTaskUser!=null)targetTask.setTrustorName(targetTaskUser.getName());
						targetTask.setTransactor(delegateTransactor);
						User transacorUser=userManager.getUserByLoginName(targetTask.getTransactor());
						if(transacorUser!=null){
							targetTask.setTransactorName(transacorUser.getName());
						}
						//生成委托流转历史
						generateDelegateHistory(targetTask);
					}else{
						targetTask.setTrustor(null);
						targetTask.setTrustorName(null);
					}
					targetTask.setGroupNum(groupNum);
					targetTask.setRead(false);
					targetTask.setTaskSource(taskSource);
					//是否显示，bkyoa特制功能
					targetTask.setVisible(shouldSaveTask);
					
					//*******************消息提醒*************************
					sendMessage(targetTask,type);
					//*******************邮件通知*************************
					sendMail(task,processId);
					tasks.add(targetTask);
    			}
    		}
    	}
    }
    
    private void usersGenerateTask(WorkflowTask task,
    		List<WorkflowTask> tasks,
    		String transactor,
    		Integer groupNum,
    		List<String> historyTransactors,TaskSource taskSource,Set<String> transactors){
    	WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
    	String processId= instance.getProcessDefinitionId();
    		WorkflowTask targetTask = task.clone();
    		//transactor的值“办理人登录名”或“办理人登录名:用户自定义信息”或“办理人登录名:$custom:customInfo$title:titleInfo”
			targetTask.setId(null);
			String titleInfo=setTaskTransactorInfo(transactor, targetTask);
			//任务委托设置
			String delegateTransactor = delegateManager.getDelegateMainName(
					task.getCompanyId(), targetTask.getTransactor(), processId, task.getName());
			boolean shouldSaveTask = shouldSaveTask(task.getCompanyId(),targetTask.getTransactor(),transactors,task.getProcessInstanceId(),delegateTransactor,true);
			User user=userManager.getUserByLoginName(targetTask.getTransactor());
			if(user!=null){
				targetTask.setTransactorName(user.getName());
				historyTransactors.add(user.getName());
			}
			targetTask.setCreatedTime(new Date());
			targetTask.setSendingMessage(true);
			//设置标题
			addTitle(targetTask, processId,titleInfo);
			WorkflowDefinition wfDef = workflowDefinitionManager.getWorkflowDefinitionByProcessId(processId);
			//流程类型
			WorkflowType type=null;
			if(wfDef!=null){
				targetTask.setGroupName(wfDef.getName());
				targetTask.setCustomType(wfDef.getCustomType());
				//流程类型
				type=workflowTypeManager.getWorkflowType(wfDef.getTypeId());
				if(type!=null)targetTask.setCategory(type.getName());
			}
			targetTask.setTrustor(null);
			targetTask.setTrustorName(null);
			if(delegateTransactor != null){
				targetTask.setTrustor(targetTask.getTransactor());
				user =  userManager.getUserByLoginName(targetTask.getTransactor());
				if(user!=null)targetTask.setTrustorName(user.getName());
				targetTask.setTransactor(delegateTransactor);
				user=userManager.getUserByLoginName(targetTask.getTransactor());
				if(user!=null){
					targetTask.setTransactorName(user.getName());
				}
				//生成委托流转历史
				generateDelegateHistory(targetTask);
			}else{
				targetTask.setTrustor(null);
				targetTask.setTrustorName(null);
			}
			targetTask.setGroupNum(groupNum);
			targetTask.setRead(false);
			targetTask.setTaskSource(taskSource);
			//是否显示，bkyoa特制功能
			targetTask.setVisible(shouldSaveTask);
			
			//*******************消息提醒*************************
			sendMessage(targetTask,type);
			//*******************邮件通知*************************
			sendMail(task,processId);
			tasks.add(targetTask);
    }
    private boolean shouldSaveTask(Long companyId,String taskName,Set<String> transactors,String processInstanceId,String delegateTransactor,boolean moreTransactor){
		boolean shouldSaveTask = true;
		//bkyoa特制功能 ：当是多人办理环节时，如果委托人、受托人是同一部门，且当前传过来的人员列表包含受托人时或受托人已有任务时，则委托人不再生成任务（当然受托人也不用生成了）
		if(moreTransactor){//多人办理环节才需要该判断
			if(delegateTransactor != null){
				boolean isSameDept=trustorTransactorSameDept(taskName,delegateTransactor);
				if(isSameDept){//如果委托人、受托人是同一部门，且当前传过来的人员列表包含受托人时或受托人已有任务时，则委托人不再生成任务（当然受托人也不用生成了）
					if(transactors!=null&&transactors.contains(delegateTransactor)){//当前传过来的人员列表包含受托人时,不生成任务
						shouldSaveTask=false;
					}else{
						WorkflowTask mytask=workflowTaskService.getMyTask(processInstanceId, companyId, delegateTransactor);
						if(mytask!=null){//如果受托人已有任务
							shouldSaveTask=false;
						}
					}
				}
			}
		}
		return shouldSaveTask;
    }
    private String setTaskTransactorInfo(String transactor, WorkflowTask targetTask){
    	//transactor的值“办理人登录名”或“办理人登录名:xxx”或“办理人登录名:$custom:xxx$title:xxx”
    	String titleInfo=null;
    	if(transactor.contains(":")){
			String[] transacts=transactor.split(":");
			targetTask.setTransactor(transacts[0]);
			boolean containCustom=transactor.contains(TASK_CUSTOM_INFO);
			boolean containTitle=transactor.contains(TASK_TITLE_INFO);
			if(containCustom||containTitle){//办理人登录名:$custom:xxx$title:xxx
				if(containCustom){//$custom(用户自定义信息，如部门名称、角色名称等等任何信息)
					String remark=transactor.split("\\"+TASK_CUSTOM_INFO+":")[1];
					if(containTitle){
						titleInfo=remark.split("\\"+TASK_TITLE_INFO+":")[1];
						remark=remark.split("\\"+TASK_TITLE_INFO+":")[0];
					}
					targetTask.setRemark(remark);//将$custom:的信息放入任务的扩展字段remark中
				}else if(containTitle){
					titleInfo=transactor.split("\\"+TASK_TITLE_INFO+":")[1];
				}
			}else{//办理人登录名:xxx
				targetTask.setRemark(transacts[1]);
			}
		}else{//办理人登录名
			targetTask.setTransactor(transactor);
		}
    	return titleInfo;
    }
	/**
	 * 获得与该任务是同一环节的所有未办理任务
	 */
	public List<WorkflowTask> getCountersigns(Long id){
		return workflowTaskService.getCountersigns(id);
	}
	
	/**
	 * 获得与该任务是同一环节的所有未办理任务
	 */
	public List<WorkflowTask> getProcessCountersigns(Long id){
		return workflowTaskService.getProcessCountersigns(id);
	}
	
	/**
	 * 获得该会签环节的所有办理人
	 */
	public List<String> getCountersignsHandler(Long id,Integer handlingState){
		return workflowTaskService.getCountersignsHandler(id,handlingState);
	}
	
	@Transactional(readOnly=false)
	public void deleteCountersignHandler(Long taskId, Collection<String> users) {
		workflowTaskService.deleteCountersignHandler(taskId, users);
	}
	
	/**
	 * 删除任务
	 */
	@Transactional(readOnly=false)
	public void deleteWorkflowTask(List<Long> ids){
		workflowTaskService.deleteWorkflowTask(ids);
	}

    /**
     * 取回任务
     * @param taskId
     * @return 是否成功
     */
	@Transactional(readOnly=false)
    public String retrieve(Long taskId){
    	log.debug("*** retrieve 方法开始");
    	
    	Assert.notNull(taskId,"取回任务时任务id不能为null");
    	//FIXME 使用国际化key替换中文字符
    	WorkflowTask task = workflowTaskService.getTask(taskId);
    	Assert.notNull(task,"取回任务时任务不能为null");
    	// 判断后面的环节是否已经办理//a.流程已经结束，b.后面的环节已阅
    	WorkflowInstance wfi = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId(),task.getCompanyId());
    	if(wfi==null){log.debug("取回任务时，流程实例不能为null");throw new RuntimeException("取回任务时，流程实例不能为null");}
    	if(wfi.getProcessState()==ProcessState.END || wfi.getProcessState()==ProcessState.MANUAL_END || wfi.getProcessState()==ProcessState.PAUSE){
    		if(wfi.getParentProcessId()==null){
    			return "流程已经结束或者被取消或者被暂停，不能取回";
    		}else{
    			return "子流程已经结束或者被取消或者被暂停，不能取回";
    		}
    	}
    	if(isSubProcessTask(task)){
    		return "下一环节是子流程环节，不能取回";
    	}
    	// 会签、投票特殊处理
    	if(TaskProcessingMode.TYPE_COUNTERSIGNATURE.toString().equals(task.getProcessingMode()) ||
    			TaskProcessingMode.TYPE_VOTE.toString().equals(task.getProcessingMode())){
    		return "会签、投票环节不能取回";
    	}
    	if(task.getMoreTransactor()){
    		return "多人办理环节不能取回";
    	}
    	Execution execut=processEngine.getExecutionService().findExecutionById(task.getExecutionId());
		if((execut!=null && task.getNextTasks()==null)||(execut==null && task.getNextTasks()!=null)){
			return "并发流程的分支已结束不能取回";
		}
    	String result = "任务已取回";
    	if(isNextTasksRead(task)){
    		// 已阅：用户不能取回
    		result = "下环节任务已阅，取回失败";
    	}else{
    		//取回任务
    		// 1. 使JBPM环节回到该任务
    		Activity activity = processEngine.execute(new GetBackCommand(task.getExecutionId(), task.getName()));
    		if(activity == null){
    			//不支持并发取回
    			result = "并发流程不能取回";
    		}else{
	    		// 2. 修改后面的环节为被取回(或删掉)
	    		String[] taskNames = task.getNextTasks().split(",");
	    		workflowTaskService.deleteTasksByName(task.getCompanyId(), task.getProcessInstanceId(), taskNames);
	    			
	    		//环节跳转后task.getNextTasks()获得的环节名不对了
	    		List<String> names=workflowTaskService.getActiveTaskNameWithoutSpecial(task.getProcessInstanceId());
	    			taskNames=names.toArray(new String[names.size()]);
	    			workflowTaskService.deleteTasksByName(task.getCompanyId(), task.getProcessInstanceId(), taskNames);
	    			
	    		//FIXME 判断任务是否需要指定办理人？
	    		// 3 设置办理为当前取回的任务的办理人
	    		ActivityExecution execution = (ActivityExecution) processEngine.getExecutionService().findExecutionById(task.getExecutionId());
	    		if(execution==null){log.debug("取回任务时，execution不能为null");throw new RuntimeException("取回任务时，execution不能为null");}
	    		org.jbpm.api.task.Task jbpmTask = processEngine.getTaskService().createTaskQuery()
	    		.processInstanceId(task.getProcessInstanceId())
	    		.activityName(execution.getActivityName()).uniqueResult();   
	    		
	    		if(jbpmTask==null){log.debug("取回任务时，jbpmTask不能为null");throw new RuntimeException("取回任务时，jbpmTask不能为null");}
        		processEngine.getTaskService().assignTask(jbpmTask.getId(),task.getTransactor());
	    		// 4. 修改本任务为未完成(删除任务)
	    		task.setActive(TaskState.WAIT_TRANSACT.getIndex());
	    		wfi.setInstanceTitle(task.getTitle());
	    		//取回的的任务,不能退回
	    		wfi.setPreviousActivity(null);
	    		wfi.setPreviousActivityTitle(null);
	    		// 5 删除流转历史
	    		instanceHistoryManager.deleteHistoryByTask(task.getCompanyId(), task.getProcessInstanceId(), task.getId(), taskNames);
	    		// 5 删除流转历史
	    		opinionDao.deleteOpinionsByTask(task.getCompanyId(), task.getProcessInstanceId(), task.getId());
	    		// 6 修改实体数据中的流程实例的一些信息
	    		WorkflowInstance instance=workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId(),task.getCompanyId());
	    		if(instance==null){log.debug("取回任务时，流程实例不能为null");throw new RuntimeException("取回任务时，流程实例不能为null");}
	    		WorkflowDefinition wfDef=workflowDefinitionManager.getWfDefinition(instance.getWorkflowDefinitionId());
	    		if(wfDef==null){log.debug("取回任务时，流程定义实体不能为null");throw new RuntimeException("取回任务时，流程定义实体不能为null");}
	    		FormView formView=formViewManager.getCurrentFormViewByCodeAndVersion(wfDef.getFormCode(),wfDef.getFromVersion());
	    		if(formView==null){log.debug("取回任务时，表单不能为null");throw new RuntimeException("取回任务时，表单不能为null");}
	    		if(formView.isStandardForm()){
	    			try{
	    				if(formView.getDataTable()==null){log.debug("取回任务时，表单对应的数据表不能为null");throw new RuntimeException("取回任务时，表单对应的数据表不能为null");}
	    				Object entity = generalDao.getObject(formView.getDataTable().getEntityName(), instance.getDataId());
	    				BeanUtils.setProperty(entity, "workflowInfo.currentActivityName", task.getName());
	    				generalDao.save(entity);
	    			}catch (Exception e) {
						throw new RuntimeException(e);
					} 
	    		}
	    		task.setNextTasks(null);
	    		task.setVisible(true);
	    		saveTask(task);
	    		WorkflowType type=workflowTypeManager.getWorkflowType(wfDef.getTypeId());
	    		//发送消息
	    		sendMessage(task, type);
	    		//*******************邮件通知*************************
				sendMail(task,wfDef.getProcessId());
	    		//业务补偿
	    		retrieveTaskSet(instance,task);
	    		workflowInstanceManager.saveWorkflowInstance(wfi);
	    		execution.removeVariable(CommonStrings.TRANSACTOR_SINGLE_CANDIDATES);
    		}
    	}
    	
    	log.debug("*** retrieve 方法结束");
    	return result;
    }
	
	/**
	 * 当是取回任务时业务补偿
	 * @param instance
	 * @param form
	 */
	private void retrieveTaskSet(WorkflowInstance instance,WorkflowTask task){
		String retrieveTaskSet = DefinitionXmlParse.getRetrieveTaskSet(instance.getProcessDefinitionId());
		if(StringUtils.isNotEmpty(retrieveTaskSet)){
			RetrieveTaskInterface retrieveTaskBean=(RetrieveTaskInterface)ContextUtils.getBean(retrieveTaskSet);
			retrieveTaskBean.retrieveTaskExecute(instance.getDataId(),task.getId());
		}
	}
    
    /*
     * 查询Task后面的环节是否已阅
     * @param task
     * @return
     */
	private boolean isNextTasksRead(WorkflowTask task){
    	log.debug("*** isNextTasksRead 方法开始");
		log.debug(new StringBuilder("*** Received parameter:[")
			.append("task:").append(task)
			.append("]").toString());
    	
    	
    	String nextTasks = task.getNextTasks();
    	if(nextTasks == null) return false;
		String[] taskNames = nextTasks.split(",");
		if(taskNames.length == 1 && PROCESS_END_EN.equals(taskNames[0])){
			//流程已经结束
			return true;
		}
		for(String name : taskNames){
			List<WorkflowTask> tasks = workflowTaskService.getTasksByName(task.getCompanyId(), task.getProcessInstanceId(), name);
			if(tasks.size() == 1 &&tasks.get(0).getRead()){
				return true;
			}else if(tasks.size() > 1 &&!tasks.get(0).getMoreTransactor()){//单人办理已有多条任务
				for(WorkflowTask t : tasks){
					if(!t.getRead()) return false;
				}
				return true;
			}
		}
		
		log.debug("*** isNextTasksRead 方法结束");
    	return false;
    }
    
    private boolean isSubProcessTask(WorkflowTask task){
    	log.debug("*** isSubProcessTask 方法开始");
		log.debug(new StringBuilder("*** Received parameter:[")
			.append("task:").append(task)
			.append("]").toString());
    	String nextTasks = task.getNextTasks();
    	WorkflowInstance wfi = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId(),task.getCompanyId());
    	if(wfi==null){log.debug("isSubProcessTask中，流程实例不能为null");throw new RuntimeException("isSubProcessTask中，流程实例不能为null");}
    	if(nextTasks != null){
    		String[] taskNames = nextTasks.split(",");
    		for(String name:taskNames){
    			return DefinitionXmlParse.isSubProcessTask(wfi.getProcessDefinitionId(), name);
    		}
    	}
    	log.debug("*** isSubProcessTask 方法结束");
    	return false;
    }
    
    /**
     * 当前实例的所有有效的办理人
     * @param instanceId
     * @return
     */
    public List<String> getParticipantsTransactor(String instanceId){
    	WorkflowInstance instance=workflowInstanceManager.getWorkflowInstance(instanceId);
    	return workflowTaskService.getParticipantsTransactor(instance.getCompanyId(), instanceId);
    }
    
    /**
     * 根据任务查询投票的结果
     * @param instanceId
     * @param taskName
     * @return int[同意票，不同意票，弃权票]
     */
    public long[] getVoteResults(String instanceId, String taskName,Long companyId){
    	log.debug("*** getVoteResults 方法开始");
    	
    	Integer groupNum=getTaskMaxGroupNum(instanceId,taskName,companyId);
    	List<WorkflowTask> tasks = workflowTaskService.getNoAssignTasksByName(companyId, instanceId, taskName,groupNum);
    	int agreement = 0;
    	int oppose = 0;
    	int kiken = 0;
    	for(WorkflowTask t : tasks){
    		if(TaskProcessingResult.AGREEMENT==t.getTaskProcessingResult()){
    			agreement++;
    		}else if(TaskProcessingResult.OPPOSE==t.getTaskProcessingResult()){
    			oppose++;
    		}else if(TaskProcessingResult.KIKEN==t.getTaskProcessingResult()){
    			kiken++;
    		}
    	}
    	
    	log.debug("*** getVoteResults 方法结束");
    	return new long[]{agreement, oppose, kiken};
    }
    
    /**
     * 根据任务查询任务会签的结果
     * @param instanceId
     * @param taskName
     * @return int[同意票，不同意票]
     */
    public long[] getCountersignatureResult(String instanceId, String taskName,Long companyId){
    	log.debug("*** getCountersignatureResult 方法开始");
    	Integer groupNum=getTaskMaxGroupNum(instanceId,taskName,companyId);
    	List<WorkflowTask> tasks = workflowTaskService.getNoAssignTasksByName(companyId, instanceId, taskName,groupNum);
    	int approve = 0;
    	int refuse = 0;
    	for(WorkflowTask t : tasks){
    		if(TaskProcessingResult.APPROVE==t.getTaskProcessingResult()){
    			approve++;
    		}else if(TaskProcessingResult.REFUSE==t.getTaskProcessingResult()){
    			refuse++;
    		}
    	}
    	
    	log.debug("*** getCountersignatureResult 方法结束");
    	return new long[]{approve, refuse};
    }
    
    /**
     * 我委托的所有流程
     * @param companyId
     * @param tasks
     * @param loginName
     * @return
     */
	public Page<WorkflowTask> getDelegateTasks(Long companyId, Page<WorkflowTask> tasks, String loginName){
		tasks = workflowTaskService.getDelegateTasks(companyId, loginName, tasks);
    	return tasks;
    }

	/**
	 * 按是否结束查询我委托的流程
	 * @param companyId
	 * @param tasks
	 * @param longinName
	 * @param isEnd
	 * @return
	 */
	public Page<WorkflowTask> getDelegateTasksByActive(Long companyId,
			Page<WorkflowTask> tasks, String loginName, Boolean isEnd) {
		return workflowTaskService.getDelegateTasksByActive(companyId, loginName, tasks, isEnd);
	}
	
	public Page<WorkflowTask> getTaskAsTrustee(Long companyId,
			Page<WorkflowTask> tasks, String loginName, Boolean isEnd) {
		return workflowTaskService.getTaskAsTrustee(companyId, loginName, tasks, isEnd);
	}
	
	public Integer getDelegateTasksNum(Long companyId, String loginName){
		return workflowTaskService.getDelegateTasksNum(companyId, loginName);
	}
	
	public Integer getDelegateTasksNum(Long companyId, String loginName, Boolean isEnd){
		return workflowTaskService.getDelegateTasksNumByActive(companyId, loginName, isEnd);
	}
	
	public Integer getTrusteeTasksNum(Long companyId, String loginName, Boolean isEnd){
		return workflowTaskService.getTrusteeTasksNum(companyId, loginName, isEnd);
	}
    
	/**
	 * 查询流程实例的第一个任务
	 * @return
	 */
	public WorkflowTask getFirstTask(String instanceId, String transactor){
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(instanceId);
		String firstTaskName = DefinitionXmlParse.getFirstTaskName(instance.getProcessDefinitionId());
		List<WorkflowTask> tasks = this.getWorkflowTasks(instanceId, firstTaskName);
		WorkflowTask resultTask = null;
		for(WorkflowTask task:tasks){
			if(task.getTransactor().equals(transactor)){
				resultTask = task;
				break;
			}
		}
		if(!resultTask.getMoreTransactor()&&resultTask.getActive().equals(TaskState.DRAW_WAIT.getIndex())){
				for(WorkflowTask task : tasks){
					if(task.equals(resultTask)){
						resultTask.setActive(TaskState.WAIT_TRANSACT.getIndex());
					}else{
						task.setActive(TaskState.CANCELLED.getIndex());
					}
				}
		}
		return resultTask;
	}
	
	
	
	/**
	 * 查询任务
	 * @param id
	 * @return
	 */
	public WorkflowTask getWorkflowTask(Long id){
		Assert.notNull(id, "任务Id不能为null");
		return workflowTaskService.getTask(id);
	}
	
	@Autowired
	public void setProcessEngine(ProcessEngine processEngine) {
		this.processEngine = processEngine;
	}

	/**
	 * 删除任务
	 * @param processInstanceId
	 * @param companyId
	 */
	@Transactional(readOnly=false)
	public void deleteTaskByProcessId(String processInstanceId, Long companyId) {
		workflowTaskService.deleteTaskByProcessId(processInstanceId,companyId);
	}

	/**
	 * 手动结束流程
	 */
	@Transactional(readOnly=false)
	public void endTasks(String processInstanceId, Long companyId) {
		Assert.notNull(companyId,"手动结束流程时companyId不能为空");
		workflowTaskService.endTasks(processInstanceId,companyId);
	}
	/**
	 * 强制结束流程
	 */
	@Transactional(readOnly=false)
	public void compelEndTasks(String processInstanceId, Long companyId) {
		Assert.notNull(companyId,"手动结束流程时companyId不能为空");
		workflowTaskService.endTasks(processInstanceId,companyId);
	}

	/**
	 * 得到当前活动的任务
	 */
	public List<WorkflowTask> getActivityTasks(String processInstanceId, Long companyId) {
		return workflowTaskService.getActivityTasks(processInstanceId,companyId);
	}
	
	public WorkflowTask getMyTask(String processInsatnceId,Long companyId ,String loginName){
		Assert.notNull(companyId,"查询用户当前办理人的当前任务时，公司id不能为null");
		return workflowTaskService.getMyTask(processInsatnceId, companyId, loginName);
	}
	
	/**
	 * 保存自动填写域数据(办理后)
	 * @param task
	 */
	@Transactional(readOnly=false)
	public void saveAutomaticallyFilledField(String processInstanceId,String taskName, String currentOperation){
		log.debug(PropUtils.LOG_METHOD_BEGIN+"TaskService+saveAutomaticallyFilledField(String processInstanceId,String taskName, String currentOperation)"+PropUtils.LOG_FLAG);
		WorkflowInstance wi = workflowInstanceManager.getWorkflowInstance(processInstanceId);
		if(wi==null){
			log.debug("环节自动填写字段时，流程实例不能为null");
			throw new RuntimeException("环节自动填写字段时，流程实例不能为null");
		}
		log.debug(PropUtils.LOG_CONTENT+"实例workflowInstance"+PropUtils.LOG_FLAG + wi);
		Assert.notNull(wi.getFormId(),"流程对应的表单id不能为null");
		FormView form = formViewManager.getFormView(wi.getFormId());
		if(form==null){
			log.debug("环节自动填写字段时，流程对应的表单不能为null");
			throw new RuntimeException("环节自动填写字段时，流程对应的表单不能为null");
		}
		log.debug(PropUtils.LOG_CONTENT+"对应的表单formView"+PropUtils.LOG_FLAG + form );
		log.debug(PropUtils.LOG_CONTENT+"对应的表单是否是标准字段,true表示是标准表单"+PropUtils.LOG_FLAG + form.isStandardForm() );
		if(form.isStandardForm()){
			saveAutomaticallyFilledFieldEntity(wi,form,taskName, currentOperation);
		}else if(!form.isStandardForm()){
			Map<String,String[]> automaticallyFilledFieldMap  = getAutomaticallyFilledFields(wi,taskName, currentOperation);
			log.debug(PropUtils.LOG_CONTENT+"需要自动填写的字段为:"+PropUtils.LOG_FLAG + automaticallyFilledFieldMap.toString());
			if(!automaticallyFilledFieldMap.isEmpty()) formViewManager.saveFormContentToTable(automaticallyFilledFieldMap,wi.getFormId(),wi.getDataId());
		}
		log.debug(PropUtils.LOG_METHOD_END+"TaskService+saveAutomaticallyFilledField(String processInstanceId,String taskName, String currentOperation)"+PropUtils.LOG_FLAG);
	}
	
	/**
	 * 得到定义文件中需要自动填写的设置
	 */
	public List<AutomaticallyFilledField> getAutomaticallyFilledFields(String processDefinitionId,String taskName){
		return DefinitionXmlParse.getAfterFilledFields(processDefinitionId, taskName);
	}
	
	@Transactional(readOnly=false)
	private void saveAutomaticallyFilledFieldEntity(WorkflowInstance wi,FormView form,String taskName, String currentOperation){
		try {
			Assert.notNull(wi,"流程实例不能为null");
			Assert.notNull(form,"流程对应的表单不能为null");
			Assert.notNull(form.getDataTable(),"表单对应的数据表不能为null");
			Assert.notNull(wi.getDataId(),"流程对应的实体id不能为null");
			Object entity = generalDao.getObject(form.getDataTable().getEntityName(), wi.getDataId());
			List<AutomaticallyFilledField> autoFilledFields = getAutomaticallyFilledFields(wi.getProcessDefinitionId(),taskName);
			log.debug("需要自动填写的字段为:" + autoFilledFields);
			for(AutomaticallyFilledField aff : autoFilledFields){
				Object value = getValueEntity(wi,   currentOperation,aff);
				log.debug("需要自动填写的字段值为:" + value);
				if(value!=null&&StringUtils.isEmpty(value.toString()))value=null;
				PropertyUtils.setProperty(entity, aff.getName(), value);
			}
			 generalDao.save(entity);
		} catch (Exception e) {
			throw new RuntimeException(e);
		} 
	}
	
	/*
	 * 实体类型的自动填写值
	 * @param wi
	 * @param taskTransactor
	 * @param currentOperation
	 * @param aff
	 * @throws IllegalAccessException
	 * @throws InvocationTargetException
	 * @throws NoSuchMethodException
	 */
	private Object getValueEntity(WorkflowInstance wi, String currentOperation,AutomaticallyFilledField aff) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException{
		Assert.notNull(wi.getFormId(),"自动填写时流程对应的表单id不能为null");
		FormView form = formViewManager.getFormView(wi.getFormId());
		Assert.notNull(form,"自动填写时流程对应的表单不能为null");
		Assert.notNull(form.getDataTable(),"自动填写时表单对应的数据表不能为null");
		Assert.notNull(wi.getDataId(),"自动填写时实例对应的实体id不能为null");
		Object entity = generalDao.getObject(form.getDataTable().getEntityName(), wi.getDataId());
		List<FormControl> fieldsList = this.formViewManager.getControls(wi.getFormId());
		FormControl field = getFieldbyName(fieldsList,aff.getName() );
		Object value ;
		if(field.getDataType()==DataType.TIME || field.getDataType()==DataType.DATE){
			log.debug("需要自动填写的字段为DATE或TIME类型" );
			value = StringUtils.contains(aff.getValue(), CommonStrings.CURRENTTIME) ? new Date() :null;
		}else if(field.getDataType()==DataType.TEXT){
			log.debug("需要自动填写的字段为TEXT类型" );
			value = getValue(aff, currentOperation);
			if(aff.getFillType().equals(AutomaticallyFilledField.AUTO_FILLED_FILL_TYPE_ADDITIONAL)){
				String originalValue = BeanUtils.getProperty(entity, aff.getName());
				if(value!=null&&StringUtils.isNotEmpty(originalValue)){//如果配的值不为空且数据库中的值也不为空时，则其值为追加后的值
					value = originalValue+","+value;
				}else if(value==null&&StringUtils.isNotEmpty(originalValue)){//如果配的值为空且数据库的值不为空时，则其值为数据库中的值不作修改
					value= originalValue;
				}
			}else if(aff.getFillType().equals(AutomaticallyFilledField.AUTO_FILLED_FILL_TYPE_ADDED_TO_THE_BEGINNING)){
				String originalValue = BeanUtils.getProperty(entity, aff.getName());
				if(value!=null&&StringUtils.isNotEmpty(originalValue)){
					value = value + ","+originalValue;
				}else if(value==null&&StringUtils.isNotEmpty(originalValue)){
					value= originalValue;
				}
			}
		}else if(field.getDataType()==DataType.NUMBER){
			value = Integer.valueOf(aff.getValue());
		}else if(field.getDataType()==DataType.AMOUNT){
			value = Float.valueOf(aff.getValue());
		}else if(field.getDataType()==DataType.INTEGER){
			log.debug("需要自动填写的字段为INTEGER类型" );
			value = Integer.valueOf(aff.getValue());
		}else if(field.getDataType()==DataType.LONG){
			log.debug("需要自动填写的字段为LONG类型" );
			value = Long.valueOf(aff.getValue());
		}else if(field.getDataType()==DataType.DOUBLE){
			log.debug("需要自动填写的字段为DOUBLE类型" );
			value = Float.valueOf(aff.getValue());
		}else if(field.getDataType()==DataType.FLOAT){
			log.debug("需要自动填写的字段为FLOAT类型" );
			value = Float.valueOf(aff.getValue());
		}else if(field.getDataType()==DataType.BOOLEAN){
			log.debug("需要自动填写的字段为BOOLEAN类型" );
			value = Boolean.parseBoolean(aff.getValue());
		}else{
			log.debug("需要自动填写的字段为不是指定的类型" );
			value = aff.getValue();
		}
		return value;
	}
	
	
	/**
	 * 得到需字段填写的字段
	 */
	public Map<String,String[]> getAutomaticallyFilledFields(WorkflowInstance wi,String taskName,String currentOperation){
		Map<String,String[]> automaticallyFilledFieldMap = new HashMap<String,String[]>();
		List<AutomaticallyFilledField> autoFilledFields = DefinitionXmlParse.getAfterFilledFields(wi.getProcessDefinitionId(), taskName);
			for(AutomaticallyFilledField aff : autoFilledFields){
				String value = getAutoFilledFieldValue(wi, currentOperation,aff);
					automaticallyFilledFieldMap.put(aff.getName(),new String[]{value });
			}
		return automaticallyFilledFieldMap;
	}
	
	
	/**
	 * 返回自动填写域表示的值
	 * @param condition
	 * @param currentOperation
	 * @return
	 */
	@SuppressWarnings("unchecked")
	private  String getAutoFilledFieldValue(WorkflowInstance wi, String currentOperation,AutomaticallyFilledField aff){
		log.debug("*** getAutoFilledFieldValue 方法开始");
		
		FormView form = formViewManager.getFormView(wi.getFormId());
		Map map = formViewManager.getDataMap(form.getDataTable().getName(), wi.getDataId());
		List<FormControl> fieldsList = this.formViewManager.getControls(wi.getFormId());
		FormControl field = getFieldbyName(fieldsList,aff.getName() );
		String value ;
		if(field.getDataType()==DataType.TIME){
			value = getFormatCurrentTime(aff,DataType.TIME);
		}else if(field.getDataType()==DataType.DATE){
			value = getFormatCurrentTime(aff,DataType.DATE);
		}else if(field.getDataType()==DataType.TEXT||field.getDataType()==DataType.CLOB){
			value = getValue(aff, currentOperation);
			if(aff.getFillType().equals(AutomaticallyFilledField.AUTO_FILLED_FILL_TYPE_ADDITIONAL)){//追加
				String originalValue = (map.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+aff.getName())==null?"":map.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+aff.getName()))+"";
				if(StringUtils.isNotEmpty(value)&&StringUtils.isNotEmpty(originalValue)){//如果配的值不为空且数据库中的值也不为空时，则其值为追加后的值
					value = originalValue+","+value;
				}else if(StringUtils.isEmpty(value)&&StringUtils.isNotEmpty(originalValue)){//如果配的值为空且数据库的值不为空时，则其值为数据库中的值不作修改
					value= originalValue;
				}
			}else if(aff.getFillType().equals(AutomaticallyFilledField.AUTO_FILLED_FILL_TYPE_ADDED_TO_THE_BEGINNING)){//添加
				String originalValue = (map.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+aff.getName())==null?"":map.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+aff.getName()))+"";
				if(StringUtils.isNotEmpty(value)&&StringUtils.isNotEmpty(originalValue)){
					value = value + ","+originalValue;
				}else if(StringUtils.isEmpty(value)&&StringUtils.isNotEmpty(originalValue)){
					value= originalValue;
				}
			}
		}else{
			value = aff.getValue();
		}
		
		log.debug("*** getAutoFilledFieldValue 方法结束");
		return value;
	}
	
	/*
	 *如果字段类型是text 调用该方法来解析要填写的值 
	 * @param aff
	 * @param taskTransactor
	 * @param currentOperation
	 * @return
	 */
	public String getValue(AutomaticallyFilledField aff, String currentOperation){
		StringBuilder builder = new StringBuilder();
		String[] strs = null;
		String condition = aff.getValue();
		if(condition.indexOf('+')==-1){
			strs = new String[]{condition};
		}else{
			strs = condition.split("\\+");
		}
		for(int i=0;i<strs.length;i++){
			if(i!=0) builder.append(aff.getSeparate());
			if( CommonStrings.CURRENTTRANSACTOR.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前登录名时，当前登录名不能为null");throw new RuntimeException("自动填写当前登录名时，当前登录名不能为null");}
				builder.append(ContextUtils.getLoginName());
			}else if(CommonStrings.CURRENT_TRANSACTOR_NAME.equals(strs[i])){
				if(ContextUtils.getUserName()==null){log.debug("自动填写当前用户姓名时，当前用户姓名不能为null");throw new RuntimeException("自动填写当前用户姓名时，当前用户姓名不能为null");}
				builder.append(ContextUtils.getUserName());
			}else if(CommonStrings.CURRENTTIME.equals(strs[i])){
				SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
				builder.append(simpleDateFormat.format(new Date()));
			}else if(CommonStrings.CURRENTOPERATION.equals(strs[i])){
				builder.append(currentOperation);
			}else if(CommonStrings.CURRENT_TRANSACTOR_DEPARTMENT.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人部门时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人部门时，当前登录名不能为null");}
				builder.append(getDepartementNames(ApiFactory.getAcsService().getDepartments(ContextUtils.getLoginName())));
			}else if(CommonStrings.CURRENT_TRANSACTOR_MAIN_DEPARTMENT.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人正职部门时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人正职部门时，当前登录名不能为null");}
				com.norteksoft.product.api.entity.User user=ApiFactory.getAcsService().getUserByLoginName(ContextUtils.getLoginName());
				if(user!=null){
					if(user.getMainDepartmentId()==null){log.debug("自动填写当前办理人正职部门时，当前办理人的正职部门id不能为null");throw new RuntimeException("自动填写当前办理人正职部门时，当前办理人的正职部门id不能为nul");}
					com.norteksoft.product.api.entity.Department dept=ApiFactory.getAcsService().getDepartmentById(user.getMainDepartmentId());
					builder.append(dept.getName());
				}
			}else if(CommonStrings.CURRENT_TRANSACTOR_SUPERIOR_DEPARTMENT.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人的上级部门时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人直属上级所在部门时，当前登录名不能为null");}
				builder.append(getDepartementNames(ApiFactory.getAcsService().getParentDepartmentsByUser(ContextUtils.getLoginName())));
			}else if(CommonStrings.CURRENT_TRANSACTOR_UPSTAGE_DEPARTMENT.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人顶级部门时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人顶级部门时，当前登录名不能为null");}
				builder.append(getDepartementNames( ApiFactory.getAcsService().getTopDepartmentsByUser(ContextUtils.getLoginName())));
			}else if(CommonStrings.CURRENT_TRANSACTOR_ROLE.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人角色时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人角色时，当前登录名不能为null");}
				builder.append(getRoleNames(ApiFactory.getAcsService().getRolesByUser(ContextUtils.getLoginName())));
			}else if(CommonStrings.CURRENT_TRANSACTOR_WORKGROUP.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人工作组时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人工作组时，当前登录名不能为null");}
				builder.append(getWorkgroupNames(ApiFactory.getAcsService().getWorkgroupsByUser(ContextUtils.getLoginName())));
			}else if(CommonStrings.CURRENT_TRANSACTOR_DIRECT_SUPERIOR_NAME.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人直属上级名称时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人直属上级名称时，当前登录名不能为null");}
				com.norteksoft.product.api.entity.User user=ApiFactory.getDataDictService().getDirectLeader(ContextUtils.getLoginName());
				if(user!=null)builder.append(user.getName());
			}else if(CommonStrings.CURRENT_TRANSACTOR_DIRECT_SUPERIOR_LOGIN_NAME.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人直属上级登录名时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人直属上级登录名时，当前登录名不能为null");}
				com.norteksoft.product.api.entity.User user=ApiFactory.getDataDictService().getDirectLeader(ContextUtils.getLoginName());
				if(user!=null)builder.append(user.getLoginName());
			}else if(CommonStrings.CURRENT_TRANSACTOR_DIRECT_SUPERIOR_DEPARTMENT.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人直属上级部门时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人直属上级部门时，当前登录名不能为null");}
				com.norteksoft.product.api.entity.User user=ApiFactory.getDataDictService().getDirectLeader(ContextUtils.getLoginName());
				if(user!=null) builder.append(getDepartementNames(ApiFactory.getAcsService().getParentDepartmentsByUser(user.getLoginName())));
			}else if(CommonStrings.CURRENT_TRANSACTOR_DIRECT_SUPERIOR_MAIN_DEPARTMENT.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人直属上级正职部门时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人直属上级正职部门时，当前登录名不能为null");}
				com.norteksoft.product.api.entity.User user=ApiFactory.getDataDictService().getDirectLeader(ContextUtils.getLoginName());
				if(user!=null){
					user=ApiFactory.getAcsService().getUserByLoginName(user.getLoginName());
					if(user!=null){
						if(user.getMainDepartmentId()==null){log.debug("自动填写当前办理人直属上级正职部门时，当前办理人直属上级的正职部门id不能为null");throw new RuntimeException("自动填写当前办理人直属上级正职部门时，当前办理人直属上级的正职部门id不能为null");}
						com.norteksoft.product.api.entity.Department dept=ApiFactory.getAcsService().getDepartmentById(user.getMainDepartmentId());
						builder.append(dept.getName());
					}
				}
			}else if(CommonStrings.CURRENT_TRANSACTOR_DIRECT_SUPERIOR_ROLE.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人直属上级角色时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人直属上级角色时，当前登录名不能为null");}
				com.norteksoft.product.api.entity.User user=ApiFactory.getDataDictService().getDirectLeader(ContextUtils.getLoginName());
				if(user!=null){
					builder.append(getRoleNames(ApiFactory.getAcsService().getRolesByUser(user.getLoginName())));
				}
			}else if(CommonStrings.CURRENT_TRANSACTOR_DIRECT_SUPERIOR_WORKGROUP.equals(strs[i])){
				if(ContextUtils.getLoginName()==null){log.debug("自动填写当前办理人直属上级工作组时，当前登录名不能为null");throw new RuntimeException("自动填写当前办理人直属上级工作组时，当前登录名不能为null");}
				com.norteksoft.product.api.entity.User user=ApiFactory.getDataDictService().getDirectLeader(ContextUtils.getLoginName());
				if(user!=null){
					builder.append(getWorkgroupNames(ApiFactory.getAcsService().getWorkgroupsByUser(user.getLoginName())));
				}
			}else{
				builder.append(strs[i]);
			}
		}
		return builder.toString();
	}
	
	private String getDepartementNames(List<com.norteksoft.product.api.entity.Department> departments){
		StringBuilder sb=new StringBuilder();
		if(departments!=null){
			int i=0;
			for(com.norteksoft.product.api.entity.Department dept:departments){
				i++;
				sb.append(dept.getName());
				if(i<departments.size()){
					sb.append(",");
				}
			}
		}
		return sb.toString();
	}
	
	private String getRoleNames(Set<com.norteksoft.product.api.entity.Role> roles){
		StringBuilder sb=new StringBuilder();
		if(roles!=null){
			int i=0;
			for(com.norteksoft.product.api.entity.Role role:roles){
				i++;
				sb.append(role.getName());
				if(i<roles.size()){
					sb.append(",");
				}
			}
		}
		return sb.toString();
	}
	
	private String getWorkgroupNames(List<com.norteksoft.product.api.entity.Workgroup> workGroups){
		StringBuilder sb=new StringBuilder();
		if(workGroups!=null){
			int i=0;
			for(com.norteksoft.product.api.entity.Workgroup wg:workGroups){
				i++;
				sb.append(wg.getName());
				if(i<workGroups.size()){
					sb.append(",");
				}
			}
		}
		return sb.toString();
	}
	
	
	private String getFormatCurrentTime(AutomaticallyFilledField aff,DataType dataType){
		String format ;
		switch(dataType){
		  	case TIME: format = "yyyy-MM-dd HH:mm" ;break;
		  	case DATE: format = "yyyy-MM-dd";break;
		  	default: return "";
		}
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
		return StringUtils.contains(aff.getValue(), CommonStrings.CURRENTTIME) ? simpleDateFormat.format(new Date()) :"";
	}
	
	/*
	 * 从List中取出英文名为enName的Field
	 */
	private FormControl getFieldbyName(List<FormControl> fields , String enName){
		for(FormControl field:fields){
			if(field.getName().equals(enName)) return field;
		}
		return null;
	}
	
	/**
	 * 通过流程实例ID及方式
	 * @param page
	 * @param processInstanceId
	 * @return
	 */
	public List<WorkflowTask> getCountersignByProcessInstanceIdResult(String processInstanceId,TaskProcessingMode processingMode,String taskName,TaskProcessingResult result){
		return workflowTaskService.getCountersignByProcessInstanceIdResult(processInstanceId, taskName, result);
	}
	
	public List<String> getCountersignByProcessInstanceId(String processInstanceId,TaskProcessingMode processingMode){
		return workflowTaskService.getCountersignByProcessInstanceId(processInstanceId, processingMode);
	}
	
	/**
	 * 自定义流程中取得会签名字列表
	 * @param processInstanceId
	 * @param processingMode
	 * @return
	 */
	public List<String> getSignByProcessInstanceId(String processInstanceId,TaskProcessingMode processingMode){
		return workflowTaskService.getSignByProcessInstanceId(processInstanceId, processingMode);
	}

	/**
	 * 根据流程名字和实例id查询workflowTask
	 * @param instanceId
	 * @param taskName
	 * @return
	 */
	public List<WorkflowTask> getWorkflowTasks(String instanceId, String taskName) {
		return workflowTaskService.getWorkflowTasks(instanceId, taskName);
	}

	public Set<String> getHandledTransactors(WorkflowInstance instance){
		Assert.notNull(instance,"流程实例不能为null");
		return workflowTaskService.getHandledTransactors(instance.getProcessInstanceId());
	}
	
	public Set<String> getAllHandleTransactors(WorkflowInstance instance){
		return workflowTaskService.getAllHandleTransactors(instance.getProcessInstanceId());
	}
	
	/**
	 * 得到所有需要催办的task
	 */
	public List<WorkflowTask> getNeedReminderTasks(){
		return workflowTaskService.getNeedReminderTasks();
	}
	
	@Autowired
	public void setWorkflowRightsManager(
			WorkflowRightsManager workflowRightsManager) {
		this.workflowRightsManager = workflowRightsManager;
	}
	
	@Autowired
	public void setUserManager(UserManager userManager) {
		this.userManager = userManager;
	}
	@Autowired
	public void setWorkflowClientManager(
			WorkflowClientManager workflowClientManager) {
		this.workflowClientManager = workflowClientManager;
	}
	
//	@Autowired
//	public void setGeneralDao(GeneralDao generalDao) {
//		this.generalDao = generalDao;
//	}

	@Autowired
	public void setWorkflowTaskService(WorkflowTaskService workflowTaskService) {
		this.workflowTaskService = workflowTaskService;
	}
	

	@Autowired
	public void setWorkflowDefinitionManager(
			WorkflowDefinitionManager workflowDefinitionManager) {
		this.workflowDefinitionManager = workflowDefinitionManager;
	}

	@Autowired
	public void setInstanceHistoryManager(
			InstanceHistoryManager instanceHistoryManager) {
		this.instanceHistoryManager = instanceHistoryManager;
	}
	
	@Autowired
	public void setDelegateManager(DelegateMainManager delegateManager) {
		this.delegateManager = delegateManager;
	}
	
	@Autowired
	public void setWorkflowInstanceManager(
			WorkflowInstanceManager workflowInstanceManager) {
		this.workflowInstanceManager = workflowInstanceManager;
	}
	
	@Autowired
	public void setFormViewManager(FormViewManager formManager) {
		this.formViewManager = formManager;
	}

	/**
	 * 设置新的办理人到工作流引擎中
	 * @param taskId 任务id
	 * @param newTransactor 新的办理人
	 */
	public void setNewTransactor(Long taskId, String newTransactor) {
		WorkflowTask task = this.getTask(taskId);
		processEngine.execute(new ExecutionVariableCommand(task.getExecutionId(), CommonStrings.NEW_TRANSACTOR, newTransactor));
	}
	/**
	 * 设置新的流向名到工作流引擎中
	 * @param taskId 任务id
	 * @param transitionName 流向名
	 */
	public void setTransitionName(Long taskId, String transitionName) {
		WorkflowTask task = this.getTask(taskId);
		processEngine.execute(new ExecutionVariableCommand(task.getExecutionId(), CommonStrings.TRANSITION_NAME, transitionName));
	}

	public List<WorkflowTask> getWorkflowTasksByDefinitonName(
			String definitionName, String loginName) {
		return workflowTaskService.getTasksOrderByWdfName(definitionName,loginName);
	}
	/**
	 * 完成选择具体办理人任务
	 * @param taskId
	 * @param newTransactor
	 */
	@Transactional(readOnly=false)
	public void completeChoiceTransactor(Long taskId, List<String> transactors) {
		for(String transactor:transactors){
			completeChoiceTransactor(taskId,transactor);
		}
	}

	/**
	 * 完成选择具体办理人任务
	 * @param taskId
	 * @param newTransactor
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType completeChoiceTransactor(Long taskId, String newTransactor) {
		if(StringUtils.isEmpty(newTransactor)) return CompleteTaskTipType.MESSAGE.setContent("请选择具体办理人！");
		WorkflowTask task = this.getTask(taskId);
    	ActivityExecution execution = (ActivityExecution) processEngine.getExecutionService().findExecutionById(task.getExecutionId());
    	org.jbpm.api.task.Task jbpmTask = processEngine.getTaskService().createTaskQuery()
		.processInstanceId(task.getProcessInstanceId())
		.activityName(execution.getActivityName()).uniqueResult();   
    	
    	((OpenExecution)processEngine.getExecutionService()
				.findExecutionById(jbpmTask.getExecutionId())).removeVariable(CommonStrings.TRANSACTOR_SINGLE_CANDIDATES);
    	
    	Integer groupNum=getTaskMaxGroupNum(task.getProcessInstanceId(), jbpmTask.getActivityName(),task.getCompanyId());
    	groupNum++;
		saveTask(createTask(task.getProcessInstanceId(), jbpmTask.getExecutionId(), newTransactor ,jbpmTask.getActivityName(),groupNum));
		if(jbpmTask.getAssignee().equals(CommonStrings.TRANSACTOR_ASSIGNMENT)||jbpmTask.getAssignee().equals(CommonStrings.TRANSACTOR_SINGLE)){
    		processEngine.getTaskService().assignTask(jbpmTask.getId(),newTransactor);
    	}
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId(),task.getCompanyId());
		if(instance.getProcessState()==ProcessState.UNSUBMIT){
			instance.setProcessState(ProcessState.SUBMIT);
			instance.setSubmitTime(new Timestamp(System.currentTimeMillis()));
			Map<String,String > reminderSetting = DefinitionXmlParse.getReminderSetting(instance.getProcessDefinitionId());
			instance.setReminderStyle(reminderSetting.get(DefinitionXmlParse.REMIND_STYLE));
			if(reminderSetting.get(DefinitionXmlParse.REMIND_REPEAT)!=null)instance.setRepeat(Long.valueOf(reminderSetting.get(DefinitionXmlParse.REMIND_REPEAT)));
			if(reminderSetting.get(DefinitionXmlParse.REMIND_DUEDATE)!=null)instance.setDuedate(Long.valueOf(reminderSetting.get(DefinitionXmlParse.REMIND_DUEDATE)));
			if(reminderSetting.get(DefinitionXmlParse.REMIND_TIME)!=null)instance.setReminderLimitTimes(Integer.valueOf(reminderSetting.get(DefinitionXmlParse.REMIND_TIME)));
			if(reminderSetting.get(DefinitionXmlParse.REMIND_NOTICE_TYPE)!=null)instance.setReminderNoticeStyle(reminderSetting.get(DefinitionXmlParse.REMIND_NOTICE_TYPE));
			if(reminderSetting.get(DefinitionXmlParse.REMIND_NOTICE_USER_CONDITION)!=null)instance.setReminderNoticeUserCondition(reminderSetting.get(DefinitionXmlParse.REMIND_NOTICE_USER_CONDITION));
		}
		workflowInstanceManager.saveWorkflowInstance(instance);
    	task.setActive(TaskState.COMPLETED.getIndex());// 任务完成状态
    	saveTask(task);
    	return CompleteTaskTipType.OK.setContent("办理人已指定");
	}
	
	
	/**
	 *  生成抄送任务。该任务不会影响任务流转，只是给用户看一下。
	 * @param taskId
	 * @param transactors
	 * @param title
	 * @param url
	 */
	
	@Transactional(readOnly=false)
	public void createCopyTaches(Long taskId, List<String> trans,String title,String url) {
		if(taskId==null){log.debug("生成抄送任务时，任务id不能为null");throw new RuntimeException("生成抄送任务时，任务id不能为null");}
		WorkflowTask currentTask=workflowTaskService.getTask(taskId);
		WorkflowInstance wi = workflowInstanceManager.getWorkflowInstance(currentTask.getProcessInstanceId());
		if(currentTask==null){log.debug("生成抄送任务时，任务不能为null");throw new RuntimeException("生成抄送任务时，任务不能为null");}
    	Set<String> transactors= new HashSet<String>();
    	if(trans!=null)transactors.addAll(trans);
		List<WorkflowTask> tasks = new ArrayList<WorkflowTask>();
    	for(String transactor:transactors){
    		WorkflowTask task = createTask(wi.getProcessDefinitionId(),currentTask.getProcessInstanceId(),currentTask.getExecutionId(),currentTask.getName(),transactor,false,currentTask.getGroupNum());
    		if(task!=null){
    			task.setName("(抄送)"+currentTask.getName());
    			task.setTitle("(抄送)"+currentTask.getTitle());
    			task.setProcessingMode(TaskProcessingMode.TYPE_READ);
    			task.setActive(TaskState.WAIT_TRANSACT.getIndex());
    			task.setRead(false);
    			task.setSendingMessage(true);
    			if(transactors.size()>0){
    				task.setMoreTransactor(true);
    			}else{
    				task.setMoreTransactor(false);
    			}
    			if(StringUtils.isNotEmpty(title))task.setTitle(title);
    			if(StringUtils.isNotEmpty(url))task.setUrl(ContextUtils.getSystemCode()+url);
    			
    			tasks.add(task);
    		}
    	}
    	this.saveTasks(tasks);
	}
	/**
	 * 发起子流程
	 * @param subprocessParse 封装子流程初始化变量
	 */
	public void startSubProcessWorkflow(Map<TaskTransactorCondition, String> transactor,SubProcessParse subprocessParse,Collection<String> transcators){
		ActivityExecution execution=(ActivityExecution)processEngine.getExecutionService().findExecutionById(subprocessParse.getExecutionId());
		WorkflowInstance parentWorkflow=workflowInstanceManager.getWorkflowInstance(subprocessParse.getParentInstanceId());
		FormView parentForm=formViewManager.getFormView(parentWorkflow.getFormId());
		boolean isMoreTransator = DefinitionXmlParse.hasMoreTransactor(subprocessParse.getParentDefinitionId(),subprocessParse.getActivityName());
		Set<String> subProcessCreator = new HashSet<String>();
		if(transactor.isEmpty() || StringUtils.isEmpty(transactor.get(TaskTransactorCondition.USER_CONDITION))){
			subProcessCreator.add(subprocessParse.getCreator());
		}else{
			Object originalUser=processEngine.getExecutionService().getVariable(execution.getId(),CommonStrings.IS_ORIGINAL_USER); 
			execution.removeVariable(CommonStrings.IS_ORIGINAL_USER);
			Object allOriginalUsers=processEngine.getExecutionService().getVariable(execution.getId(),CommonStrings.ALL_ORIGINAL_USERS);
			execution.removeVariable(CommonStrings.ALL_ORIGINAL_USERS);
			Set<String> candidates = null;
			if("true".equals(originalUser)){
				TaskService  taskService = (TaskService)ContextUtils.getBean("taskService");
				String subFirstTaskName=DefinitionXmlParse.getFirstTaskName(subprocessParse.getSubDefinitionId());
				List<WorkflowInstance> ins=workflowInstanceManager.getSubWorkflowInstances(subprocessParse.getParentInstanceId(),ContextUtils.getSystemId());
				List<WorkflowTask> tasks=new ArrayList<WorkflowTask>();
				for(WorkflowInstance wi:ins){
					String subFirstName=DefinitionXmlParse.getFirstTaskName(wi.getProcessDefinitionId());
					if(subFirstTaskName.equals(subFirstName)){
						tasks.addAll(taskService.getCompletedTasksByTaskName(subprocessParse.getParentInstanceId(), wi.getCompanyId(), subFirstTaskName));
					}
				}
				
				candidates = new HashSet<String>();
				if(allOriginalUsers!=null && !"".equals(allOriginalUsers)){
					String[] aous=allOriginalUsers.toString().split(",");
					for(String s:aous){
						for(WorkflowTask task:tasks){
							if(s.equals(task.getTransactor())){
								candidates.add(task.getTransactor());
								break;
							}
						}
					}
				}
				//当没有传入该环节上次办理人的登录名，则将所有已办理该环节的人加入候选人集合中
				if(allOriginalUsers==null ||(allOriginalUsers!=null && "".equals(allOriginalUsers))){
					for(WorkflowTask task:tasks){
						candidates.add(task.getTransactor());
					}
				}
			}
			if(originalUser==null || "false".equals(originalUser) || ("true".equals(originalUser)&&candidates.size()==0)){
				Map<String,String> paramMap = new HashMap<String,String>();
				paramMap.put(TransactorConditionHandler.DOCUMENT_CREATOR, subprocessParse.getCreator());
				paramMap.put(TransactorConditionHandler.PROCESS_INSTANCEID, subprocessParse.getParentInstanceId());
				Object previousTaskTransactorObj = ((OpenExecution) execution).getVariable(CommonStrings.PREVIOUS_TASK_TRANSACTOR);
				if(previousTaskTransactorObj!=null){
					paramMap.put(TransactorConditionHandler.PREVIOUS_TRANSACTOR, previousTaskTransactorObj.toString());
				}
				
				candidates = TransactorConditionHandler.processCondition(transactor, (OpenExecution) execution,paramMap);
			}
			if(transcators!=null)subProcessCreator.addAll(transcators);
			if(subProcessCreator.isEmpty()){//如果指定办理人为空时，继续指定子流程创建人
				if(candidates.isEmpty()){
					subProcessCreator.add(subprocessParse.getCreator());
				}else{
					subProcessCreator.addAll(candidates);
				}
			}
		}
		Map<String,Object> subNeedVariableMap = new HashMap<String,Object>();// mainVariableTosub(execution);
		subNeedVariableMap.put(CommonStrings.PRIORITY, subprocessParse.getPriority());//本环节任务名
		subNeedVariableMap.put(CommonStrings.PARENT_WORKFLOW_ID, subprocessParse.getParentInstanceId());
		subNeedVariableMap.put(CommonStrings.PARENT_EXECUTION_ID, execution.getId());
		subNeedVariableMap.put(CommonStrings.PARENT_TACHE_NAME, subprocessParse.getActivityName());
	if(DefinitionXmlParse.isSharedForm(subprocessParse.getParentDefinitionId(),subprocessParse.getSubDefinitionId())){
		subNeedVariableMap.put(CommonStrings.FORM_DATA_ID, parentWorkflow.getDataId());
		//共用表单
		log.info("主子流程公用表单");
		if(parentForm.isStandardForm()){
			log.info("父流程表单为标准表单");
			FormFlowable parentEntity = (FormFlowable)generalDao.get(parentWorkflow.getDataId());
			log.info("parentEntity:"+parentEntity);
			log.info("开始启动子流程...");
			String subprocessInstanceId="";
			if(isMoreTransator){
				//需要发起多个子流程
				Iterator< String> it=subProcessCreator.iterator();
				while(it.hasNext()){
					subNeedVariableMap.put(CommonStrings.CREATOR, it.next());
					subprocessInstanceId = workflowClientManager.startSubProcess(subprocessParse.getSubDefinitionId(), parentEntity,  subNeedVariableMap);
					WorkflowInstance subWorkflow = workflowInstanceManager.getWorkflowInstance(subprocessInstanceId);
					//设置表单查看url formUrl和应急处理url urgenUrl
					setInstanceUrl(subWorkflow);	
				}
			}else{
				if(subProcessCreator.size()==1){
					subNeedVariableMap.put(CommonStrings.CREATOR, subProcessCreator.iterator().next());
				}else{
					subNeedVariableMap.put(CommonStrings.CREATOR_CANDIDATES, subProcessCreator);
				}
				subprocessInstanceId = workflowClientManager.startSubProcess(subprocessParse.getSubDefinitionId(), parentEntity,  subNeedVariableMap);
				WorkflowInstance subWorkflow = workflowInstanceManager.getWorkflowInstance(subprocessInstanceId);
				//设置表单查看url formUrl和应急处理url urgenUrl
				setInstanceUrl(subWorkflow);	
			}
			log.info("子流程启动结束...");
		}else if(!parentForm.isStandardForm()){
			log.info("开始启动子流程...");
			if(isMoreTransator){
				//需要发起多个子流程
				for(String creator:subProcessCreator){
					subNeedVariableMap.put(CommonStrings.CREATOR, creator);
					WorkflowInstance subWorkflow = startWorkflow(subNeedVariableMap,subprocessParse);
					subWorkflow.setDataId(parentWorkflow.getDataId());
					//设置表单查看url formUrl和应急处理url urgenUrl
					setInstanceUrl(subWorkflow);
					workflowInstanceManager.saveWorkflowInstance(subWorkflow);
				}
			}else{
				if(subProcessCreator.size()==1){
					subNeedVariableMap.put(CommonStrings.CREATOR, subProcessCreator.iterator().next());
				}else{
					subNeedVariableMap.put(CommonStrings.CREATOR_CANDIDATES, subProcessCreator);
				}
				WorkflowInstance subWorkflow = startWorkflow(subNeedVariableMap,subprocessParse);
				subWorkflow.setDataId(parentWorkflow.getDataId());
				//设置表单查看url formUrl和应急处理url urgenUrl
				setInstanceUrl(subWorkflow);
				workflowInstanceManager.saveWorkflowInstance(subWorkflow);
			}
			log.info("子流程启动结束...");
		}
	}else{
		Map<String,Object> param = new HashMap<String,Object>();
		log.info("主子流程不同表单");
		WorkflowDefinition subDefinition =  workflowDefinitionManager.getWorkflowDefinitionByProcessId(subprocessParse.getSubDefinitionId());
		log.info("subDefinition"+subDefinition.toString());
		FormView subForm=formViewManager.getCurrentFormViewByCodeAndVersion(subDefinition.getFormCode(), subDefinition.getFromVersion());
		log.info("subForm:"+subForm);
		if(subForm.isStandardForm()){
			String beanName = DefinitionXmlParse.getSubProcessBeginning(subprocessParse.getParentDefinitionId(),subprocessParse.getActivityName());
			log.info("实现类的beanname:"+beanName);
			OnStartingSubProcess beginning = (OnStartingSubProcess)ContextUtils.getBean(beanName);
			Assert.notNull(beginning,"实现类不能为空");
			log.info("开始启动子流程...");
			String subprocessInstanceId="";
			
			if(isMoreTransator){
				//需要发起多个子流程
				Iterator< String> it=subProcessCreator.iterator();
				while(it.hasNext()){
					String creator=it.next();
					subNeedVariableMap.put(CommonStrings.CREATOR, creator);
					param.put(OnStartingSubProcess.PARENT_ENTITY_ID, parentWorkflow.getDataId());
					param.put(OnStartingSubProcess.SUB_DOCUMENT_CREATOR, creator);
					FormFlowable subFormEntity = beginning.getRequiredSubEntity(param);
					Assert.notNull(subFormEntity+"返回子流程实体不能为空");
					Assert.notNull(subFormEntity.getId(),"返回子流程实体的id不能为空");
					log.info("返回实体："+subFormEntity);
					fillSubEntity(subFormEntity,subprocessParse);
					subprocessInstanceId = workflowClientManager.startSubProcess(subprocessParse.getSubDefinitionId(), subFormEntity,  subNeedVariableMap);
					WorkflowInstance subWorkflow = workflowInstanceManager.getWorkflowInstance(subprocessInstanceId);
					//设置实体中表示流程实例状态字段的值
					Object entity = generalDao.getObject(subForm.getDataTable().getEntityName(), subWorkflow.getDataId());
	    			try {
						BeanUtils.setProperty(entity, "workflowInfo.processState", ProcessState.SUBMIT);
						generalDao.save(entity);
					} catch (IllegalAccessException e) {
						log.debug(e);
						throw new RuntimeException();
					} catch (InvocationTargetException e) {
						log.debug(e);
						throw new RuntimeException();
					}
					//设置表单查看url formUrl和应急处理url urgenUrl
					setInstanceUrl(subWorkflow);	
				}
			}else{
				if(subProcessCreator.size()==1){
					subNeedVariableMap.put(CommonStrings.CREATOR, subProcessCreator.iterator().next());
					param.put(OnStartingSubProcess.SUB_DOCUMENT_CREATOR, subprocessParse.getCreator());
				}else{
					subNeedVariableMap.put(CommonStrings.CREATOR_CANDIDATES, subProcessCreator);
				}
				param.put(OnStartingSubProcess.PARENT_ENTITY_ID, parentWorkflow.getDataId());
				FormFlowable subFormEntity = beginning.getRequiredSubEntity(param);
				Assert.notNull(subFormEntity+"返回子流程实体不能为空");
				Assert.notNull(subFormEntity.getId(),"返回子流程实体的id不能为空");
				log.info("返回实体："+subFormEntity);
				fillSubEntity(subFormEntity,subprocessParse);
				subprocessInstanceId = workflowClientManager.startSubProcess(subprocessParse.getSubDefinitionId(), subFormEntity,  subNeedVariableMap);
				WorkflowInstance subWorkflow = workflowInstanceManager.getWorkflowInstance(subprocessInstanceId);
				//设置实体中表示流程实例状态字段的值
				Object entity = generalDao.getObject(subForm.getDataTable().getEntityName(), subWorkflow.getDataId());
    			try {
					BeanUtils.setProperty(entity, "workflowInfo.processState", ProcessState.SUBMIT);
					generalDao.save(entity);
				} catch (IllegalAccessException e) {
					log.debug(e);
					throw new RuntimeException();
				} catch (InvocationTargetException e) {
					log.debug(e);
					throw new RuntimeException();
				}
				//设置表单查看url formUrl和应急处理url urgenUrl
				setInstanceUrl(subWorkflow);	
			}
			log.info("子流程启动结束...");
			
		}else if(!subForm.isStandardForm()){
			log.info("开始启动子流程...");
			if(isMoreTransator){
				//需要发起多个子流程
				for(String creator:subProcessCreator){
					subNeedVariableMap.put(CommonStrings.CREATOR, creator);
					WorkflowInstance subWorkflow = startWorkflow(subNeedVariableMap,subprocessParse);
					Long dataId = fillSubDefaultForm(subWorkflow,subprocessParse);
					subWorkflow.setDataId(dataId);
					//设置表单查看url formUrl和应急处理url urgenUrl
					setInstanceUrl(subWorkflow);	
					subNeedVariableMap.put(CommonStrings.FORM_DATA_ID, dataId);
					workflowInstanceManager.saveWorkflowInstance(subWorkflow);
				}
			}else{
				if(subProcessCreator.size()==1){
					subNeedVariableMap.put(CommonStrings.CREATOR, subProcessCreator.iterator().next());
				}else{
					subNeedVariableMap.put(CommonStrings.CREATOR_CANDIDATES, subProcessCreator);
				}
				WorkflowInstance subWorkflow = startWorkflow(subNeedVariableMap,subprocessParse);
				Long dataId = fillSubDefaultForm(subWorkflow,subprocessParse);
				subWorkflow.setDataId(dataId);
				//设置表单查看url formUrl和应急处理url urgenUrl
				setInstanceUrl(subWorkflow);
				subNeedVariableMap.put(CommonStrings.FORM_DATA_ID, dataId);
				workflowInstanceManager.saveWorkflowInstance(subWorkflow);
			}
			log.info("子流程启动结束...");
		}
	}
	log.info("主流程开始等待...");
	generateFirstTask(execution,subprocessParse);
	execution.removeVariable(CommonStrings.FORM_DATA_ID);
	//generateFlowHistory( execution, PROCESS_ENTER);
	}
	
	private void setInstanceUrl(WorkflowInstance workflow){
		String processId = workflow.getProcessDefinitionId();
		Map<String,String> parameterSetting=DefinitionXmlParse.getParameterSetting(workflow.getProcessDefinitionId());
		String formViewUrl = parameterSetting.get(DefinitionXmlParse.FORM_VIEW_URL);
		if(StringUtils.isEmpty(formViewUrl)){
			formViewUrl = PropUtils.getProp(CommonStrings.WORKFLOW_PARAMETER_URL, CommonStrings.FORM_VIEW_URL);
		}
		String parameterName = parameterSetting.get(DefinitionXmlParse.FORM_VIEW_URL_PARAMETER_NAME);
		if(StringUtils.isEmpty(parameterName)){
			parameterName = PropUtils.getProp(CommonStrings.WORKFLOW_PARAMETER_URL, CommonStrings.FORM_VIEW_PARAMTER_NAME);
		}
		if(StringUtils.isNotEmpty(formViewUrl)){
			String joinSign = StringUtils.contains(formViewUrl, "?") ? "&" : "?";
			String systemCode=ContextUtils.getSystemCode();
			WorkflowDefinition definition = workflowDefinitionManager.getWorkflowDefinitionByProcessId(processId);
			if(definition!=null){
				com.norteksoft.product.api.entity.BusinessSystem system=ApiFactory.getAcsService().getSystemById(definition.getSystemId());
				if(system!=null)systemCode=system.getCode();
			}
			formViewUrl = systemCode+formViewUrl + joinSign + parameterName + "=";
		}
		workflow.setFormUrl(formViewUrl);
		String urgenUrl = parameterSetting.get(DefinitionXmlParse.URGEN_URL);
		if(StringUtils.isEmpty(urgenUrl)){
			urgenUrl = PropUtils.getProp(CommonStrings.WORKFLOW_PARAMETER_URL, CommonStrings.FORM_URGEN_URL);
		}
		String urgenParameterName = parameterSetting.get(DefinitionXmlParse.URGEN_URL_PARAMETER_NAME);
		if(StringUtils.isEmpty(urgenParameterName)){
			urgenParameterName = PropUtils.getProp(CommonStrings.WORKFLOW_PARAMETER_URL, CommonStrings.FORM_URGEN_PARAMTER_NAME);
		}
		if(StringUtils.isNotEmpty(urgenUrl)){
			String joinSign = StringUtils.contains(urgenUrl, "?") ? "&" : "?";
			String systemCode=ContextUtils.getSystemCode();
			WorkflowDefinition definition = workflowDefinitionManager.getWorkflowDefinitionByProcessId(processId);
			if(definition!=null){
				com.norteksoft.product.api.entity.BusinessSystem system=ApiFactory.getAcsService().getSystemById(definition.getSystemId());
				if(system!=null)systemCode=system.getCode();
			}
			urgenUrl = systemCode+urgenUrl + joinSign + urgenParameterName + "=";
		}
		workflow.setEmergencyUrl(urgenUrl);
	}
	
	public void  generateFirstTask(ActivityExecution execution,SubProcessParse subprocessParse){
		WorkflowInstance parentWorkflow=workflowInstanceManager.getWorkflowInstance(subprocessParse.getParentInstanceId());
		WorkflowTask task = new WorkflowTask();
		task.setCompanyId(parentWorkflow.getCompanyId());
		task.setProcessInstanceId(subprocessParse.getParentInstanceId());
		task.setExecutionId(execution.getId());
		task.setName(subprocessParse.getActivityName());
		String code = DefinitionXmlParse.getTacheCode(parentWorkflow.getProcessDefinitionId(), task.getName());
		task.setCode(code);
		task.setTitle(subprocessParse.getActivityName());
		task.setActive(TaskState.WAIT_TRANSACT.getIndex());
		task.setVisible(false);
		saveTask(task);
		executionVariableCommand(new ExecutionVariableCommand(execution.getId(), CommonStrings.SUBPROCESS_TASK_ID, task.getId()));
	}
	
	@SuppressWarnings("unchecked")
	private void fillSubEntity(FormFlowable subFormEntity,SubProcessParse subprocessParse){
		try {
			WorkflowInstance parentWorkflow=workflowInstanceManager.getWorkflowInstance(subprocessParse.getParentInstanceId());
			FormView parentForm=formViewManager.getFormView(parentWorkflow.getFormId());
			log.info("subFormEntity:"+subFormEntity);
			Map<String,String> mainToSubMap = DefinitionXmlParse.getMainToSub(subprocessParse.getParentDefinitionId(), subprocessParse.getActivityName());
			log.info("mainToSubMap"+mainToSubMap);
			Map<String,Object> valueMap = new HashMap<String,Object>();
			if(parentForm.isStandardForm()){
				Object parentEntity = generalDao.getObject(parentForm.getDataTable().getEntityName(), parentWorkflow.getDataId());
				log.info("parentObject:"+ parentEntity);
				for(String mainFieldName:mainToSubMap.keySet()){
					Object mainFieldValue = BeanUtils.getProperty(parentEntity, mainFieldName);
					if(mainFieldValue!=null){
						log.info("mainFieldValue:"+mainFieldValue.toString());
						valueMap.put(mainToSubMap.get(mainFieldName),mainFieldValue);
					}
				}
			}else if(!parentForm.isStandardForm()){
				Map dataMap = formViewManager.getDataMap(parentForm.getDataTable().getName(), parentWorkflow.getDataId());
				log.info("datamap:" + dataMap);
				for(String mainFieldName:mainToSubMap.keySet()){
					Object mainFieldValue = dataMap.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+mainFieldName);
					if(mainFieldValue!=null){
						log.info("mainFieldValue:" + mainFieldValue);
						valueMap.put(mainToSubMap.get(mainFieldName),mainFieldValue);
					}
				}
			}
			log.info("ValueMap:"+ valueMap.toString());
			BeanUtils.populate(subFormEntity, valueMap);
			log.info("subFormEntity:" + subFormEntity.toString());
			generalDao.save(subFormEntity);
		} catch (IllegalAccessException e) {
			log.error(e.getMessage());
			throw new RuntimeException(e);
		} catch (InvocationTargetException e) {
			log.error(e.getMessage());
			throw new RuntimeException(e);
		} catch (NoSuchMethodException e) {
			log.error(e.getMessage());
			throw new RuntimeException(e);
		}
		
	}
	
	private WorkflowInstance startWorkflow(Map<String ,Object> subNeedVariableMap,SubProcessParse subprocessParse){
		ProcessInstance pi = processEngine.getExecutionService()
				.startProcessInstanceById(subprocessParse.getSubDefinitionId(),subNeedVariableMap);
		String subInstanceId = pi.getId();
		WorkflowInstance subWorkflow = workflowInstanceManager.getWorkflowInstance(subInstanceId);
		return subWorkflow;
	}
	
	@SuppressWarnings("unchecked")
	private Long fillSubDefaultForm(WorkflowInstance subWorkflow,SubProcessParse subprocessParse){
		Map<String,String> mainToSubMap = DefinitionXmlParse.getMainToSub(subprocessParse.getParentDefinitionId(), subprocessParse.getActivityName());
		log.info("mainToSubMap:"+mainToSubMap);
		 Map<String,String[]> valueMap = new HashMap<String,String[]>();
		 valueMap.put(WorkflowInstanceManager.INSTANCE_ID, new String[]{subWorkflow.getProcessInstanceId()});
		 WorkflowDefinition subDefinition =  workflowDefinitionManager.getWorkflowDefinitionByProcessId(subprocessParse.getSubDefinitionId());
		 FormView subForm=formViewManager.getCurrentFormViewByCodeAndVersion(subDefinition.getFormCode(), subDefinition.getFromVersion());
		try {
			WorkflowInstance parentWorkflow=workflowInstanceManager.getWorkflowInstance(subprocessParse.getParentInstanceId());
			FormView parentForm=formViewManager.getFormView(parentWorkflow.getFormId());
			if(parentForm.isStandardForm()){
				Object parentEntity = generalDao.getObject(parentForm.getDataTable().getEntityName(), parentWorkflow.getDataId());
				log.info("parentEntity:"+parentEntity);
				for(String mainFieldName:mainToSubMap.keySet()){
					Object mainFieldValue = BeanUtils.getProperty(parentEntity, mainFieldName);
					if(mainFieldValue!=null){
						log.info("mainFieldValue"+mainFieldValue);
						valueMap.put(mainToSubMap.get(mainFieldName), new String[]{mainFieldValue.toString()});
					}
				}
			}else if(!parentForm.isStandardForm()){
				Map dataMap = formViewManager.getDataMap(parentForm.getDataTable().getName(), parentWorkflow.getDataId());
				log.info("dataMap"+dataMap);
				for(String mainFieldName:mainToSubMap.keySet()){
					Object mainFieldValue = dataMap.get(JdbcSupport.FORM_FIELD_PREFIX_STRING+mainFieldName);
					if(mainFieldValue!=null){
						log.info("mainFieldValue"+mainFieldValue.toString());
						valueMap.put(mainToSubMap.get(mainFieldName),new String[]{mainFieldValue.toString()});
					}
				}
			}
		} catch (IllegalAccessException e) {
			log.error(e.getMessage());
			throw new RuntimeException(e);
		} catch (InvocationTargetException e) {
			log.error(e.getMessage());
			throw new RuntimeException(e);
		} catch (NoSuchMethodException e) {
			log.error(e.getMessage());
			throw new RuntimeException(e);
		}
		log.info("开始保存子流程的表单数据...");
		
		Long subDataId = formViewManager.saveFormContentToTable(valueMap,subForm.getId(),null);
		log.info("返回id为"+subDataId);
		return subDataId;
	}
	public List<WorkflowTask> getCompletedTasksByTaskName(String workflowId,
			Long companyId, String taskName) {
		return workflowTaskService.getCompletedTasksByTaskName(workflowId, companyId, taskName);
	}
	@Deprecated
	public List<WorkflowTask> getOverdueTasks(Long companyId) {
		return workflowTaskService.getOverdueTasks(companyId);
	}
	public List<WorkflowTask> getOverdueTasks() {
		Assert.notNull(ContextUtils.getCompanyId(),"公司id不能为null");
		return workflowTaskService.getOverdueTasks(ContextUtils.getCompanyId());
	}
	@Deprecated
	public Map<String, Integer> getOverdueTasksNumByTransactor(Long companyId) {
		return workflowTaskService.getOverdueTasksNumByTransactor(companyId);
	}
	public Map<String, Integer> getOverdueTasksNumByTransactor() {
		Assert.notNull(ContextUtils.getCompanyId(),"公司id不能为null");
		return workflowTaskService.getOverdueTasksNumByTransactor(ContextUtils.getCompanyId());
	}
	@Deprecated
	public Integer getTasksNumByTransactor(Long companyId, String loginName) {
		return workflowTaskService.getTasksNumByTransactor(companyId, loginName);
	}
	
	public Integer getTasksNumByTransactor(String loginName) {
		Assert.notNull(ContextUtils.getCompanyId(),"公司id不能为null");
		return workflowTaskService.getTasksNumByTransactor(ContextUtils.getCompanyId(),loginName);
	}
	@Deprecated
	public List<WorkflowTask> getTotalOverdueTasks(Long companyId) {
		return workflowTaskService.getTotalOverdueTasks(companyId);
	}
	
	public List<WorkflowTask> getTotalOverdueTasks() {
		Assert.notNull(ContextUtils.getCompanyId(),"公司id不能为null");
		return workflowTaskService.getTotalOverdueTasks(ContextUtils.getCompanyId());
	}
	@Deprecated
	public Map<String, Integer> getTotalOverdueTasksNumByTransactor(
			Long companyId) {
		return workflowTaskService.getTotalOverdueTasksNumByTransactor(companyId);
	}
	
	public Map<String, Integer> getTotalOverdueTasksNumByTransactor() {
		Assert.notNull(ContextUtils.getCompanyId(),"公司id不能为null");
		return workflowTaskService.getTotalOverdueTasksNumByTransactor(ContextUtils.getCompanyId());
	}
	
	/**
	 * 分页查询用户所有未完成任务
	 * @param page
	 */
	public void getAllTasksByUser(Long companyId, String loginName, Page<WorkflowTask> page){
		workflowTaskService.getAllTasksByUser(companyId,loginName,page);
	}
	
	/**
	 * 查询用户所有未完成任务(不是分页)
	 * @param page
	 */
	public List<WorkflowTask> getAllTasksByUser(Long companyId, String loginName){
		return workflowTaskService.getAllTasksByUser(companyId,loginName);
	}
	
	public List<String> getTransactorsExceptTask(Long taskId){
		return workflowTaskService.getTransactorsExceptTask(taskId);
	}
	
	/**
	 * 获得“任务组编号”最大的任务
	 * @param workflowId
	 * @param taskName
	 * @return
	 */
	private Integer getTaskMaxGroupNum(String workflowId,String taskName,Long companyId){
		List<WorkflowTask> tasks=workflowTaskService.getTaskOrderByGroupNum(companyId, workflowId, taskName);
		if(tasks.size()>0){
			WorkflowTask task1=tasks.get(0);
			if(task1.getGroupNum()==null||task1.getGroupNum().equals(0)){
				return 0;
			}else{
				return task1.getGroupNum();
			}
		}
		return 0;
	}
	
	/**
	 * 流程实例所有的环节名称的集合
	 * @param instanceId
	 * @return
	 */
	public List<String> getTaskNames(String workflowId){
		WorkflowInstance workflowInstance=workflowInstanceManager.getWorkflowInstance(workflowId);
		List<String> names=new ArrayList<String>();
		ProcessInstance instance = processEngine.getExecutionService().findProcessInstanceById(workflowId);
		//有并发或流程已结束不能退回
		if(instance==null || ((ExecutionImpl)instance).getSubProcessInstance() != null) 
			return names;
		//获得环节属性中“办理人设置”不是“字段中指定”的环节名称
		List<String> unFieldNames=DefinitionXmlParse.getUnFieldTaskNames(workflowInstance.getProcessDefinitionId());
		names.addAll(unFieldNames);
		return names;
	}
	/**
	 * 环节跳转处理
	 * @param workflowId
	 * @param backTo
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType taskJump(String workflowId, String backTo,Long companyId){
		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(workflowId,companyId);
		OpenExecution execution=(OpenExecution)processEngine.getExecutionService().findProcessInstanceById(instance.getProcessInstanceId()).findActiveExecutionIn(instance.getCurrentActivity());
		Object compIdStr=execution.getVariable(CommonStrings.COMPANY_ID);
		if(compIdStr==null){
			processEngine.getExecutionService().setVariable(execution.getId(), CommonStrings.COMPANY_ID, companyId);
		}
		return taskJump(instance,backTo,null,null);
	}
	
	@Autowired
	private JdbcSupport jdbcDao;
	
	/**
	 * 环节跳转处理
	 * @param workflowId
	 * @param backTo
	 * @return
	 */
	@Transactional(readOnly=false)
	public CompleteTaskTipType taskJump(WorkflowInstance instance, String backTo,List<String> transactors,String type){
		CompleteTaskTipType result=null;
		
//		WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(workflowId);
		String workflowId=instance.getProcessInstanceId();
		
		boolean isSubprocess=getActivetySubProcess(workflowId);
		if(isSubprocess){
			return CompleteTaskTipType.MESSAGE.setContent("当前环节为【子流程】环节,环节跳转时不支持该功能");
		}
		// 环节跳转时生成任务
		if(transactors!=null && transactors.size()>0){//当是"上一环节办理人指定"时生成任务
			generateTask(instance,backTo,transactors);
		}else{//当不是上一环节办理人指定时
			//判断backTo环节是否需要指定办理人
			Map<TaskTransactorCondition, String> conditions = DefinitionXmlParse.getTaskTransactor(instance.getProcessDefinitionId(),backTo);
			String userCondition = conditions.get(TaskTransactorCondition.USER_CONDITION);
			if(PRE_TRANSACTOR_ASSIGN.equals(userCondition)){
				result = CompleteTaskTipType.RETURN_URL;
			}else if(conditions.get(TaskTransactorCondition.SELECT_ONE_FROM_MULTIPLE).equals("true")&&conditions.get(TaskTransactorCondition.SELECT_TYPE).equals(TaskTransactorCondition.SELECT_TYPE_CUSTOM)){
				if("volumeBack".equals(type)){
					result = CompleteTaskTipType.MESSAGE.setContent("跳转到的环节为【选择具体办理人】,批量环节跳转时不支持该功能");
				}else{
					OpenExecution execution=(OpenExecution)processEngine.getExecutionService().findProcessInstanceById(instance.getProcessInstanceId()).findActiveExecutionIn(instance.getCurrentActivity());
					FormView form = formViewManager.getFormView(instance.getFormId());
					UserParseCalculator upc = new UserParseCalculator();
					upc.setDataId(instance.getDataId());
					upc.setFormView(form);
					String creator = execution.getVariable(CommonStrings.CREATOR)==null?null:execution.getVariable(CommonStrings.CREATOR).toString();
					upc.setDocumentCreator(creator);
					Object obj = execution.getVariable(CommonStrings.PREVIOUS_TASK_PRINCI_TRANSACTOR);
					if(obj==null){//上一环节办理人委托人为空，取办理人
						obj = execution.getVariable(CommonStrings.PREVIOUS_TASK_TRANSACTOR);
					}
					if(obj!=null){
						upc.setPreviousTransactor(obj.toString());
					}
					result = CompleteTaskTipType.SINGLE_TRANSACTOR_CHOICE.setCanChoiceTransactor(upc.getUsers(userCondition,instance.getSystemId(),instance.getCompanyId()));
				}
			}
			if(result!=null)return result;
			
			List<WorkflowTask> needSaveTasks = new ArrayList<WorkflowTask>();
			List<WorkflowTask> tasks = workflowTaskService.getActivityTasks(workflowId, instance.getCompanyId());
			//取消所有当前的环节
			for(WorkflowTask task :tasks){
//				if(!task.isSpecialTask()) {
					task.setActive(TaskState.CANCELLED.getIndex());
					task.setEffective(false);      //设置任务失效
					needSaveTasks.add(task);
					taskJumpHistoryProcess(workflowId, task, backTo);
//				}
			}
			//将jbpm退回到backto环节
			processEngine.execute(new GetBackCommand(instance.getProcessInstanceId(), backTo));
			//判断backTo节点是否是子流程节点
			if(!DefinitionXmlParse.isSubProcessTask(instance.getProcessDefinitionId(), backTo)){
				generateTask(instance,backTo);
				FormView form = formViewManager.getFormView(instance.getFormId());
				//如果表单是实体表单，同步实体的当前环节
				if(form.isStandardForm()){
					try {
						
						
						StringBuilder sql = new StringBuilder("UPDATE ").append(form.getDataTable().getName())
							.append(" SET current_activity_name='").append(backTo).append("' ")
							.append("where id=").append(instance.getDataId());
						jdbcDao.updateTable(sql.toString());
						
					} catch (Exception e) {
						log.error("为bean设置属性异常:" + e.getMessage());
					} 
				}
				this.saveTasks(needSaveTasks);
			}
		}
		//设置实例的相关属性
		if(instance.getProcessState()==ProcessState.END){
			instance.setProcessState(ProcessState.SUBMIT);
			instance.setEndTime(null);
		}
		instance.setCurrentActivity(backTo);
		//跳转后，不能再退回
		instance.setPreviousActivity(null);
		instance.setPreviousActivityTitle(null);
		workflowInstanceManager.saveWorkflowInstance(instance);
		//业务补偿
		taskJumpSet(instance);
		
		return CompleteTaskTipType.OK;
	}
	
	/**
	 * 流程监控/环节跳转的的业务补偿
	 * @param instance
	 * @param form
	 */
	private void taskJumpSet(WorkflowInstance instance){
		Map<String,String> taskJumpSet = DefinitionXmlParse.getMonitorTaskJumpSet(instance.getProcessDefinitionId());
		String setType=taskJumpSet.get(DefinitionXmlParse.SET_TYPE);
		String taskJumpSetUrl=taskJumpSet.get(DefinitionXmlParse.TASK_JUMP_MONITOR);
		if(StringUtils.isNotEmpty(taskJumpSetUrl)){
			String systemCode=WebUtil.getSystemCodeByDef(instance.getProcessDefinitionId());
			if(setType.equals("http")){
				WebUtil.getHttpConnection(taskJumpSetUrl,ContextUtils.getCompanyId(),instance.getDataId(),systemCode);
			}else if(setType.equals("RESTful")){
				WebUtil.restful(taskJumpSetUrl,ContextUtils.getCompanyId(),instance.getDataId(),systemCode);
			}
		}
	}
	/**
	 * 环节跳转时生成任务
	 * 当是"上一环节办理人指定"时生成任务
	 * @param instance
	 * @param taskName
	 */
	@Transactional(readOnly=false)
	private void generateTask(WorkflowInstance instance,String taskName,List<String> transactors){
		List<WorkflowTask> needSaveTasks = new ArrayList<WorkflowTask>();
		List<WorkflowTask> tasks = workflowTaskService.getActivityTasks(instance.getProcessInstanceId(), instance.getCompanyId());
		//取消所有当前的环节
		for(WorkflowTask task :tasks){
			if(!task.isSpecialTask()) {
				task.setActive(TaskState.CANCELLED.getIndex());
				task.setEffective(false);      //设置任务失效
				needSaveTasks.add(task);
				taskJumpHistoryProcess(instance.getProcessInstanceId(), task, taskName);
			}
		}
		this.saveTasks(needSaveTasks);
		//将jbpm跳转到taskName环节
		processEngine.execute(new GetBackCommand(instance.getProcessInstanceId(), taskName));
		
		Execution exec=processEngine.getExecutionService().findProcessInstanceById(instance.getProcessInstanceId()).findActiveExecutionIn(taskName);
		Object assign=processEngine.getExecutionService().getVariable(exec.getId(), CommonStrings.TRANSACTOR_ASSIGNMENT);
		if(assign!=null && PRE_TRANSACTOR_ASSIGN.equals(assign.toString())){
			SubProcessParse subprocessParse=(SubProcessParse)processEngine.getExecutionService().getVariable(exec.getId(),CommonStrings.SUBPROCESS_PARSE);
			ActivityExecution execution=(ActivityExecution)processEngine.getExecutionService().findExecutionById(subprocessParse.getExecutionId());
			execution.removeVariable(CommonStrings.TRANSACTOR_ASSIGNMENT);
			execution.removeVariable(CommonStrings.SUBPROCESS_PARSE);
			Map<TaskTransactorCondition, String> transactor = DefinitionXmlParse.getTaskTransactor(subprocessParse.getParentDefinitionId(),subprocessParse.getActivityName());
			this.startSubProcessWorkflow(transactor, subprocessParse,transactors);
		}else{
			setTaskJumpTransactor(instance,taskName,transactors);
		}
	}
	/**
	 * 环节跳转时生成任务
	 * 当是"上一环节办理人指定"时生成任务
	 * @param instance
	 * @param taskName
	 */
	@Transactional(readOnly=false)
	private void setTaskJumpTransactor(WorkflowInstance instance,String taskName,List<String> transactors){
		List<String> trans=new ArrayList<String>();
		Set<String> transcatorsSet = new HashSet<String>();
		if(CommonStrings.ALL_USER.equals(transactors.get(0))){//当时所有人时
			List<com.norteksoft.product.api.entity.User> users=ApiFactory.getAcsService().getUsersByCompany(instance.getCompanyId());
			for(com.norteksoft.product.api.entity.User u:users){
				trans.add(u.getLoginName());
			}
			transcatorsSet.addAll(trans);
		}else{
			transcatorsSet.addAll(transactors);
		}
		org.jbpm.api.task.Task jbpmTask = processEngine.getTaskService().createTaskQuery()
		.processInstanceId(instance.getProcessInstanceId())
		.activityName(taskName).uniqueResult();
    	
    	Integer groupNum=getTaskMaxGroupNum(instance.getProcessInstanceId(),jbpmTask.getActivityName(),instance.getCompanyId());
    	groupNum++;
    	for(String transcator:transcatorsSet){
    		if(transcator.contains(":")){
    			String[] transacts=transcator.split(":");
    			WorkflowTask wfTask=createTask(instance.getProcessInstanceId(), jbpmTask.getExecutionId(), transacts[0] ,jbpmTask.getActivityName(),groupNum);
    			//审批任务有多个办理人时设置为待领取
				if(!wfTask.getMoreTransactor()&&transcatorsSet.size()>1){
					wfTask.setActive(TaskState.DRAW_WAIT.getIndex());
				}
    			wfTask.setRemark(transacts[1]);
    			saveTask(wfTask);
    		}else{
    			WorkflowTask wfTask = createTask(instance.getProcessInstanceId(), jbpmTask.getExecutionId(), transcator ,jbpmTask.getActivityName(),groupNum);
    			//审批任务有多个办理人时设置为待领取
				if(!wfTask.getMoreTransactor()&&transcatorsSet.size()>1){
					wfTask.setActive(TaskState.DRAW_WAIT.getIndex());
				}
    			saveTask(wfTask);
    		}
    		
        	((OpenExecution)processEngine.getExecutionService()
    				.findExecutionById(jbpmTask.getExecutionId())).removeVariable(CommonStrings.TRANSACTOR_SINGLE_CANDIDATES);
        	//"上一环节指定办理人"或"办理人设置"/"选择具体办理人"/“人工选择”
    		if(jbpmTask.getAssignee().equals(CommonStrings.TRANSACTOR_ASSIGNMENT)||jbpmTask.getAssignee().equals(CommonStrings.TRANSACTOR_SINGLE)){
        		processEngine.getTaskService().assignTask(jbpmTask.getId(),transcator);
        	}
    	}
	}
	/**
	 * 环节跳转时生成任务
	 * 当不是"上一环节办理人指定"时生成任务
	 * @param instance
	 * @param taskName
	 */
	@Transactional(readOnly=false)
	private void generateTask(WorkflowInstance instance,String taskName){
		org.jbpm.api.task.Task jbpmTask = processEngine.getTaskService().createTaskQuery()
		.processInstanceId(instance.getProcessInstanceId())
		.activityName(taskName).uniqueResult();
		// 组任务
		if(jbpmTask == null){
			jbpmTask = processEngine.getTaskService().createTaskQuery()
				.processInstanceId(instance.getProcessInstanceId())
				.candidate(ContextUtils.getLoginName())
				.activityName(taskName).uniqueResult();
		}
		String parentExecutionId = null;
    	Execution execution = processEngine.getExecutionService().findExecutionById(jbpmTask.getExecutionId());
    	Execution parentExecution = execution.getParent();
    	if(parentExecution != null){
    		parentExecutionId = parentExecution.getId();
    	}
		generateTask(instance,execution.getId(),parentExecutionId);
	}
	/**
	 * 流程监控/增加办理人
	 * @param instance
	 * @param taskName
	 */
	@Transactional(readOnly=false)
	public void addTransactor(String workflowId,List<String> transactors){
		WorkflowInstance wfi = workflowInstanceManager.getWorkflowInstance(workflowId);
		List<WorkflowTask> tasks = workflowTaskService.getActivitySignTasks(workflowId, wfi.getCompanyId());
		WorkflowTask task=null;
		if(tasks!=null&&tasks.size()>0)task=tasks.get(0);
		if(task==null)return;
		
		//生成任务
		generateTask(task.getId(), transactors,TaskSource.ADD_TRANSACTOR);
		
		List<WorkflowTask> currentTasks=workflowTaskService.getActivitySignTasks(task.getProcessInstanceId(), task.getCompanyId());
		//任务为单人办理，且任务有多个办理人时设置为待领取
		if(currentTasks!=null&¤tTasks.size()>1){
			List<WorkflowTask> result=new ArrayList<WorkflowTask>();
			boolean isMoreTransactor=DefinitionXmlParse.hasMoreTransactor(wfi.getProcessDefinitionId(), task.getName());
			if(!isMoreTransactor){
				for(WorkflowTask currentTask:currentTasks){
					//如果任务是会签式或投票式默认为多人办理模式,所以当任务不是会签式和投票式时才有必要设置任务状态为待领取
					if(TaskProcessingMode.TYPE_COUNTERSIGNATURE!=currentTask.getProcessingMode()&&TaskProcessingMode.TYPE_VOTE!=currentTask.getProcessingMode()){
						if(TaskState.WAIT_TRANSACT.getIndex().equals(currentTask.getActive())){
							currentTask.setActive(TaskState.DRAW_WAIT.getIndex());
							currentTask.setTitle(task.getTitle());//增加办理人时将任务的标题设为源任务的标题，因为流程监控中无法取字段的值
							result.add(currentTask);
						}
					}
				}
				saveTasks(result);
			}
		}
		
		//生成流传历史
		generateAddTransactorHistory(task,wfi,transactors);
	}
	/**
	 * 生成增加办理人流转历史
	 * @param instance
	 * @param taskName
	 */
	private void generateAddTransactorHistory(WorkflowTask task,
			WorkflowInstance wfi,List<String> transactors) {
		String historyMessage = new StringBuilder(dateFormat.format(new Date()))
		.append(COMMA).append(ContextUtils.getUserName()).append(PROCESS_ADDTRANSACTOR)
		.append(getTransactorName(transactors)).append(DELTA_START)
		.append(task.getName()).append(DELTA_END).append("\n").toString();
		
		InstanceHistory history = new InstanceHistory(task.getCompanyId(), wfi.getProcessInstanceId(), InstanceHistory.TYPE_TASK, historyMessage, task.getName());
		history.setEffective(false);
		history.setCreatedTime(new Date());
		history.setExecutionId(wfi.getProcessInstanceId());
		
        instanceHistoryManager.saveHistory(history);
		
	}

	
	/**
	 * 根据
	 * @param instance
	 * @param taskName
	 */
	private Object getTransactorName(List<String> transactors) {
		String result = "";
		for(String transactor:transactors){
			result+=acsUtils.getUserByLoginName(transactor).getName()+",";
		}
		return result.substring(0, result.length()-1);
	}

	/**
	 * 流程监控/减少办理人
	 * @param instance
	 * @param taskName
	 */
	@Transactional(readOnly=false)
	public void delTransactor(String workflowId,List<String> transactors){
		WorkflowInstance wfi = workflowInstanceManager.getWorkflowInstance(workflowId);
		List<WorkflowTask> tasks = workflowTaskService.getActivitySignTasks(workflowId, wfi.getCompanyId());
		WorkflowTask task=null;
		if(tasks!=null&&tasks.size()>0)task=tasks.get(0);
		if(task==null)return;
		deleteCountersignHandler(task.getId(), transactors);
		
		List<WorkflowTask> currentTasks=workflowTaskService.getActivitySignTasks(task.getProcessInstanceId(), task.getCompanyId());
		//任务为单人办理，且任务只有一个办理人时且任务的状态为“待领取”时，设置任务为”待办理“状态
		if(currentTasks!=null&¤tTasks.size()==1){
			
			boolean isMoreTransactor=DefinitionXmlParse.hasMoreTransactor(wfi.getProcessDefinitionId(), task.getName());
			if(!isMoreTransactor){
				WorkflowTask currentTask=currentTasks.get(0);
				if(TaskState.DRAW_WAIT.getIndex().equals(currentTask.getActive()))currentTask.setActive(TaskState.WAIT_TRANSACT.getIndex());
				saveTask(currentTask);
			}
		}
		//生成流转历史
		generateRemoveTransactorHistory(task,wfi,transactors);
	}
	
	private void generateRemoveTransactorHistory(WorkflowTask task,
			WorkflowInstance wfi, List<String> transactors) {
		String historyMessage = new StringBuilder(dateFormat.format(new Date()))
		.append(COMMA).append(ContextUtils.getUserName()).append(PROCESS_REMOVETRANSACTOR)
		.append(getTransactorName(transactors)).append(DELTA_START)
		.append(task.getName()).append(DELTA_END).append("\n").toString();
		
		InstanceHistory history = new InstanceHistory(task.getCompanyId(), wfi.getProcessInstanceId(), InstanceHistory.TYPE_TASK, historyMessage, task.getName());
		history.setEffective(false);
		history.setCreatedTime(new Date());
		history.setExecutionId(wfi.getProcessInstanceId());
		
        instanceHistoryManager.saveHistory(history);
		
	}

	public List<String[]> getActivityTaskTransactors(String workflowId){
		WorkflowInstance wfi = workflowInstanceManager.getWorkflowInstance(workflowId);
		if(wfi==null){log.debug("获得当前任务和办理时，流程实例不能为null");throw new RuntimeException("获得当前任务和办理时，流程实例不能为null");}
		return workflowTaskService.getActivityTaskTransactors(workflowId,wfi.getCompanyId());
	}
	
	public List<String> getActivityTaskPrincipals(String workflowId){
		WorkflowInstance wfi = workflowInstanceManager.getWorkflowInstance(workflowId);
		return workflowTaskService.getActivityTaskPrincipals(workflowId, wfi.getCompanyId());
	}
	public List<String[]> getActivityTaskPrincipalsDetail(String workflowId){
		WorkflowInstance wfi = workflowInstanceManager.getWorkflowInstance(workflowId);
		return workflowTaskService.getActivityTaskPrincipalsDetail(workflowId, wfi.getCompanyId());
	}
	/**
	 * 暂停任务
	 */
	@Transactional(readOnly=false)
	public void pauseTasks(String processInstanceId, Long companyId) {
		workflowTaskService.pauseTasks(processInstanceId,companyId);
	}
	
	/**
	 * 继续被暂停的任务
	 */
	@Transactional(readOnly=false)
	public void continueTasks(String processInstanceId, Long companyId) {
		workflowTaskService.continueTasks(processInstanceId,companyId);
	}
	/**
	 * 批量移除任务中根据办理人查询当前任务列表
	 * @param tasks
	 * @param transactorName
	 * @param typeId
	 * @param defCode
	 * @param wfdId
	 */
	
	public void getActivityTasksByTransactorName(Page<WorkflowTask> tasks,Long typeId, String defCode,Long wfdId){
		workflowTaskService.getActivityTasksByTransactorName(tasks,  typeId, defCode, wfdId);
	}
	@Transactional(readOnly=false)
	public Map<String, List<WorkflowTask>> deleteTasks(List<Long> taskIds){
		// 将所有需要删除的任务按实例分组
		Map<String, List<WorkflowTask>> instanceTasks = new HashMap<String, List<WorkflowTask>>();
		
		WorkflowTask task = null;
		for(Long id:taskIds){
			task = getWorkflowTask(id);
			if(instanceTasks.get(task.getProcessInstanceId())==null){
				instanceTasks.put(task.getProcessInstanceId(), new ArrayList<WorkflowTask>());
			}
			instanceTasks.get(task.getProcessInstanceId()).add(task);
		}
		Map<String, List<WorkflowTask>> result = new HashMap<String, List<WorkflowTask>>();
		// 判断是否可以删除任务
		for(Map.Entry<String, List<WorkflowTask>> en : instanceTasks.entrySet()){
			// 查询实例当前活动的任务
			List<WorkflowTask> tasks = getActivityTasks(en.getKey(), en.getValue().get(0).getCompanyId());
			if(tasks.size()==1){ // 只有一个活动任务不允许删除
				if(result.get("JUST_ONE") == null) result.put("JUST_ONE", new ArrayList<WorkflowTask>());
				result.get("JUST_ONE").add(en.getValue().get(0));
			}else if(tasks.size() == en.getValue().size()){ // 实例活动任务多于一个，但不允许删除所有活动的任务
				result.put(en.getKey(), en.getValue());
			}else{
				deleteTaskInList(en.getValue());
			}
		}
		return result;
	}
	private void deleteTaskInList(List<WorkflowTask> tasks){
		String instanceId=null;
		Long companyId=null;
		if(tasks.size()>0){
			instanceId=tasks.get(0).getProcessInstanceId();
			companyId=tasks.get(0).getCompanyId();
		}
		for(WorkflowTask task : tasks){
			workflowTaskService.deleteTask(task);
		}
		if(StringUtils.isNotEmpty(instanceId)&&companyId!=null){
			List<WorkflowTask> activeTasks = getActivityTasks(instanceId, companyId);
			if(activeTasks!=null&&activeTasks.size()==1){
				WorkflowTask task=activeTasks.get(0);
				if(task.getActive().equals(TaskState.DRAW_WAIT.getIndex())){//待领取改为待办理
					task.setActive(TaskState.WAIT_TRANSACT.getIndex());
					saveTask(task);
				}
			}
		}
	}
	/**
	 * 批量移除任务
	 * @param taskIds
	 * @return
	 */
	@Transactional(readOnly=false)
	public String deleteTasksBatch(List<Long> taskIds){
		int sucessNum=0;
		int failNum=0;
		for(Long id:taskIds){
			WorkflowTask task=getWorkflowTask(id);
			List<WorkflowTask> tasks=getActivityTasks(task.getProcessInstanceId(), task.getCompanyId());
			if(tasks!=null&&tasks.size()>1){
				ArrayList<Long> idList=new ArrayList<Long>();
				idList.add(id);
				sucessNum++;
				deleteWorkflowTask(idList);
				//设置流程状态
				tasks=getActivityTasks(task.getProcessInstanceId(), task.getCompanyId());
				if(tasks!=null&&tasks.size()==1){
					task=tasks.get(0);
					if(task.getActive()==4){//待领取改为待办理
						task.setActive(0);
						saveTask(task);
					}
				}
			}
		}
		failNum=taskIds.size()-sucessNum;
		StringBuilder sb=new StringBuilder();
		sb.append("成功移除")
		.append(sucessNum).append("个;")
		.append("移除失败").append(failNum).append("个");
		return sb.toString();
	}
	
	/**
	 * 根据委托查询任务计划
	 * @param instanceIds 实例id的集合
	 * @param taskName 任务名称
	 * @param recieveUser 委托的受托人登录名
	 * @param consignor 委托的委托人登录名
	 * @return
	 */
	public List<WorkflowTask> getTasksByInstance(List<String> instanceIds,String taskName,String recieveUser,String consignor,Long companyId){
		List<WorkflowTask> result = new ArrayList<WorkflowTask>();
		if(StringUtils.isNotEmpty(taskName)){
			String[] taskNames = taskName.split(",");
			for(String t : taskNames){
				result.addAll(workflowTaskService.getTasksByInstance(instanceIds, t,recieveUser,consignor,companyId));
			}
		}else{
			result.addAll(workflowTaskService.getTasksByInstance(instanceIds, null,recieveUser,consignor,companyId));
		}
		return result;
	}
	
	/**
	 * 取消委托或委托过期时取回委托的任务
	 */
	public void recieveDelegateTask(TrustRecord delegateMain){
		List<String> instanceIds=new ArrayList<String>();
		if(delegateMain.getStyle()==1){
			instanceIds=workflowInstanceManager.getInstanceIdByDelegate(delegateMain);
		}
		List<WorkflowTask> tasks=getTasksByInstance(instanceIds,delegateMain.getActivityName(),delegateMain.getTrustee(),delegateMain.getTrustor(),delegateMain.getCompanyId());
		WorkflowTask targetTask =null;
		List<WorkflowTask> cancelTasks = new ArrayList<WorkflowTask>();
		List<WorkflowTask> targetTasks=new ArrayList<WorkflowTask>();
		for(WorkflowTask task:tasks){
			//流程类型
			WorkflowType type=getType(task);
			
			//得到当前办理人集合
			List<String[] > currentTransactors=workflowTaskService.getActivityTaskTransactors(task.getProcessInstanceId(), ContextUtils.getCompanyId());
			if(!currentTransactors.contains(delegateMain.getTrustor())){
				targetTask = task.clone();
				targetTask.setId(null);
				targetTask.setTrustor(null);//将该任务的委托人设为空，即使该任务不再是委托任务
				targetTask.setTrustorName(null);//将该任务的委托人设为空，即使该任务不再是委托任务
				targetTask.setTransactor(delegateMain.getTrustor());
				User user= userManager.getUserByLoginName(delegateMain.getTrustor());
				if(user!=null){
					targetTask.setTransactorName(user.getName());
				}
				targetTask.setRead(false);
				targetTask.setVisible(true);
				
				//*******************消息提醒*************************
				sendMessage(targetTask,type);
				//******************发送邮件*************************
				WorkflowInstance instance = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
				sendMail(targetTask, instance.getProcessDefinitionId());
				targetTasks.add(targetTask);
			}
			task.setTaskProcessingResult(null);
	    	task.setActive(TaskState.CANCELLED.getIndex());
	    	cancelTasks.add(task);
		}
		saveTasks(targetTasks);
		saveTasks(cancelTasks);
	}
	private WorkflowType getType(WorkflowTask task){
		String processId= processEngine.getExecutionService().findProcessInstanceById(task.getProcessInstanceId()).getProcessDefinitionId();
		WorkflowDefinition wfDef = workflowDefinitionManager.getWorkflowDefinitionByProcessId(processId);
		//流程类型
		WorkflowType type=null;
		if(wfDef!=null){
			//流程类型
			type=workflowTypeManager.getWorkflowType(wfDef.getTypeId());
		}
		return type;
	}
	public List<Integer> getGroupNumByTaskName(String processInstanceId,String taskName){
		return workflowTaskService.getGroupNumByTaskName(processInstanceId, taskName);
	}
	//是否是分支汇聚任务，true表示是分支任务，false表示不是
	public boolean isForkTask(String workflowId){
		List<WorkflowTask> tasks = workflowTaskService.getActivityTasks(workflowId, ContextUtils.getCompanyId());
		for(WorkflowTask task:tasks){
			if(!workflowId.equals(task.getExecutionId())){//表示是分支汇聚任务
				return true;
			}
		}
		return false;
	}
	
	public String goBackTask(Long taskId){
		Assert.notNull("流程实例workflow不能为null");
		WorkflowTask task = workflowTaskService.getTask(taskId);
		Assert.notNull("当前任务task不能为null");
		if(!(TaskState.WAIT_TRANSACT.getIndex().equals(task.getActive())))return "当前任务不是待办理任务，不能退回";
		WorkflowInstance workflow = workflowInstanceManager.getWorkflowInstance(task.getProcessInstanceId());
		if(workflow.getProcessState()==ProcessState.END || workflow.getProcessState()==ProcessState.MANUAL_END|| workflow.getProcessState()==ProcessState.PAUSE){
    		if(workflow.getParentProcessId()==null){
    			return "流程已经结束或者被取消或已暂停，不能退回";
    		}else{
    			return "子流程已经结束或者被取消或已暂停，不能退回";
    		}
    	}
		if(!workflow.getProcessInstanceId().equals(task.getExecutionId())){
			return "当前环节为分支环节不能退回";
		}
		
		if(task.getMoreTransactor()){
    		List<WorkflowTask> activeTasks = workflowTaskService.getActivityTasksByNameWithout(workflow.getProcessInstanceId(), taskId, task.getName());
    		if(activeTasks.size()>0){//有多个人,将当前任务减签
    			deleteCountersignHandler(taskId,Arrays.asList(task.getTransactor()));
    			return "退回成功";
    		}
    	}
		String backTo =  workflow.getPreviousActivity();
		if(StringUtils.isEmpty(backTo))return "无法退回。可能是历史任务或是被退回、取回、跳转的任务。";
		WorkflowTask previousTask=workflowTaskService.getLastCompletedTaskByTaskName(task.getProcessInstanceId(), task.getCompanyId(), backTo);
		if(previousTask!=null){
			if(!workflow.getProcessInstanceId().equals(previousTask.getExecutionId())){
				return "上一环节为分支环节不能退回";
			}
			if(previousTask.getMoreTransactor()){
				return "上一环节是多人办理不能退回";
			}else{
				//退回成功
				List<WorkflowTask> needSaveTasks = new ArrayList<WorkflowTask>();
				//取消当前环节任务
				task.setActive(TaskState.CANCELLED.getIndex());
				task.setEffective(false);      //设置任务失效
				needSaveTasks.add(task);
				gobackTaskHistoryProcess(workflow.getProcessInstanceId(), task, backTo);
				
				//将jbpm退回到backto环节
				processEngine.execute(new GetBackCommand(workflow.getProcessInstanceId(), backTo));
				//如果退回到的环节办理人为"上一环节办理人指定"或“条件筛选/选择具体办理人/人工选择”，则设置jbpmTask的办理人为previousTask的办理人
				ActivityExecution execution = (ActivityExecution) processEngine.getExecutionService().findExecutionById(task.getExecutionId());
				org.jbpm.api.task.Task jbpmTask = processEngine.getTaskService().createTaskQuery()
				.processInstanceId(task.getProcessInstanceId())
				.activityName(execution.getActivityName()).uniqueResult();   
				if(jbpmTask!=null && (CommonStrings.TRANSACTOR_ASSIGNMENT.equals(jbpmTask.getAssignee())||CommonStrings.TRANSACTOR_SINGLE.equals(jbpmTask.getAssignee()))){
	        		processEngine.getTaskService().assignTask(jbpmTask.getId(),previousTask.getTransactor());
	        	}
				//判断backTo节点是否是子流程节点
				if(!DefinitionXmlParse.isSubProcessTask(workflow.getProcessDefinitionId(), backTo)){
					FormView form = formViewManager.getFormView(workflow.getFormId());
					//如果表单是实体表单，同步实体的当前环节
					if(form.isStandardForm()){
						try {
							StringBuilder sql = new StringBuilder("UPDATE ").append(form.getDataTable().getName())
							.append(" SET current_activity_name='").append(backTo).append("' ")
							.append("where id=").append(workflow.getDataId());
							jdbcDao.updateTable(sql.toString());
							
						} catch (Exception e) {
							log.error("为bean设置属性异常:" + e.getMessage());
						} 
					}
					this.saveTasks(needSaveTasks);
				}
				//设置实例的相关属性
				if(workflow.getProcessState()==ProcessState.END){
					workflow.setProcessState(ProcessState.SUBMIT);
					workflow.setEndTime(null);
				}
				workflow.setCurrentActivity(backTo);
				//退回生成的任务，不能再退回
				workflow.setPreviousActivity(null);
				workflow.setPreviousActivityTitle(null);
				
				//生成退回的任务
				WorkflowTask backToTask=previousTask.clone();
				backToTask.setId(null);
				backToTask.setActive(TaskState.WAIT_TRANSACT.getIndex());
				backToTask.setRead(false);
				backToTask.setCreatedTime(new Date());
				backToTask.setTransactDate(null);
				saveTask(backToTask);
				
				workflow.setInstanceTitle(backToTask.getTitle());
				workflowInstanceManager.saveWorkflowInstance(workflow);
				
				//退回时回调
				String beanName=DefinitionXmlParse.getGobackTaskBean(workflow.getProcessDefinitionId());
				if(StringUtils.isNotEmpty(beanName)){
					ReturnTaskInterface gobackTaskInterface = (ReturnTaskInterface)ContextUtils.getBean(beanName);
					gobackTaskInterface.goback(workflow, task, backToTask);
				}
				return "退回成功";
			
		}
	  }else{
			return "可能是第一环节或取回的任务,不能退回";
	  }
	}
	
	/**
	 * 判断当前环节是否是子流程
	 * @param processInstanceId
	 * @return
	 */
	
	public boolean getActivetySubProcess(String processInstanceId) {
		List<Object> subProcess = workflowInstanceManager.getActivetySubProcess(processInstanceId);
		if(subProcess.size()>0){
			return true;
		}
		return false;
	}
}