package com.wondersgroup.zjoa.core.service;

import java.sql.Timestamp;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;

import javax.annotation.Resource;

import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import com.wondersgroup.zjoa.core.constant.DocMarks;
import com.wondersgroup.zjoa.core.constant.Globals;
import com.wondersgroup.zjoa.core.constant.Group;
import com.wondersgroup.zjoa.core.constant.WorkFlowNode;
import com.wondersgroup.zjoa.core.constant.Workflow;
import com.wondersgroup.zjoa.core.entity.OaDocAuditUser;
import com.wondersgroup.zjoa.core.entity.OaDocProcessUser;
import com.wondersgroup.zjoa.core.entity.OaDocuments;
import com.wondersgroup.zjoa.core.entity.OaProcess;
import com.wondersgroup.zjoa.core.entity.SystemGroup;
import com.wondersgroup.zjoa.core.entity.doc.OaDocProcessUserEntity;
import com.wondersgroup.zjoa.core.entity.workflow.BaseOaWfHistoryRela;
import com.wondersgroup.zjoa.core.entity.workflow.BaseOaWfInstance;
import com.wondersgroup.zjoa.core.entity.workflow.BaseOaWfProcessUser;
import com.wondersgroup.zjoa.core.entity.workflow.EndWfParams;
import com.wondersgroup.zjoa.core.entity.workflow.NextWfParams;
import com.wondersgroup.zjoa.core.entity.workflow.ProcessUser;
import com.wondersgroup.zjoa.core.entity.workflow.StartWfParams;
import com.wondersgroup.zjoa.core.entity.workflow.WorkflowInfo;
import com.wondersgroup.zjoa.core.form.DocumentForm;
import com.wondersgroup.zjoa.core.form.WfHistoryEntry;
import com.wondersgroup.zjoa.core.form.DocsReceiveProcessForm;
import com.wondersgroup.zjoa.core.repository.OaDocAuditUserRepository;
import com.wondersgroup.zjoa.core.repository.OaDocProcessUserRepository;
import com.wondersgroup.zjoa.core.repository.OaDocumentsRepository;
import com.wondersgroup.zjoa.core.repository.OaProcessRepository;
import com.wondersgroup.zjoa.core.repository.SystemGroupRepository;
import com.wondersgroup.zjoa.core.repository.SystemUserRepository;
import com.wondersgroup.zjoa.core.repository.workflow.BaseOaWfHistoryRelaRepository;
import com.wondersgroup.zjoa.core.repository.workflow.BaseOaWfProcessUserRepository;
import com.wondersgroup.zjoa.core.util.DateUtils;

/**
 *  Receipt 
 * 
 * @author yaozhenzhen 20200227
 *
 */

@Service
public class DocReceiveService {
	@Resource
	private DataDictionaryService dataDictionaryService;
	@Resource
	private SystemUserService systemUserService;
	@Resource
	private SystemGroupService systemGroupService;
	@Resource
	private SystemGroupRepository systemGroupRepository;
	@Resource
	private SystemUserRepository systemUserRepository;
	@Resource
	private OaDocumentsRepository oaDocumentsRepository;

	@Resource
	private OaProcessRepository oaProcessRepository;

	@Resource
	private OaDocAuditUserRepository auditUserRepository;
	@Resource
	private OaDocProcessUserRepository processUserRepository;
	@Resource
	private WorkFlowService workflowService;
	@Resource
	private BaseOaWfHistoryRelaRepository baseOaWfHistoryRelaRepository;
	@Resource
	private BaseOaWfProcessUserRepository baseOaWfProcessUserRepository;
	/**
	 *  Initialize the basic information of incoming documents   Dictionary item initialization 
	 * 
	 * @return documentForm
	 */
	public DocumentForm receiveDocBaseInit() {
		DocumentForm documentForm = new DocumentForm();
		documentForm.setEmergentLevelList(
				dataDictionaryService.getChildrenDataDictionarysByDictCode(Globals.DataDictionary_Code_Documents.JJCD));
		documentForm.setCagegoryList(
				dataDictionaryService.getChildrenDataDictionarysByDictCode(Globals.DataDictionary_Code_Documents.LWLX));
		return documentForm;
	}

	/**
	 *  According to the received document ID Get the basic information of the incoming document 
	 * 
	 * @param docUuid
	 * @return
	 */
	public OaDocuments findByDocUuid(String docUuid) {
		return oaDocumentsRepository.findTopByDocUuid(docUuid);
	}

	/**
	 *  Handle according to Id Get processing details 
	 * 
	 * @param processUuid
	 * @return
	 */
	public OaProcess findByProcessUuid(String processUuid) {
		return oaProcessRepository.findByProcessUuid(processUuid);
	}

