ProcdefinitionBusinessImpl.java

package com.gaowj.business.procdefinition;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

import org.activiti.engine.RepositoryService;
import org.activiti.engine.delegate.Expression;
import org.activiti.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.pvm.delegate.ActivityBehavior;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.task.TaskDefinition;
import org.activiti.engine.repository.ProcessDefinition;
import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.session.RowBounds;

import com.gaowj.business.ProcdefinitionBusiness;
import com.gaowj.business.exception.BusinessException;
import com.gaowj.business.formfield.formfieldDAO;
import com.gaowj.business.procdefinitionInitlink.procdefinitionInitlinkDAO;
import com.gaowj.business.formmodels.formmodelsDAO;
import com.gaowj.business.util.Page;
import com.gaowj.business.util.SessionUtil;

public class ProcdefinitionBusinessImpl implements ProcdefinitionBusiness {

	private procdefinitionDAO procdefinitionDAO;
	
	private formmodelsDAO formmodelsDAO;
	
	private formfieldDAO formfieldDAO;

	private RepositoryService repositoryService;
	
	private procdefinitionInitlinkDAO procdefinitionInitlinkDAO;
	
	public formmodelsDAO getFormmodelsDAO() {
		return formmodelsDAO;
	}

	public void setFormmodelsDAO(com.gaowj.business.formmodels.formmodelsDAO formmodelsDAO) {
		this.formmodelsDAO = formmodelsDAO;
	}

	public procdefinitionDAO getProcdefinitionDAO() {
		return procdefinitionDAO;
	}

	public void setProcdefinitionDAO(procdefinitionDAO procdefinitionDAO) {
		this.procdefinitionDAO = procdefinitionDAO;
	}


	public formfieldDAO getFormfieldDAO() {
		return formfieldDAO;
	}

	public void setFormfieldDAO(formfieldDAO formfieldDAO) {
		this.formfieldDAO = formfieldDAO;
	}

	public RepositoryService getRepositoryService() {
		return repositoryService;
	}

	public void setRepositoryService(RepositoryService repositoryService) {
		this.repositoryService = repositoryService;
	}

	public procdefinitionInitlinkDAO getProcdefinitionInitlinkDAO() {
		return procdefinitionInitlinkDAO;
	}

	public void setProcdefinitionInitlinkDAO(
			procdefinitionInitlinkDAO procdefinitionInitlinkDAO) {
		this.procdefinitionInitlinkDAO = procdefinitionInitlinkDAO;
	}

	@Override
	public Map<String, Object> insert_procde_finition(Map<String, Object> entity) throws BusinessException {
		if (entity.get("UUID") == null) {
			entity.put("UUID", java.util.UUID.randomUUID().toString());
		}
		if (entity.get("CREATE_TIME") == null) {
			entity.put("CREATE_TIME", new Date());
		}
		if (entity.get("CREATE_ID") == null) {
			entity.put("CREATE_ID", SessionUtil.getCode());
		}
		if (entity.get("UPDATE_ID") == null) {
			entity.put("UPDATE_ID", SessionUtil.getCode());
		}
		if (entity.get("UPDATE_TIME") == null) {
			entity.put("UPDATE_TIME", new Date());
		}
		entity.put("DEPLOYMENT_KEY", UUID.randomUUID().toString());

		// 动态传值插入
		List<String> infoListKey = new ArrayList<String>();
		List<Object> infoList = new ArrayList<Object>();
		if (entity.keySet() != null) {
			Set<String> key = entity.keySet();
			// 将map集合中的key和value 取出来分别放到list集合里
			for (String str : key) {
				infoList.add(entity.get(str));
				infoListKey.add(str);
			}
			entity.put("infoListKey", infoListKey);
			entity.put("infoList", infoList);
		}
		procdefinitionDAO.insert_procde_finition(entity);
		return entity;
	}

	@Override
	public void update_procde_finition(Map<String, Object> entity) throws BusinessException {
		// 动态传值修改
		if (entity.keySet() != null) {
			convertEntity(entity);
			//禁止修改key值
			entity.remove("DEPLOYMENT_KEY");
			procdefinitionDAO.update_procde_finition(entity);
			entity.remove("info");
		}
	}