	/**
	 *  Obtain registration information   Selected leaders and departments 
	 * 
	 * @return
	 */
	public DocsReceiveProcessForm receiveRegisterProcess(String docUuid,String processUuid) {
		DocsReceiveProcessForm processForm = new DocsReceiveProcessForm();
		processForm.setProcessUuid(processUuid);
		//  Instruction leader drop-down box 
		processForm.setBanLeaderList(systemUserService.findAllValid());

		//  Saved department leader （ Required  ）
		OaDocAuditUser auditUser = auditUserRepository
				.findAuditByDocUuidAndAuditType(docUuid, DocMarks.AuditType.CHULEADER).get(0);
		//  organization id
		processForm.setOwnerGroupId(auditUser.getAuditUserOrganCode());
		//  Organization name 
		processForm.setOwnerGroupName(systemGroupService.load(auditUser.getAuditUserOrganCode()).getName());
		//  Leader of the audit office userName
		processForm.setLeaderName(auditUser.getAuditUser());
		//  Gets the set of approval leaders under the currently selected organization （ Drop down box initialization ）
		processForm.setLeaderList(systemUserService.findUserByGroupId(auditUser.getAuditUserOrganCode()));

		//  Saved leadership set 
		processForm.setSelectedAuditUserList(
				auditUserRepository.findAuditUserByDocUuidAndAuditType(docUuid, DocMarks.AuditType.BANLEADER));
		//  Set of saved processing departments 
		List<OaDocProcessUser> processUserList=processUserRepository.findProcessUserListByDocUuid(docUuid);
						
		if(!CollectionUtils.isEmpty(processUserList)) {
			List<OaDocProcessUserEntity> processUserEntityList=toSetProcessUserEntityList(processUserList);
			// Set of selected processing departments 			
			processForm.setSelectedOrganList(processUserEntityList);

		}				
		return processForm;                              
	}
	/**
	 *  Seal the handling department 
	 * @param processUserList
	 * @return
	 */
	private List<OaDocProcessUserEntity> toSetProcessUserEntityList(List<OaDocProcessUser> processUserList){
		List<OaDocProcessUserEntity> processUserEntityList=new ArrayList<OaDocProcessUserEntity>();
		for(OaDocProcessUser processUser:processUserList) {
			OaDocProcessUserEntity processUserEntity=new OaDocProcessUserEntity();
			SystemGroup group=systemGroupRepository.findGroupById(processUser.getUserOrganCode());
			processUserEntity.setDocUuid(processUser.getDocUuid());
			processUserEntity.setProcessUuid(processUser.getProcessUuid());
			processUserEntity.setGroupName(group.getName());
			processUserEntity.setProcessUser(processUser.getProcessUser());
			processUserEntity.setUserOrganCode(processUser.getUserOrganCode());
			processUserEntity.setUserList(systemUserService.findUserByGroupId(processUser.getUserOrganCode()));
			processUserEntityList.add(processUserEntity);
		}
		
		return processUserEntityList;
	}

	/**
	 *  Save basic information and handling information 
	 * 
	 * @param processForm
	 * @param documentForm
	 * @throws ParseException
	 */
	@Transactional
	public void toSaveProcessInfo(DocsReceiveProcessForm processForm, DocumentForm documentForm, String userName,String userGroupId)
			throws ParseException {
		final String nextUserGroupId=processForm.getOwnerGroupId();
		// Obtained according to the organization of the selected approver 
		 //  Save the handling department 
		if (processForm.getGroupUserMap().size() > 0) {
			saveProcessUser(processForm.getGroupUserMap(), processForm.getProcessUuid(), processForm.getDocUuid(),
					userName,DocMarks.PROCESS_TYPE);
		}
		//  Save basic information 
		saveOaDocument(documentForm, userName);
		//  Keep the leader of the Department 
		List<String> chuLeaderList = new ArrayList<String>();
		chuLeaderList.add(processForm.getLeaderName());
		saveAuditUser(chuLeaderList, processForm.getProcessUuid(), processForm.getDocUuid(), userName,
				DocMarks.AuditType.CHULEADER, processForm.getOwnerGroupId());
		//  Preservation Office （ Instructions ） leader 
		saveAuditUser(processForm.getToGetAuditUserList(), processForm.getProcessUuid(), processForm.getDocUuid(),
				userName, DocMarks.AuditType.BANLEADER, Group.KCB.getId());

		//  Save processing information 
		saveRegistProcess(processForm, userName);
		//  Start the process 
		ProcessUser processUser = new ProcessUser();
		ProcessUser startUser = new ProcessUser();
		processUser.setOrganCode(nextUserGroupId);
		processUser.setLoginName(processForm.getLeaderName());
		startUser.setOrganCode(userGroupId);
		startUser.setLoginName(userName);

		//  Start the process 
		startUser.setLoginName(userName);
		Integer wfInstanceId = startWf(Workflow.WfDefinition.WF_DOC_RECEIVE, "0000", // TODO  Serial number 
				processForm.getDocUuid(), processForm.getProcessUuid(), userGroupId, 
				startUser, userName);                      
		//  Submit to the person in charge for review , Need review 
		if (!CollectionUtils.isEmpty(processForm.getToGetAuditUserList())) {
			nextWf(wfInstanceId, userGroupId, 
					userName, processUser, WorkFlowNode.CONDITION.RECEIVE_PROCESS //  Need review 
			);
		} else {
			//  There is no need to handle , Go directly to the confidential file 
			nextWf(wfInstanceId, userGroupId, //  Current organization 
					userName, startUser, WorkFlowNode.CONDITION.RECEIVE_NO_PROCESS //  no   Need review 
			);
		}
	}

	/**
	 *  Update the basic registration information and handling information of return modification 
	 * 
	 * @param processForm
	 * @param documentForm
	 * @throws ParseException
	 */
	@Transactional
	public void toSaveReceive01(DocsReceiveProcessForm processForm, DocumentForm documentForm, String userName,String userGroupId)
			throws ParseException {
		final Integer wfInstanceId = processForm.getWfInstanceId();
		final String nextProcessUserGroupId=processForm.getOwnerGroupId();
		//  Update basic information 
		updateOaDocument(documentForm, userName);
		
		//  Save the handling department 
		saveProcessUser(processForm.getGroupUserMap(), processForm.getProcessUuid(), processForm.getDocUuid(),
				userName,DocMarks.PROCESS_TYPE);
		
		//  Keep the leader of the Department 
		List<String> chuLeaderList = new ArrayList<String>();
		chuLeaderList.add(processForm.getLeaderName());
		saveAuditUser(chuLeaderList, processForm.getProcessUuid(), processForm.getDocUuid(), userName,
				DocMarks.AuditType.CHULEADER, processForm.getOwnerGroupId());
		
		//  Save leadership 		
		saveAuditUser(processForm.getToGetAuditUserList(), processForm.getProcessUuid(), processForm.getDocUuid(),
				userName, DocMarks.AuditType.BANLEADER, Group.KCB.getId());// TODO  Change to the office leadership organization ID
		
		//  Save processing information 
		saveRegistProcess(processForm, userName);

		//  Drive the process 
		ProcessUser processUser = new ProcessUser();
		ProcessUser startUser = new ProcessUser();
		processUser.setOrganCode(nextProcessUserGroupId);
		processUser.setLoginName(processForm.getLeaderName());
		startUser.setOrganCode(userGroupId);
		startUser.setLoginName(userName);
		//  Start the process 
		startUser.setLoginName(userName);
		//  Submit to the person in charge for review , Need review 
		if (!CollectionUtils.isEmpty(processForm.getToGetAuditUserList())) {
			nextWf(wfInstanceId, userGroupId, 
					userName, processUser, WorkFlowNode.CONDITION.RECEIVE_PROCESS //  Need review 
			);
		} else {
			//  There is no need to handle , Go directly to the confidential file 
			nextWf(wfInstanceId,userGroupId, 
					userName, startUser, WorkFlowNode.CONDITION.RECEIVE_NO_PROCESS // no   Need review 
			);
		}
	}

	/**
	 *  Save basic information 
	 * 
	 * @param documentForm
	 * @param userName
	 * @throws ParseException
	 */
	private void saveOaDocument(DocumentForm documentForm, String userName) throws ParseException {
		OaDocuments oaDoc = new OaDocuments();
		BeanUtils.copyProperties(documentForm, oaDoc);
		Timestamp receiveDate = Timestamp.valueOf(documentForm.getReceiveTime() + " 00:00:00");
		oaDoc.setReceiveDate(receiveDate);
		oaDoc.setDocDiv(Globals.FLG.DOCDIV_RECEIVE);
		oaDoc.setGuanlianLaiwenLeibie("0");// TODO  Related communications 
		// oaDoc.setTempSaveFlg(Globals.FLG.YES);// TODO  No temporary storage 
		oaDoc.setCreateId(userName);
		oaDoc.setCreateTime(DateUtils.currentTime());
		oaDoc.setUpdateId(userName);
		oaDoc.setUpdateTime(DateUtils.currentTime());
		oaDoc.setDelFlg(Globals.FLG.YES);// 0： Not deleted  1： Delete 
		oaDoc.setFinishFlg(Globals.FLG.YES);// 0: hang in the air  1： complete 
		oaDoc.setSerialNo("90909");// TODO  Is it necessary to 
		oaDocumentsRepository.saveAndFlush(oaDoc);
	}