	@Override
	public void delete_procde_finition(List<String> list) throws BusinessException {
		procdefinitionDAO.delete_procde_finition(list);
	}

	@Override
	public Page<Map<String, Object>> list_procde_finition(int pageNo, int pageSize, Map<String, Object> query) throws BusinessException {
		machining(query);
		// 计算起始记录
		int pageStart = (pageNo - 1) * pageSize;

		// 获取列表
		List<Map<String, Object>> items = procdefinitionDAO.list_procde_finition(new RowBounds(pageStart, pageSize), query);
		// 获取列表个数
		int count = listCount_procde_finition(query);

		// 创建分页对象
		Page<Map<String, Object>> page = new Page<Map<String, Object>>();
		page.setStart(pageStart);
		page.setLimit(pageSize);
		page.setCount(count);
		page.setItems(items);

		return page;
	}

	@Override
	public List<Map<String, Object>> list_procde_finition(Map<String, Object> query) throws BusinessException {
		machining(query);
		return procdefinitionDAO.list_procde_finition(query);
	}

	@Override
	public int listCount_procde_finition(Map<String, Object> query) throws BusinessException {
		machining(query);
		return procdefinitionDAO.listCount_procde_finition(query);
	}

	@Override
	public InputStream viewPic(String deploymentId,StringBuffer filename) throws BusinessException{
		// 获取图片资源名称
		List<String> list = repositoryService.getDeploymentResourceNames(deploymentId);
		// 定义图片资源的名称（一个流程定义，默认都有两个资源文件，一个是png，一个是xml，这里只获取png）
		String resourceName = "";
		if (list != null && list.size() > 0) {
			for (String name : list) {
				if (name.indexOf(".png") >= 0) {
					resourceName = name;
				}
			}
		}
		// 获取图片的输入流
		InputStream in = repositoryService.getResourceAsStream(deploymentId, resourceName);
		filename.append(resourceName);
		return in;
	}

	@Override
	public Map<String,Object> findFormModel(String procdefinitionUuid) throws BusinessException {
		if(procdefinitionUuid==null||"".equals(procdefinitionUuid)){
			return null;
		}
		Map<String, Object> query=new HashMap<String, Object>();
		query.put("UUID", procdefinitionUuid);
		String tableId=procdefinitionDAO.list_procde_finition(query).get(0).get("TABLE_ID").toString();
		Map<String, Object> query2=new HashMap<String, Object>();
		query2.put("FLAG", 1);
		query2.put("TABLE_ID", tableId);
		List<Map<String, Object>>  listFormmodels=formmodelsDAO.list_form_models(query2);
		if(listFormmodels.size()==0){
			return null;
		}
		
		return listFormmodels.get(0);
	}

	/**
	 * 更新或者插入时，处理map对象的形式（将字段信息存储为list，便于mybatis代码调用）
	 * 
	 * @param entity
	 */
	private void convertEntity(Map<String, Object> entity, String... ignoreKeys) {
		List<Map<String, Object>> updateList = new ArrayList<Map<String, Object>>();
		Set<String> key = entity.keySet();
		// 将map集合中的key和value 取出来分别放到list集合里
		for (String str : key) {
			Map<String, Object> updateMap = new HashMap<String, Object>();

			for (String k : ignoreKeys) {
				if (StringUtils.equalsIgnoreCase("UUID", str))
					continue;
			}
			updateMap.put("key", str);
			updateMap.put("value", entity.get(str));

			updateList.add(updateMap);
		}
		entity.put("info", updateList);
	}

	private void machining(Map<String, Object> query) {
		if (query.get("PROC_NAME") != null && !"".equals(query.get("PROC_NAME"))) {
			query.put("PROC_NAME", "%" + query.get("PROC_NAME") + "%");
		}
	}