	/**
	 *  Update basic information 
	 * 
	 * @param documentForm
	 * @param userName
	 * @throws ParseException
	 */
	private void updateOaDocument(DocumentForm documentForm, String userName) throws ParseException {
		//  Get the original basic information 
		OaDocuments oldOaDoc = oaDocumentsRepository.findTopByDocUuid(documentForm.getDocUuid());

		OaDocuments oaDoc = new OaDocuments();
		BeanUtils.copyProperties(documentForm, oaDoc);
		Timestamp receiveDate = Timestamp.valueOf(documentForm.getReceiveTime() + " 00:00:00");
		oaDoc.setReceiveDate(receiveDate);
		oaDoc.setDocDiv(oldOaDoc.getDocDiv());
		oaDoc.setGuanlianLaiwenLeibie(oldOaDoc.getGuanlianLaiwenLeibie());// TODO  Related communications 
		// oaDoc.setTempSaveFlg(Globals.FLG.YES);// TODO  No temporary storage 
		oaDoc.setCreateId(oldOaDoc.getCreateId());
		oaDoc.setCreateTime(oldOaDoc.getCreateTime());
		oaDoc.setUpdateId(userName);
		oaDoc.setUpdateTime(DateUtils.currentTime());
		oaDoc.setDelFlg(oldOaDoc.getDelFlg());// 0： Not deleted  1： Delete 
		oaDoc.setFinishFlg(oldOaDoc.getFinishFlg());// 0: hang in the air  1： complete 
		oaDoc.setSerialNo(oldOaDoc.getSerialNo());// TODO  Is it necessary to 
		oaDocumentsRepository.saveAndFlush(oaDoc);
	}

	/**
	 *  Save registration information 
	 * 
	 * @param processForm
	 */
	private void saveRegistProcess(DocsReceiveProcessForm processForm, String userName) {
		//  Save processing information 
		OaProcess oaProcess = new OaProcess();
		BeanUtils.copyProperties(processForm, oaProcess);
		// oaProcess.setTempSaveFlg(Globals.FLG.YES); TODO  Delete 
		oaProcess.setCreateId(userName);
		oaProcess.setCreateTime(DateUtils.currentTime());
		oaProcess.setUpdateId(userName);
		oaProcess.setUpdateTime(DateUtils.currentTime());
		oaProcess.setDelFlg(Globals.FLG.YES);

		oaProcessRepository.saveAndFlush(oaProcess);
	}

	/**
	 *  Save the leader selected for registration 
	 * 
	 * @param userList
	 * @param processUuid
	 * @param docUuid
	 * @param userName
	 */
	private void saveAuditUser(List<String> userList, String processUuid, String docUuid, String userName,
			String auditType, String auditUserOrganCode) {
		List<OaDocAuditUser> auditUserList = new ArrayList<OaDocAuditUser>();
		//  Delete the original data first 
		auditUserRepository.deleteAllAuditByDocUuidAndAuditType(docUuid, auditType);
		if (!CollectionUtils.isEmpty(userList)) {
			for (String user : userList) {
				OaDocAuditUser auditUser = new OaDocAuditUser();
				// auditUser.setAuditUuid(UUID.randomUUID().toString());
				auditUser.setDocUuid(docUuid);
				auditUser.setProcessId(processUuid);
				auditUser.setAuditUser(user);
				// auditUser.setSortNo("0");
				auditUser.setAuditType(auditType);
				auditUser.setAuditUserOrganCode(auditUserOrganCode);
				auditUser.setAuditFlg(Globals.FLG.YES);// 0: Not approved  1： Reviewed 
				// auditUser.setTempSaveFlg("0");
				auditUser.setCreateId(userName);
				auditUser.setCreateTime(DateUtils.currentTime());
				auditUser.setUpdateId(userName);
				auditUser.setUpdateTime(DateUtils.currentTime());
				auditUser.setDelFlg(Globals.FLG.YES);
				auditUserList.add(auditUser);
			}
			auditUserRepository.saveAll(auditUserList);
		}
	}

	/**
	 *  Save the selected processing Department 
	 * 
	 * @param organList
	 * @param processUuid
	 * @param docUuid
	 * @param userName
	 */
	private void saveProcessUser(Map<String, String> groupUserMap, String processUuid, String docUuid,
			String userName,String processType) {
		List<OaDocProcessUser> oaProcessUserList = new ArrayList<OaDocProcessUser>();
		//  Delete the original data first 
		processUserRepository.deleteAllByDocUuid(docUuid);
		if (!CollectionUtils.isEmpty(groupUserMap)) {
			for (Entry<String, String> vo : groupUserMap.entrySet()) {
				OaDocProcessUser oaProcessUser = new OaDocProcessUser();

				// oaProcessUser.setProcessUserUuid(UUID.randomUUID().toString());
				oaProcessUser.setDocUuid(docUuid);
				oaProcessUser.setProcessUuid(processUuid);
				oaProcessUser.setProcessType(processType);
				oaProcessUser.setProcessUser(vo.getValue());
				oaProcessUser.setUserOrganCode(vo.getKey());
				oaProcessUser.setCreateId(userName);
				oaProcessUser.setCreateTime(DateUtils.currentTime());
				oaProcessUser.setUpdateId(userName);
				oaProcessUser.setUpdateTime(DateUtils.currentTime());
				oaProcessUser.setDelFlg(Globals.FLG.YES);
				oaProcessUserList.add(oaProcessUser);

			}
			processUserRepository.saveAll(oaProcessUserList);
		}
	}

	/**
	 *  Start the process 
	 *
	 * @return  Process instance ID
	 */
	private Integer startWf(String wfKey, String busiEventNo, String busiEventId, String busiProcessId, String nodeCode,
			ProcessUser processUser, String startUserName) {
		StartWfParams startWfParams = new StartWfParams();
		startWfParams.setWfKey(wfKey);
		startWfParams.setBusinessEventNo(busiEventNo);
		startWfParams.setBusinessEventUuid(busiEventId);
		startWfParams.setBusinessProcessUuid(busiProcessId);
		startWfParams.setInputNodeCode(nodeCode);
		startWfParams.setCurrentUser(startUserName);
		startWfParams.addProcessUser(processUser);
		//  Get process instance id
		WorkflowInfo wf = workflowService.start(startWfParams);
		return wf.getInstanceId();
	}

	/**
	 * next technological process 
	 *
	 * @param wfInstanceId  Process instance id
	 * @param currentUser   Currently logged in user 
	 * @param processUser   The next handler 
	 */
	private void nextWf(Integer wfInstanceId, String inputNodeCode, String currentUser, ProcessUser processUser,
			String nodeCondition) {
		NextWfParams nextWfParams = new NextWfParams();
		nextWfParams.setInstanceId(wfInstanceId); //  Process instance id
		nextWfParams.setInputNodeCode(inputNodeCode);//  The organization selected by the current user code
		nextWfParams.setCurrentUser(currentUser); //  Current user 
		nextWfParams.addProcessUser(processUser); //  Who will operate next 
		nextWfParams.setNodeCondition(nodeCondition);//  Node condition 
		workflowService.next(nextWfParams);
	}

	/**
	 *  End process 
	 * 
	 * @param wfInstanceId
	 * @param currentUser
	 */
	private void endWf(Integer wfInstanceId, String currentUser) {
		EndWfParams endWfParams = new EndWfParams();
		endWfParams.setInstanceId(wfInstanceId);
		endWfParams.setCurrentUser(currentUser);
		workflowService.end(endWfParams);
	}