	@Override
	public int init_procde_finition_people_approval(String DEPLOYMENT_ID)
			throws BusinessException {
		// TODO Auto-generated method stub
		 ProcessDefinition  processDefinition =repositoryService.createProcessDefinitionQuery().deploymentId(DEPLOYMENT_ID).singleResult();
		if(processDefinition == null) {
			return -1;
		}
		Map<String, Object> entity=new HashMap<String, Object>();
		entity.put("DEPLOYMENT_ID", DEPLOYMENT_ID);
		List<Map<String, Object>> list=procdefinitionInitlinkDAO.list_procde_finition_init_link(entity);
		String proDefKey = processDefinition.getKey();
		ProcessDefinitionEntity processDef = (ProcessDefinitionEntity) repositoryService.getProcessDefinition(processDefinition.getId());
		List<ActivityImpl> activitiList = processDef.getActivities();
		for (ActivityImpl activity : activitiList) {
			ActivityBehavior activityBehavior = activity.getActivityBehavior();
			boolean isFound = false;
			//是否为用户任务
			if (activityBehavior instanceof UserTaskActivityBehavior) {
				UserTaskActivityBehavior userTaskActivityBehavior = (UserTaskActivityBehavior) activityBehavior;
	            TaskDefinition taskDefinition = userTaskActivityBehavior.getTaskDefinition();
	            //任务所属角色
	            String taskDefKey = taskDefinition.getKey();
	            Expression taskName = taskDefinition.getNameExpression();
	       
	            //判断表中是否存在此节点
	            if(list.size() != 0){
					for(Map<String, Object> map : list){
						Map<String, Object> param=new HashMap<String, Object>();
						if(taskDefKey.equals(map.get("LINK_KEY"))){
							param.put("UUID", map.get("UUID"));
							param.put("DEPLOYMENT_ID", DEPLOYMENT_ID);
							param.put("LINK_KEY", taskDefKey);
							param.put("LINK_NAME", taskName.toString());
							param.put("PROC_DEFIN_KEY", processDefinition.getKey());
							param.put("PROC_DEFIN_ID", processDefinition.getId());
							param.put("PROC_DEFIN_NAME", processDefinition.getName());
							param.put("PROC_DEFIN_VERSION", processDefinition.getVersion());
				            isFound = true;
				            break;
						}
					}
					
				}
	           if(!isFound){
	        	   if (entity.get("UUID") == null) {
	        			entity.put("UUID", java.util.UUID.randomUUID().toString());
	        		}
	        		if (entity.get("CREATE_TIME") == null) {
	        			entity.put("CREATE_TIME", new Date());
	        		}
	        		entity.put("DEPLOYMENT_ID", DEPLOYMENT_ID);
	        		entity.put("LINK_KEY", taskDefKey);
	        		if(taskName!=null){
	        			entity.put("LINK_NAME", taskName.toString());
	        		}
	        		entity.put("PROC_DEFIN_KEY", processDefinition.getKey());
	        		entity.put("PROC_DEFIN_ID", processDefinition.getId());
	        		entity.put("PROC_DEFIN_NAME", processDefinition.getName());
	        		entity.put("PROC_DEFIN_VERSION", processDefinition.getVersion());
	        		// 动态传值插入
	        		List<String> infoListKey = new ArrayList<String>();
	        		List<Object> infoList = new ArrayList<Object>();
	        		if (entity.keySet() != null) {
	        			Set<String> key = entity.keySet();
	        			// 将map集合中的key和value 取出来分别放到list集合里
	        			for (String str : key) {
	        				infoList.add(entity.get(str));
	        				infoListKey.add(str);
	        			}
	        			entity.put("infoListKey", infoListKey);
	        			entity.put("infoList", infoList);
	        		}
	        		procdefinitionInitlinkDAO.insert_procde_finition_init_link(entity);
	        		entity.clear();
	            }
			}
		}
	return 1;
	}

	@Override
	public List<Map<String, Object>> listShowField(String procDefinitionId) throws BusinessException {
		Map<String,Object> query=new HashMap<String, Object>();
		query.put("UUID", procDefinitionId);
		String tableId=procdefinitionDAO.list_procde_finition(query).get(0).get("TABLE_ID").toString();
		
		Map<String,Object> query2=new HashMap<String, Object>();
		query2.put("TABLE_ID", tableId);
		query2.put("IS_SHOW_LIST", 1);
		return formfieldDAO.list_form_field(query2);
	}
}