	/**
	 *  Submit information to the director for review 
	 * 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveReceiveLdsh01Process(DocsReceiveProcessForm processForm, String userName) {
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//  Save processing information 
		saveRegistProcess(processForm, userName);
		//  Drive the process 
		ProcessUser processUser = new ProcessUser();
		processUser.setOrganCode("1111");// TODO  Get confidential registrant organization 
		processUser.setLoginName("admin");// TODO  Get confidential registrant 
		//  Select agree to confidential distribution 
		if(DocMarks.AuditResult.AGREE.equals(processForm.getAuditingResult())) {			
			nextWf(wfInstanceId, "bbb", // TODO  Current organization 
					userName, processUser, WorkFlowNode.CONDITION.RECEIVE_AGREE //  Need review 
			);
		}else {
			// If you choose not to agree , Return to confidential registration 		
			nextWf(wfInstanceId, "bbb", // TODO  Current organization 
					userName, processUser, WorkFlowNode.CONDITION.RECEIVE_DISAGREE //  Need review 
			);
		}
	}

	/**
	 *  Submit confidential distribution information 
	 * 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveReceive02Process(DocsReceiveProcessForm processForm, String userName) {
		//  Main process instance Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//  Save processing information 
		saveRegistProcess(processForm, userName);
		
		//  Select agree to confidential distribution 
		// （1） Distribution Department 
		fenFaBuMen(processForm, userName);
		
		//(2) Distribution leader 
		fenFaLeader(processForm, userName);
		// Turn on the waiting node , The main process cannot enter anyone's inbox , Therefore, the handler cannot be a real user 
		// False user , The user table cannot be found 
		ProcessUser dummyUser = new ProcessUser();
		dummyUser.setOrganCode("##$$%%");
		dummyUser.setLoginName("010101");
		nextWf(wfInstanceId, "bbb", // TODO  Current organization 
				userName, dummyUser, null); //  Need review 
	}
	/**
	 *  Confidential Distribution Department 
	 * @param processForm
	 * @param userName
	 */
	private void fenFaBuMen(DocsReceiveProcessForm processForm,String userName) {
		//  Drive the process 
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode("bbb");// TODO  Get login Department 
		startUser.setLoginName(userName);
		List<OaDocProcessUser> processUserList = processUserRepository
				.findProcessUserListByDocUuid(processForm.getDocUuid());
		if(!CollectionUtils.isEmpty(processUserList)) {
		for(OaDocProcessUser proUser:processUserList) {
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(proUser.getUserOrganCode());//  organization  
			processUser.setLoginName(proUser.getProcessUser());//  Handle internal affairs 
			// Open a new sub process instance Id 
			Integer childWfInstanceId = startWf(Workflow.WfDefinition.WF_DOC_RECEIVE_PROCESS, "0000", // TODO  Serial number 
					processForm.getDocUuid(), processForm.getProcessUuid(), "bbb", // TODO  Login user organization 
					startUser, userName);
			nextWf(childWfInstanceId, "bbb", // TODO  Current organization 
					userName, processUser, null); //  Need review 
		}
		}
	}
	/**
	 *  Leader of confidential Distribution Office 
	 * @param processForm
	 * @param userName
	 */
	private void fenFaLeader(DocsReceiveProcessForm processForm,String userName) {
		//  Drive the process 
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode("bbb");// TODO  Get login Department 
		startUser.setLoginName(userName);
		List<String> auditUserList=auditUserRepository.findAuditUserByDocUuidAndAuditType(processForm.getDocUuid(),DocMarks.AuditType.BANLEADER); 
		if(!CollectionUtils.isEmpty(auditUserList)) {
			for(String auditUser:auditUserList) {
				ProcessUser processUser = new ProcessUser();
				processUser.setOrganCode("111");//TODO  Get leadership organization  
				processUser.setLoginName(auditUser);//  Management leader 
				
				// Open a new sub process leader instruction instance Id 
				Integer leaderWfInstanceId = startWf(Workflow.WfDefinition.WF_DOC_RECEIVE_LEADER, "0000", // TODO  Serial number 
						processForm.getDocUuid(), processForm.getProcessUuid(), "bbb", // TODO  Login user organization 
						startUser, userName);
				nextWf(leaderWfInstanceId, "bbb", // TODO  Current organization 
						userName, processUser, null); //  Need review 
				
			}
		}
	}

	/**
	 *  Submit confidential files 
	 * 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveReceive03Process(DocsReceiveProcessForm processForm, String userName) {
		//  Main process instance Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//  End official document 
		finishOaDocument(processForm.getDocUuid(), userName);
		//  Save processing information 
		saveRegistProcess(processForm, userName);
		//  Drive the process 
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode("bbb");// TODO  Get login Department 
		startUser.setLoginName(userName);
		//  End process 
		nextWf(wfInstanceId, "bbb", // TODO  Get login Department 
				userName, startUser, null);
		endWf(wfInstanceId, userName);
	}

	/**
	 *  End official document 
	 * 
	 * @param documentForm
	 * @param userName
	 * @throws ParseException
	 */
	private void finishOaDocument(String docUuid, String userName) {
		//  Get the original basic information 
		OaDocuments oaDoc = oaDocumentsRepository.findTopByDocUuid(docUuid);

		oaDoc.setUpdateId(userName);
		oaDoc.setUpdateTime(DateUtils.currentTime());
		oaDoc.setFinishFlg(Globals.FLG.NO);// 0: hang in the air  1： complete 
		oaDoc.setFinishDate(DateUtils.currentTime());
		oaDocumentsRepository.saveAndFlush(oaDoc);
	}
	/**
	 *  Save the sub process and handle it in the office 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcess01Info(DocsReceiveProcessForm processForm, String userName) {
		//  Save processing information 
		saveRegistProcess(processForm, userName);
		
		// Assign undertaker 
		if(processForm.getProcessType().equals(DocMarks.ProcessType.FENPEI_CEHNGBANREN)) {
			fenPeiChengBanRen(processForm, userName);
		}
		// Select the audit leader 
		if(processForm.getProcessType().equals(DocMarks.ProcessType.LEADER)) {
			songShenLeader(processForm, userName);
		}
	}
	/**
	 *  Distribution undertaker 
	 * @param chengBanRenList
	 */
	private void toFenFaChengBanRen(DocsReceiveProcessForm processForm,String organId,String userName) {
		//  Drive the process 
		// Initiator 
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode(organId);
		startUser.setLoginName(userName);
		
		List<String> chengBanRenList=processForm.getToGetChenBanRenList();
		for(String chengBanRen:chengBanRenList) {
			// Handler 
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(organId); 
			processUser.setLoginName(chengBanRen);//  Management leader 
			
			// Open a new sub process leader instruction instance Id 
			Integer chengBanRenWfInstanceId = startWf(Workflow.WfDefinition.WF_DOC_RECEIVE_PROCESSER, "0000", // TODO  Serial number 
					processForm.getDocUuid(), processForm.getProcessUuid(), organId, 
					startUser, userName);
			nextWf(chengBanRenWfInstanceId, organId, 
					userName, processUser, null); //  Need review 
		}
				
	}
	/**
	 *  The sub process undertaker who saves the sub process shall handle it 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcess02Info(DocsReceiveProcessForm processForm, String userName) {
		//  Sub process instance of sub process Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO  Get the selected organization of the current login person ID 
		final String groupId="bbb";//processForm.getGroupId();
		//  Save processing information 
		saveRegistProcess(processForm, userName);
		
		//  Drive the process 
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode(groupId);
		startUser.setLoginName(userName);
		//  End process 
		nextWf(wfInstanceId, groupId,
				userName, startUser, null);
		endWf(wfInstanceId, userName);
		//TODO  Obtain the unfinished instances handled by other contractors 
		List<BaseOaWfInstance> instanceList=new ArrayList<BaseOaWfInstance>();
		// If all instances are completed , The sub process needs to continue to enter the office confirmation node 
		if(!CollectionUtils.isEmpty(instanceList)) {
			//TODO  Get the current instance id Parent instance of Id, This is the instance of the corresponding secondary sub process Id
			Integer secondWfInstanceId=1;
			//TODO  Get office information from history 
			String neiQin="admin";
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(groupId);
			processUser.setLoginName(neiQin);
			nextWf(secondWfInstanceId, groupId, 
					userName, processUser, null);
		}
	}
	/**
	 *  Save the internal confirmation of the sub process 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcess03Info(DocsReceiveProcessForm processForm, String userName) {		
		//  Save processing information 
		saveRegistProcess(processForm, userName);
		
		// Assign undertaker 
		if(processForm.getProcessType().equals(DocMarks.ProcessType.FENPEI_CEHNGBANREN)) {
			fenPeiChengBanRen(processForm, userName);
		}
		// Select the audit leader 
		if(processForm.getProcessType().equals(DocMarks.ProcessType.LEADER)) {
			songShenLeader(processForm, userName);
		}
		// Finish 
		if(processForm.getProcessType().equals(DocMarks.ProcessType.BANJIE)) {
			banJieShenHe(processForm, userName);
		}
	}
	/**
	 *  The office selects and assigns the undertaker 
	 * @param processForm
	 * @param userName
	 */
	private void fenPeiChengBanRen(DocsReceiveProcessForm processForm, String userName) {
		//  Sub process instance of sub process Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO  Get the selected organization of the current login person ID 
		final String groupId="bbb";//processForm.getGroupId();
		/***
		 *  Reasons for using fake users ：1、 Handler cannot be blank ,2、 Can't get into the inbox of real people ,3、 Need to move on to the next step 
		 */
		// False user 
		ProcessUser dummyUser = new ProcessUser();
		dummyUser.setOrganCode("##$$%%");
		dummyUser.setLoginName("010101");
		//  Drive the process to the undertaker 
		nextWf(wfInstanceId, groupId, 
				userName, dummyUser, WorkFlowNode.CONDITION.CHENGBANREN_PROCESSER);
		
		if(!CollectionUtils.isEmpty(processForm.getToGetChenBanRenList())) {
			toFenFaChengBanRen(processForm,groupId,userName);
		}
	}
	/**
	 *  The internal affairs department selects the audit leader for handling 
	 * @param processForm
	 * @param userName
	 */
	private void songShenLeader(DocsReceiveProcessForm processForm, String userName) {
		//  Sub process instance of sub process Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO  Get the selected organization of the current login person ID 
		final String groupId="bbb";//processForm.getGroupId();
		String leader=processForm.getLeaderName();
		ProcessUser processUser = new ProcessUser();
		processUser.setOrganCode(groupId);
		processUser.setLoginName(leader);
		//  Drive the process to be handled by the audit leader 
		nextWf(wfInstanceId, groupId, 
				userName, processUser, WorkFlowNode.CONDITION.LEADER_PROCESS);
	}
	/**
	 *  The office confirms that you choose to finish 
	 * @param processForm
	 * @param userName
	 */
	private void banJieShenHe(DocsReceiveProcessForm processForm, String userName) {
		//  Sub process instance of sub process Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO  Get the selected organization of the current login person ID 
		final String groupId="bbb";//processForm.getGroupId();
		//  Drive the process 
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode(groupId);
		startUser.setLoginName(userName);
		//  End sub process 
		nextWf(wfInstanceId, groupId, 
				userName, startUser, null);
		endWf(wfInstanceId, userName);
		
		//TODO  Get the unsettled instance of sub process department Id aggregate 
		List<BaseOaWfInstance> instanceList=new ArrayList<BaseOaWfInstance>();
		// If all instances are empty , The main process needs to enter the archive node 
		if(CollectionUtils.isEmpty(instanceList)) {
			//TODO  Get the current instance id Parent instance of Id, That is, the instance of the corresponding main process Id
			Integer mainWfInstanceId=1;
			//TODO  Get confidential information from history 
			String jiYao="admin";
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(groupId);// TODO  Get login Department 
			processUser.setLoginName(jiYao);
			nextWf(mainWfInstanceId, groupId, // TODO  Get login Department 
					userName, processUser, null);
		}
	}
	/**
	 *  Save leader approval of sub process 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcessLdsh01Info(DocsReceiveProcessForm processForm, String userName) {
		//  Examples of subprocesses Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO  Get the selected organization of the current login person ID 
		final String groupId="bbb";//processForm.getGroupId();
		//  Save processing information 
		saveRegistProcess(processForm, userName);
		//TODO  Get the office in the history 
		String neiQin="admin";
		
		ProcessUser processUser = new ProcessUser();
		processUser.setOrganCode(groupId);
		processUser.setLoginName(neiQin);
		
		//  Drive the process into internal confirmation 
		nextWf(wfInstanceId, groupId, 
				userName, processUser,null);
	}
	/**
	 *  Instructions from the leader of the preservation Office 
	 * @param processForm
	 * @param userName
	 */
	@Transactional
	public void saveProcessComment01Info(DocsReceiveProcessForm processForm, String userName) {
		//  Examples of subprocesses Id
		final Integer wfInstanceId = processForm.getWfInstanceId();
		//TODO  Get the selected organization of the current login person ID 
		final String groupId="bbb";//processForm.getGroupId();
		//  Save processing information 
		saveRegistProcess(processForm, userName);
		
		//  Drive the process 
		ProcessUser startUser = new ProcessUser();
		startUser.setOrganCode(groupId);
		startUser.setLoginName(userName);
		//  End sub process 
		nextWf(wfInstanceId, groupId, 
				userName, startUser, null);
		endWf(wfInstanceId, userName);
		
		// Promote the mainstream process 
		//TODO  Get the unsettled instance of sub process department Id aggregate 
		List<BaseOaWfInstance> instanceList=new ArrayList<BaseOaWfInstance>();
		// If all instances are empty , The main process needs to enter the archive node 
		if(CollectionUtils.isEmpty(instanceList)) {
			//TODO  Get the current instance id Parent instance of Id, That is, the instance of the corresponding main process Id
			Integer mainWfInstanceId=1;
			//TODO  Get confidential information from history 
			String jiYao="admin";
			ProcessUser processUser = new ProcessUser();
			processUser.setOrganCode(groupId);
			processUser.setLoginName(jiYao);
			nextWf(mainWfInstanceId, groupId, // TODO  Get login Department 
					userName, processUser, null);
		}
				
	}
	/**
	 *  initialization 
   *  According to id Query process path 
   * @param id  Flow chart id
   * @return  Process path entry
   */
  public WfHistoryEntry findWfRela(String id) {
    BaseOaWfHistoryRela rela = baseOaWfHistoryRelaRepository.findByBusinessWfUuid(id); 
    BaseOaWfProcessUser processUser = baseOaWfProcessUserRepository.findBybusinessWfUuid(id);
    WfHistoryEntry entry = new WfHistoryEntry();
    entry.setPreProcessUser(rela.getInputUser());   
    entry.setPreGroupId(rela.getInputNodeCode());  
    entry.setCurrentProcessUser(processUser.getProcessOrganCode());    
    entry.setCurrentProcessGroupId(processUser.getProcessOrganCode());  
    entry.setInstanceId(rela.getInstanceId());
    entry.setNodeKey(rela.getNodeKey());
    entry.setBusinessId(rela.getBusinessEventUuid());
    entry.setProcessId(rela.getBusinessProcessUuid());
    return entry;
  } 
}