snd-escloud/src/main/java/platform/modules/company/service/StockLandService.java

package platform.modules.company.service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.ModelMap;
import org.springframework.web.multipart.MultipartFile;
import platform.common.Constant;
import platform.common.base.model.DictionaryItem;
import platform.common.base.service.BaseService;
import platform.common.base.service.DictionaryItemService;
import platform.common.exception.BaseException;
import platform.common.util.*;
import platform.modules.build.entity.Company;
import platform.modules.build.service.CompanyService;
import platform.modules.company.dao.StockLandDao;
import platform.modules.company.dto.ProcessNodeDto;
import platform.modules.company.dto.StockLandApprovalDto;
import platform.modules.company.entity.ProjectApplicationCompanyInfo;
import platform.modules.company.entity.StockLand;
import platform.modules.company.entity.StockLandMaterial;
import platform.modules.government.dao.AttachmentDao;
import platform.modules.government.dto.GovStatisticsDto;
import platform.modules.government.dto.SearchCondition;
import platform.modules.government.entity.Attachment;
import platform.modules.government.entity.FileDown;
import platform.modules.government.entity.User;
import platform.modules.government.service.AttachmentService;
import platform.modules.government.service.StreetService;
import platform.modules.government.service.UserService;
import platform.modules.sys.entity.Approval;
import platform.modules.sys.entity.Department;
import platform.modules.sys.entity.Group;
import platform.modules.sys.entity.Message;
import platform.modules.sys.entity.UserGroup;
import platform.modules.sys.service.*;
import platform.modules.sys.web.ResponseMessage;
import tk.mybatis.mapper.entity.Example;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.util.*;

/**
 * 存量用地Service
 * @author hp
 *
 */
@Service
@Transactional
public class StockLandService extends BaseService<StockLand> {

	private static final Logger logger = LoggerFactory.getLogger(StockLandService.class);

	@Autowired
	private StockLandDao stockLandDao;

	@Autowired
	private DepartmentService departmentService;

	@Autowired
	private DictionaryItemService dictionaryItemService;

	@Autowired
	private CompanyService companyService;

	@Autowired
	private StockLandMaterialService stockLandMaterialService;

	@Autowired
	private AttachmentService attachmentService;

	@Autowired
	private UserService userService;

	@Autowired
	private ApprovalService approvalService;

	@Autowired
	GroupService groupService;
	@Autowired
	UserGroupService userGroupService;
	@Autowired
	AttachmentDao attachmentDao;
	@Autowired
	MessageService messageService;
	
	@Autowired
	private StreetService streetService;
	
	@Autowired
	private ProjectApplicationCompanyInfoService projectApplicationCompanyInfoService;
	
	@Autowired
	private WaitToDoService waitToDoService;

	@Transactional(readOnly = true)
	public PageInfo<StockLand> findPage(Integer pageNum, Integer pageSize, String param,StockLand searchCondition) throws Exception {
		Example example = new Example(StockLand.class);
		Example.Criteria criteria = example.createCriteria();
		criteria.andEqualTo("del_flag", 0);
		if (StringUtils.isNotBlank(param)) {
			criteria.andLike("apply_no", "%" + WebUtil.covertData(param) + "%");
		}
		if(StringUtils.isNotBlank(searchCondition.getApply_type())) {
			criteria.andEqualTo("apply_type", searchCondition.getApply_type());
		}
		if(StringUtils.isNotBlank(searchCondition.getApply_status())) {
			criteria.andEqualTo("apply_status", searchCondition.getApply_status());
		}
		if(ShiroUtils.getUserType().equals(Constant.UserType.COMPANY)){
			Integer companyId = ShiroUtils.getCompanyId();
			if(null != companyId) {
				criteria.andEqualTo("company_id", companyId);
			}
		}
		if(ShiroUtils.getUserType().equals(Constant.UserType.STREET)){
			Integer streetId = ShiroUtils.getStreetId();
			if(null != streetId) {
				criteria.andEqualTo("street_id", streetId);
			}
		}
		if(isLandLord()) {
			criteria.andEqualTo("create_by", ShiroUtils.getUserId());
		}
		//倒序
		example.setOrderByClause("create_time desc");
		PageHelper.startPage(pageNum, pageSize);
		List<StockLand> landApplys = this.selectByExample(example);
		for(StockLand stockLand:landApplys) {
			getFullLandInfo(stockLand);
		}
		return new PageInfo<StockLand>(landApplys);
	}

	private boolean isLandLord() {
		if(userService.hasRole(Constant.RoleName.LANDLORD)) {
			return true;
		}
		return false;
	}

	//获取存量用地申请codename，公司名称，状态名称等数据
	public StockLand getFullLandInfo(StockLand stockLand) {
		if(StringUtils.isNotBlank(stockLand.getApply_status())) {
			stockLand.setApply_status_str(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.STOCKLAND_APPLY_STATUS, stockLand.getApply_status()));
			//可否编辑，可否删除
			if(stockLand.getApply_status().equals(Constant.LandApplyStatus.REJECT)) {
				if(null != stockLand.getCreate_by() && stockLand.getCreate_by().equals(ShiroUtils.getUserId())) {
					stockLand.setCanEdit(true);
					stockLand.setCanDelete(true);
				}
			}else if(stockLand.getApply_status().equals(Constant.LandApplyStatus.PENDING_SUBMIT)) {
				if(null != stockLand.getCreate_by() && stockLand.getCreate_by().equals(ShiroUtils.getUserId())) {
					stockLand.setCanEdit(true);
					stockLand.setCanDelete(true);
				}
			}
		}
		if(StringUtils.isNotBlank(stockLand.getApply_type())) {
			stockLand.setApply_type_str(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.STOCKLAND, stockLand.getApply_type()));
		}
		if(StringUtils.isNotBlank(stockLand.getApprove_status())) {
			//街道可以看见临时状态
			if(ShiroUtils.getUserType().equals(Constant.UserType.STREET) && 
					StringUtils.isNotBlank(stockLand.getTemporary_state())) {
				stockLand.setApprove_status_str(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.STOCKLAND_APPROVE_STATUS, stockLand.getTemporary_state()));
			}else {
				stockLand.setApprove_status_str(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.STOCKLAND_APPROVE_STATUS, stockLand.getApprove_status()));
				
			}
		}
		if(null != stockLand.getCompany_id()) {
			Company company = companyService.findById(stockLand.getCompany_id());
			if(null != company) {
				stockLand.setCompany_name(company.getCompany_name());
			}
		}
		if(null != stockLand.getBuilding_street_id()) {
			try {
				String streetName = streetService.getStreetName(stockLand.getBuilding_street_id());
				if(StringUtils.isNotBlank(streetName)) {
					stockLand.setBuilding_street_name(streetName);
				}
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if(StringUtils.isNotBlank(stockLand.getSummary_procedure())) {
			String[] summary_procedure_types = stockLand.getSummary_procedure().split(",");
			String summary_procedure_str = "";
			for(String type : summary_procedure_types) {
				summary_procedure_str += dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.STOCKLAND_SUMMARY_PROCEDURE_TYPE, type) + ",";
			}
			summary_procedure_str = summary_procedure_str.substring(0, summary_procedure_str.length()-1);
			stockLand.setSummary_procedure_str(summary_procedure_str);
		}
		
		String apply_time = this.getApplyDate(stockLand.getId());
    	if(null != apply_time) {
        	//申请时间
        	stockLand.setApply_time(apply_time);
    	}
    	
		return stockLand;

	}

	//获取申请日期
	private String getApplyDate(Integer id) {
		return stockLandDao.getApplyDate(id);
	}

	//获取下拉框的值列表
	public ModelMap getDictInfo(ModelMap modelMap) {
		List<DictionaryItem> applyTypes = dictionaryItemService.findListByTypeName(Constant.DictionaryType.STOCKLAND);
		List<DictionaryItem> applyStatus = dictionaryItemService.findListByTypeName(Constant.DictionaryType.STOCKLAND_APPLY_STATUS);
		List<DictionaryItem> approveStatus = dictionaryItemService.findListByTypeName(Constant.DictionaryType.STOCKLAND_APPROVE_STATUS);
		List<DictionaryItem> processStatus = dictionaryItemService.findListByTypeName(Constant.DictionaryType.PROCESS_STATUS);
		List<DictionaryItem> summaryProcedureType = dictionaryItemService.findListByTypeName(Constant.DictionaryType.STOCKLAND_SUMMARY_PROCEDURE_TYPE);
		
		modelMap.put("applyTypeList", applyTypes);
		modelMap.put("applyStatusList", applyStatus);
		modelMap.put("approveStatusList", approveStatus);
		modelMap.put("processStatusList", processStatus);
		modelMap.put("summaryProcedureTypeList", summaryProcedureType);
		
		return modelMap;
	}

	//新增用地申请保存
	@Transactional
	public Boolean saveLandApply(StockLand apply) {
		//根据工作组名称查出工作组
		Integer streetId = ShiroUtils.getStreetId();
		if(null != apply.getBuilding_street_id()) {
			streetId = apply.getBuilding_street_id();
		}
		Group group = groupService.findByNameAndUserType(Constant.HGXSHXZ, null,Constant.UserType.STREET,streetId);
		String nextChecker = "";
		List<UserGroup> list = new ArrayList<UserGroup>();
		//如果不为空
		if(null != group){
			//根据工作组id查出UserGroup
			list = userGroupService.findByGroupId(group.getId());
			if(null == list || list.size()==0) {
				throw new BaseException("所属街道工业用地合规性审核组没有配置人员，请联系街道管理员配置!");
			}
			//构建一个StringBuffer 存放下一审核人id
			StringBuffer sb = new StringBuffer("");
			for (UserGroup userGroup: list) {
				Integer userId = userGroup.getUser_id();
				User user = userService.findById(userId);
				if(null == user.getApprove_level()){
					throw new BaseException("所属街道工业用地合规性审核组没有配置相应层级的人员，请联系街道管理员配置!");
				}
				sb.append(userId+",");
			}
			nextChecker = sb.toString();
		}else {
			throw new BaseException("所属街道还没有工业用地合规性审核组进行用地审核，请联系街道管理员配置!");
		}
		
		apply.setStreet_id(ShiroUtils.getStreetId());
		if(null == apply.getBuilding_street_id()) {
			apply.setBuilding_street_id(ShiroUtils.getStreetId());
		}
		String no = GenerateNoUtil.generateStocklandApplyNo();
		apply.setApply_no(no);

		//直接提交才有流程变化
		if(apply.getIsDraft().equals(Constant.IsDraft.DRAFT)){
			apply.setApply_status(Constant.LandApplyStatus.PENDING_SUBMIT);
		}else if(apply.getIsDraft()==Constant.IsDraft.NOT_DRAFT) {
			//审核流程变化
			apply.setApply_status(Constant.LandApplyStatus.IN_AUDIT);
			apply.setApprove_status(Constant.LandApproveStatus.LOCAL_AUDIT);
		}
		
		if (this.insertAndGetId(apply) > 0) {
			//保存企业基本信息
			if(null != apply.getCompanyInfo()) {
				ProjectApplicationCompanyInfo companyInfo = apply.getCompanyInfo();
				companyInfo.setApply_id(apply.getId());
				companyInfo.setCompany_id(apply.getCompany_id());
				companyInfo.setApply_type(Constant.DictionaryType.STOCKLAND);
				projectApplicationCompanyInfoService.saveSelective(companyInfo);
			}
			//保存材料
			if(null != apply.getApplyMaterials() && apply.getApplyMaterials().size()>0) {
				for(StockLandMaterial material : apply.getApplyMaterials()) {
					material.setApply_id(apply.getId());
					stockLandMaterialService.saveMaterial(material);
				}
			}
			if(null != apply.getOtherMaterials() && apply.getOtherMaterials().size()>0) {
				for(StockLandMaterial material : apply.getOtherMaterials()) {
					if(null != material.getFileDown() && null != material.getFileDown().getFile_id()) {
						//空行不保存
						material.setMaterial_type(Constant.LandApplyMaterialType.OTHER_MATERIAL);
						material.setApply_id(apply.getId());
						stockLandMaterialService.saveMaterial(material);
					}
				}
			}
			if(StringUtils.isNotBlank(apply.getSummary_procedure())) {
				//简易程序材料
				if(null != apply.getSummaryMaterials() && apply.getSummaryMaterials().size()>0) {
					for(StockLandMaterial material : apply.getSummaryMaterials()) {
						if(null != material.getFileDown() && null != material.getFileDown().getFile_id()) {
							material.setMaterial_type(Constant.LandApplyMaterialType.SUMMARY_MATERIAL);
							material.setApply_id(apply.getId());
							stockLandMaterialService.saveMaterial(material);
						}
					}
				}
			}
			//直接提交才有流程变化
			if(apply.getIsDraft().equals(Constant.IsDraft.NOT_DRAFT)) {
				//审核流
				Approval approval = new Approval();
				approval.setApply_id(apply.getId());
				approval.setBefore_approvalstatus(Constant.LandApplyStatus.PENDING_SUBMIT);
				approval.setApproval_round(1);
				approval.setAfter_approvalstatus(Constant.LandApproveStatus.LOCAL_AUDIT);
				approval.setChecker( ShiroUtils.getUserId());
				approval.setType(Constant.DictionaryType.STOCKLAND);
				approval.setOper_type(Constant.OperType.SUBMIT);
				approval.setDepartment(ShiroUtils.getUserEntity().getCompany_name());
				
				approval.setNextchecker(nextChecker);
				sendAuditMessage(apply,Constant.UserType.STREET,ShiroUtils.getStreetId(),getNextCheckersByLevel(list));
				
				approvalService.insertAndGetId(approval);
				//新增待办
				String handler = getNextCheckersIdsByLevelAndIdsStr(nextChecker);
				waitToDoService.newTODO("存量用地审核", "/stockLand/approvePage/" + apply.getId(), Constant.WaitToDo_OperType.AUDIT, apply.getId(),
						Constant.DictionaryType.STOCKLAND, apply.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_SERIAL);
			}
			return true;
		}
		return false;
	}

	public List<Integer> getNextCheckersByLevel(List<UserGroup> list) {
		List<Integer> checkerIds = new ArrayList<Integer>(); 
		int level = 0;
		for(UserGroup gUser : list) {
			if(null != gUser.getApprove_level() && gUser.getApprove_level() > level) {
				level = gUser.getApprove_level();
			}
		}
		for(UserGroup user : list) {
			if(null != user.getApprove_level() && user.getApprove_level().equals(level)) {
				checkerIds.add(user.getUser_id());
			}
		}
		return checkerIds;
	}
	
	//找到审核人里面下一级要审核的所有人员
	public List<Integer> getNextCheckersByLevelAndIdsStr(String userIds) {
		List<Integer> checkerIds = new ArrayList<Integer>(); 
		int level = 0;
		if(StringUtils.isNotBlank(userIds)) {
			for(String id : userIds.split(",")) {
				User gUser = userService.findById(Integer.valueOf(id));
				if(null != gUser.getApprove_level() && gUser.getApprove_level() > level) {
					level = gUser.getApprove_level();
				}
			}
			for(String id : userIds.split(",")) {
				User gUser = userService.findById(Integer.valueOf(id));
				if(null != gUser.getApprove_level() && gUser.getApprove_level().equals(level)) {
					checkerIds.add(Integer.valueOf(id));
				}
			}
		}
		return checkerIds;
	}
	
	//找到审核人里面下一级要审核的所有人员id,字符串
	public String getNextCheckersIdsByLevelAndIdsStr(String userIds) {
		List<Integer> checkerIds = new ArrayList<Integer>(); 
		int level = 0;
		if(StringUtils.isNotBlank(userIds)) {
			for(String id : userIds.split(",")) {
				User gUser = userService.findById(Integer.valueOf(id));
				if(null != gUser.getApprove_level() && gUser.getApprove_level() > level) {
					level = gUser.getApprove_level();
				}
			}
			for(String id : userIds.split(",")) {
				User gUser = userService.findById(Integer.valueOf(id));
				if(null != gUser.getApprove_level() && gUser.getApprove_level().equals(level)) {
					checkerIds.add(Integer.valueOf(id));
				}
			}
		}
		return StringUtils.join(checkerIds, ",");
	}
	
	
	/**
	 * 发送消息审核消息
	 * @param apply
	 * @param userType
	 * @param departmentId
	 */
	public void sendAuditMessage(StockLand apply, Integer userType, Integer departmentId, List<Integer> pushUserIds) {
		if(null != pushUserIds && pushUserIds.size()>0) {
			apply = this.findLandApplyById(apply.getId());
			Message message = getDefaultAuditMessage(apply);
			message.setBusiness_type(Constant.Message_Business_type.STOCKLAND);
			message.setApply_id(apply.getId());
			messageService.saveMessageAndPushToUser(message, pushUserIds,userType);
		}
	}

	//编辑申请
	public Boolean updateLandApply(StockLand apply) {
		//直接提交才有流程变化
		if(apply.getIsDraft()==Constant.IsDraft.NOT_DRAFT) {
			if(null == apply.getBuilding_street_id()) {
				apply.setBuilding_street_id(ShiroUtils.getStreetId());
			}
			//审核流程变化
			apply.setApply_status(Constant.LandApplyStatus.IN_AUDIT);
			apply.setApprove_status(Constant.LandApproveStatus.LOCAL_AUDIT);
			// 审核流
			Approval latestApproval = approvalService.getLatestApproval(apply.getId(),Constant.DictionaryType.STOCKLAND);
			Approval approval = new Approval();
			approval.setApply_id(apply.getId());
			if(null != latestApproval) {
				approval.setBefore_approvalstatus(latestApproval.getAfter_approvalstatus());
				approval.setApproval_round(latestApproval.getApproval_round()==null?1:latestApproval.getApproval_round()+1);
				approval.setOper_type(Constant.OperType.EDIT);
			}else {
				approval.setBefore_approvalstatus(Constant.LandApplyStatus.PENDING_SUBMIT);
				approval.setApproval_round(1);
				approval.setOper_type(Constant.OperType.SUBMIT);
			}
			approval.setAfter_approvalstatus(Constant.LandApproveStatus.LOCAL_AUDIT);
			approval.setChecker(ShiroUtils.getUserId());
			approval.setType(Constant.DictionaryType.STOCKLAND);
			approval.setDepartment(ShiroUtils.getUserEntity().getCompany_name());
			//根据工作组名称查出工作组
			Integer streetId = ShiroUtils.getStreetId();
			if(null != apply.getBuilding_street_id()) {
				streetId = apply.getBuilding_street_id();
			}
			Group group = groupService.findByNameAndUserType(Constant.HGXSHXZ, null,Constant.UserType.STREET,streetId);
			//如果不为空
			if(null != group){
				//根据工作组id查出UserGroup
				List<UserGroup> list = userGroupService.findByGroupId(group.getId());
				if(null == list || list.size()==0) {
					throw new BaseException("所属街道工业用地合规性审核组没有配置人员，请联系街道管理员配置!");
				}
				//构建一个StringBuffer 存放下一审核人id
				StringBuffer sb = new StringBuffer("");
				for (UserGroup userGroup: list) {
					Integer userId = userGroup.getUser_id();
					User user = userService.findById(userId);
					if(null == user.getApprove_level()){
						throw new BaseException("所属街道工业用地合规性审核组没有配置相应层级的人员，请联系街道管理员配置!");
					}
					sb.append(userId+",");
				}
				approval.setNextchecker(sb.toString());
				sendAuditMessage(apply,Constant.UserType.STREET,ShiroUtils.getStreetId(),getNextCheckersByLevel(list));
				//新增待办
				String handler = getNextCheckersIdsByLevelAndIdsStr(approval.getNextchecker());
				waitToDoService.newTODO("存量用地审核", "/stockLand/approvePage/" + apply.getId(), Constant.WaitToDo_OperType.AUDIT, apply.getId(),
						Constant.DictionaryType.STOCKLAND, apply.getApply_no(),handler , Constant.WaitToDo_IsSerial.IS_SERIAL);
			}else {
				throw new BaseException("所属街道还没有工业用地合规性审核组进行用地审核，请联系街道管理员配置!");
			}
			approvalService.saveSelective(approval);
		}
		if (this.updateSelective(apply) > 0) {
			//更新企业基本信息
			if(null != apply.getCompanyInfo()) {
				ProjectApplicationCompanyInfo companyInfo = apply.getCompanyInfo();
				projectApplicationCompanyInfoService.updateSelective(companyInfo);
			}
			if(null != apply.getApplyMaterials() && apply.getApplyMaterials().size()>0) {
				for(StockLandMaterial material : apply.getApplyMaterials()) {
					if(null == material.getId()) {
						material.setApply_id(apply.getId());
						stockLandMaterialService.saveMaterial(material);
					}else {
						stockLandMaterialService.updateMaterial(material);
					}
				}
			}
			// 根据deleteMaterialIds删除对应删除的材料
			stockLandMaterialService.deleteMaterials(apply.getDeleteMaterialIds());
			if(null != apply.getOtherMaterials() && apply.getOtherMaterials().size()>0) {
				for(StockLandMaterial material : apply.getOtherMaterials()) {
					if(null == material.getId()) {
						if(null != material.getFileDown() && null != material.getFileDown().getFile_id()) {
							material.setApply_id(apply.getId());
							material.setMaterial_type(Constant.LandApplyMaterialType.OTHER_MATERIAL);
							stockLandMaterialService.saveMaterial(material);
						}
					}else {
						stockLandMaterialService.updateMaterial(material);
					}
				}
			}
			if(null != apply.getSummaryMaterials() && apply.getSummaryMaterials().size()>0) {
				for(StockLandMaterial material : apply.getSummaryMaterials()) {
					if(null == material.getId()) {
						if(null != material.getFileDown() && null != material.getFileDown().getFile_id()) {
							material.setApply_id(apply.getId());
							material.setMaterial_type(Constant.LandApplyMaterialType.SUMMARY_MATERIAL);
							stockLandMaterialService.saveMaterial(material);
						}
					}else {
						stockLandMaterialService.updateMaterial(material);
					}
				}
			}
			return true;
		}
		return false;
	}

	//根据id查找用地申请
	public StockLand findLandApplyById(Integer id) {
		StockLand landApply = this.findById(id);
		if(null != landApply) {
			getFullLandInfo(landApply);
		}
		return landApply;
	}

	/**
	 * @Title: findPageInfo
	 * @Description: TODO(存量用地 待审核)
	 * @param @return
	 * @return PageInfo<StockLand>    返回类型
	 * @author jiangjz
	 * @param condition
	 * @param pageSize
	 * @param pageNum
	 */
	public PageInfo<StockLand> findPageInfo(Integer pageNum, Integer pageSize, SearchCondition condition) {

		//设置查询condition条件
		List<Integer> applyStatus = new ArrayList<>();

		Integer userId = ShiroUtils.getUserId();

		//根据当前用户userId查询和当前用户同一部门，审核层级小于当前用户的UserId
		List<Integer> userIdList = userService.findUserIdsByUserId(userId);
		//排除当前用户
		if (userIdList.size() > 0){
			userIdList.remove(userId);
		}

		List<String> groupNameList = this.getUserGroupName();

		if (groupNameList.contains(Constant.XTGZXZ)) {
			applyStatus.add(2);
			applyStatus.add(4);
			applyStatus.add(5);
			applyStatus.add(6);
			applyStatus.add(11);
			applyStatus.add(15);
		}
		
		//合规性审查不用合规性审查小组了
		//if (groupNameList.contains(Constant.HGXSHXZ)) {
			applyStatus.add(3);
		//}
		if (groupNameList.contains(Constant.JYLCSHXZ)) {
			//简易流程会签
			applyStatus.add(14);
		}

		if(null != applyStatus && applyStatus.size() > 0) {

			condition.setApply_status(applyStatus);
			condition.setUserId(ShiroUtils.getUserId());
			PageHelper.startPage(pageNum, pageSize);
				List<StockLand> stockLands = stockLandDao.findPageInfo(condition);
			/*for (Integer usrId : userIdList) {
				stockLands = stockLands.stream().filter(stockLand -> !(Arrays.asList(stockLand.getNextChecker().split(",")).contains(String.valueOf(usrId)))).collect(Collectors.toList());
			}*/

			for (StockLand stockLand : stockLands) {
				stockLand.setApply_time(this.getApplyDate(stockLand.getId()));
				//判断单据是否被当前用户的下一级所审核
				for (Integer usrId : userIdList) {
					if(Arrays.asList(stockLand.getNextChecker().split(",")).contains(String.valueOf(usrId))){
						stockLand.setIsApproval(0);
						break;
					}
				}

				//超过五天
				if ((stockLand.getOverTime() / 24) > 5) {
					stockLand.setOverTimeStr("超出" + String.valueOf((int) Math.round(stockLand.getOverTime() / 24)) + "天");
				} else {//少于五天
					stockLand.setOverTimeStr("剩余" + String.valueOf((int) Math.round(stockLand.getOverTime() / 24)) + "天");
				}
			}
			return new PageInfo<StockLand>(stockLands);
		}else{
			return new PageInfo<StockLand>(new ArrayList<>());
		}

	}


	/**
	 * 获取用户所属用户组
	 * @return
	 */
	public List<String> getUserGroupName() {
		List<String> list = new ArrayList<>();
		//User user = ShiroUtils.getCurrentUser();
		int userId = ShiroUtils.getUserId();
		List<UserGroup> userGroupList = userGroupService.findByUserId(userId);
		for (UserGroup ug : userGroupList) {
			int groupId = ug.getGroup_id();
			Group group = groupService.findById(groupId);
			if(null != group){
				list.add(group.getName());
			}
		}
		return list;
	}


	/**
	 * @Title: fileUpload
	 * @Description: TODO(存量用地审核 附件上传)
	 * @param @param id
	 * @param @param files
	 * @param @param baseFolderPath
	 * @return void    返回类型
	 * @author jiangjz
	 */
	@Transactional(rollbackFor = Exception.class)
	public void fileUpload(int id,MultipartFile files,String baseFolderPath) {
		File folder = new File(baseFolderPath, "areaApply");
		if (!folder.exists() || !folder.isDirectory()) {
			folder.mkdirs();
		}

		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;

		// 获得原始文件名
		String fileName = files.getOriginalFilename();
		// 新文件名
		String newFileName = UUID.randomUUID() + fileName;
		try {
			String path = baseFolderPath + "/areaApply/" + newFileName;
			bos = new BufferedOutputStream(new FileOutputStream(path));
			bis = new BufferedInputStream(files.getInputStream());

			int len = 0;
			byte[] bt = new byte[1024];
			while ((len = bis.read(bt)) != -1) {
				bos.write(bt, 0, len);
			}


			//将附件信息存放到表中
			Attachment attachment = new Attachment();
			attachment.setBusiness_id(id);
			attachment.setBusiness_type(Constant.Attach_BunessType.PENDING_DISTRIBUTE);
			attachment.setFile_name(newFileName);
			attachment.setFile_url(path);
			attachmentService.saveSelective(attachment);


		} catch (Exception e) {

			e.printStackTrace();
		} finally {
			if (bis != null) {
				try {
					bis.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			if (bos != null) {
				try {
					bos.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * @Title: submit
	 * @Description: TODO(存量用地审核)
	 * @param @param id
	 * @param @param comment
	 * @param @param type
	 * @param slad
	 * @return void    返回类型
	 * @author jiangjz
	 */
	public ResponseMessage submit(StockLandApprovalDto slad, Integer apply_type, StockLand apply, String departmentIds) {
		//单据id
		int id = slad.getApply_id();
		//前端操作类型
		Integer type = Integer.valueOf(slad.getStatus());
		//审核意见
		String comment = slad.getApproval_comment();
		//根据id查询出申请单据
		StockLand stockLand = this.findById(id);

//		String str = Constant.HGXSHXZ;


		//1.查出该单据最新一条的审核记录
		Example example = new Example(Approval.class);
		example.setTableName("z_approval");
		Example.Criteria criteria = example.createCriteria();
		criteria.andEqualTo("apply_id",id);
		criteria.andEqualTo("del_flag",false);
		criteria.andEqualTo("type",Constant.DictionaryType.STOCKLAND);
		example.setOrderByClause("create_Time desc");
		List<Approval> approvals = approvalService.selectByExample(example);
		Approval approval = null;
		if(null != approvals && approvals.size() > 0){
			approval = approvals.get(0);
		}

		if (CommonUtils.isNull(approval)) {
			logger.error("当前单据缺少审批流程");
			throw new RuntimeException("当前单据缺少审批流程");
		}
		//审核轮次
		Integer approval_round = null;
		if(null != approval) {
			approval_round = approval.getApproval_round();
		}
		//合规性审查“通过”或“退回”
		if(type == 5 || type == 6){
			if(null != approval){
				String nextChecker = approval.getNextchecker();
				//2.找出下一审核人
				//-2018-05-28 - 去除当前审核人同一审核层级，同一部门的人，同一层级只需要一个审核
				nextChecker = getNextLevelCheckerByDepartment(ShiroUtils.getUserId(),nextChecker);
				if(StringUtils.isNotBlank(nextChecker)) {
					//还有其他审核人
					nextChecker = nextChecker.replace(ShiroUtils.getUserId()+",","");
					//保存审核记录，并更新附件
					saveApprovalAndUpdateAttach(slad, id, comment, nextChecker,Constant.LandApproveStatus.COMPLIANCE_AUDIT,type == 5?Constant.OperType.SUBMIT_COMMENT:Constant.OperType.REJECT,approval_round);
					
					//如果是经办人，新增领导待办，如果是领导，不新增待办，直接完成
					
					String handler = getNextLevelByDepartment(ShiroUtils.getUserId(),nextChecker);
					if(StringUtils.isNotBlank(handler)) {
						waitToDoService.newTODO("存量用地审核", "/areaManager/approval?id=" + stockLand.getId(), Constant.WaitToDo_OperType.AUDIT, stockLand.getId(),
								Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_PARALLEL);
					}else {
						waitToDoService.completeTODO(stockLand.getId(), Constant.DictionaryType.STOCKLAND);
					}
					
				}else {
					//合规性审查全部审核完成
					boolean flag = true;
					//List<Integer> userIdList = userGroupService.findUserIdByGroupName(str);

					//查询最后一次分发各部门中的userId
					Approval app = approvalService.findLastByCheckerAndBeforeStatu(id,Constant.DictionaryType.STOCKLAND,null,Constant.LandApproveStatus.PENDING_DISTRIBUTE);
					String [] userIds = null;
					if(null != app){
						userIds = app.getNextchecker().split(",");
					}

					for(String userId : userIds){
						Approval approval1 = approvalService.findLastByCheckerAndBeforeStatu(id,Constant.DictionaryType.STOCKLAND,Integer.valueOf(userId),Constant.LandApproveStatus.COMPLIANCE_AUDIT);
						if(null != approval1 && approval1.getOper_type().equals(Constant.OperType.REJECT)){
							flag = false;
							break;
						}
					}
					//无论是否全部审查通过 状态改为都“合规性审查汇总”
                    stockLand.setApprove_status(Constant.LandApproveStatus.HGXSCTG);
					if(flag && type == 5){
						//全部通过 页面button设为 “进入区政府批准”
                        stockLand.setButton_status(0);
					//没有全部审查通过，页面button设为 “联合评议”
					}else{
                        stockLand.setButton_status(1);
					}
					//下一审核人到“协调工作组”,
					String userIdInThisGroup = findUserIdByGroupName(Constant.XTGZXZ);
					//保存审核记录，并更新附件
					saveApprovalAndUpdateAttach(slad, id, comment, userIdInThisGroup,Constant.LandApproveStatus.HGXSCTG,type == 5?Constant.OperType.SUBMIT_COMMENT:Constant.OperType.REJECT,approval_round);
					//新增待办
					String handler = userIdInThisGroup;
					waitToDoService.newTODO("存量用地审核", "/areaManager/approval?id=" + stockLand.getId(), Constant.WaitToDo_OperType.AUDIT, stockLand.getId(),
							Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_PARALLEL);
					
				}
				
				/* -2018-05-28 改变- 同一级审核需要都审核完成
				 * String [] nextCheckerArr = nextChecker.split(",");
				 * if(null != nextCheckerArr && nextCheckerArr.length > 0){
					//“合规性审核小组”最后一个人审核
					if(nextCheckerArr.length == 1){
						//当最后一个人审核通过后，判断是否全部通过，全部通过，将该单据的状态设为“合规性审查通过”，否则走联合评议
						//查出“合规性审核小组”所有成员最近的一条审核记录，是否全部审核通过(过期)
						boolean flag = true;
						//List<Integer> userIdList = userGroupService.findUserIdByGroupName(str);

						//查询最后一次分发各部门中的userId
						Approval app = approvalService.findLastByCheckerAndBeforeStatu(id,null,Constant.LandApproveStatus.PENDING_DISTRIBUTE);
						String [] userIds = null;
						if(null != app){
							userIds = app.getNextchecker().split(",");
						}

						for(String userId : userIds){
							Approval approval1 = approvalService.findLastByCheckerAndBeforeStatu(id,Integer.valueOf(userId),Constant.LandApproveStatus.COMPLIANCE_AUDIT);
							if(null != approval1 && approval1.getOper_type().equals(Constant.OperType.REJECT)){
								flag = false;
								break;
							}
						}
						//无论是否全部审查通过 状态改为都“合规性审查汇总”
                        stockLand.setApprove_status(Constant.LandApproveStatus.HGXSCTG);
						if(flag && type == 5){
							//全部通过 页面button设为 “进入区政府批准”
                            stockLand.setButton_status(0);
						//没有全部审查通过，页面button设为 “联合评议”
						}else{
                            stockLand.setButton_status(1);
						}
						//下一审核人到“协调工作组”,
						String userIdInThisGroup = findUserIdByGroupName(Constant.XTGZXZ);
						//保存审核记录，并更新附件
						saveApprovalAndUpdateAttach(slad, id, comment, userIdInThisGroup,Constant.LandApproveStatus.HGXSCTG,type == 5?Constant.OperType.SUBMIT_COMMENT:Constant.OperType.REJECT,approval_round);

						//不是最后一个人审核
					}else{
						nextChecker = nextChecker.replace(ShiroUtils.getUserId()+",","");
						//保存审核记录，并更新附件
						saveApprovalAndUpdateAttach(slad, id, comment, nextChecker,Constant.LandApproveStatus.COMPLIANCE_AUDIT,type == 5?Constant.OperType.SUBMIT_COMMENT:Constant.OperType.REJECT,approval_round);
					}
				}*/

			}

		//走简易流程
		} else if(type == 1) {
			stockLand.setApprove_status(Constant.LandApproveStatus.APPROVED);
			//将下一审核人设为 街道
			String checkers = this.getNextChecker(stockLand);
			//保存审核记录，并更新附件
			saveApprovalAndUpdateAttach(slad, id, comment, checkers,Constant.LandApproveStatus.APPROVED,Constant.OperType.APPROVED,approval_round);
			//新增待办
			String handler = checkers;
			waitToDoService.newTODO("存量用地确认并通知", "/stockLand/confirmPage/" + stockLand.getId(), Constant.WaitToDo_OperType.CONFIRM_AND_NOTIFY, stockLand.getId(),
					Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_SERIAL);

		//分送各部门,将申请状态改变，并将下一审核人设为各部门的领导和科员
		}else if(type == 2 ){
			//协调工作小组审核
			//将状态设为“合规性审查”
			stockLand.setApprove_status(Constant.LandApproveStatus.COMPLIANCE_AUDIT);
			//查出要分送的各部门(暂定“工业用地合规性审核组”)
			//根据工作组名称查出工作组
			//Group group = groupService.findByName(str, null);
			//如果不为空
			//if(null != group){
				//根据工作组id查出UserGroup
				//List<UserGroup> list = userGroupService.findByGroupId(group.getId());
				//构建一个StringBuffer 存放下一审核人id
				//StringBuffer sb = new StringBuffer("");
				//for (UserGroup userGroup: list) {
				//	Integer userId = userGroup.getUser_id();
				//	sb.append(userId+",");
				//}
				//保存审核记录，并更新附件
				//saveApprovalAndUpdateAttach(slad, id, comment, sb.toString(),Constant.LandApproveStatus.COMPLIANCE_AUDIT,Constant.OperType.APPROVED);
			//}
			StringBuffer sb = new StringBuffer("");
			if(StringUtils.isNotBlank(departmentIds)){
				String departmentIdArr [] = departmentIds.split(",");
				String handler = "";//待办操作人，待办先发送经办人
				for(String departId:departmentIdArr){
					List<User> userList = userService.findUserBydepartmentId(departId);
					if(null == userList || userList.size() == 0){
						String departmentName = departmentService.findById(Integer.valueOf(departId)).getName();
						return ResponseMessage.error(departmentName+"没有审核人！");
					}else {
						//是否有一级二级审批人
						if(!checkAuditPerson(userList,Constant.LandApproveStatus.COMPLIANCE_AUDIT)) {
							String departmentName = departmentService.findById(Integer.valueOf(departId)).getName();
							return ResponseMessage.error(departmentName+"审核人不全，需要有一级二级审核人！");
						}
					}
					for(User user:userList){
						sb.append(user.getId()+",");
					}
					handler += getFirstLevelChecker(userList);
				}
				saveApprovalAndUpdateAttach(slad, id, comment, sb.toString(),Constant.LandApproveStatus.COMPLIANCE_AUDIT,Constant.OperType.APPROVED,approval_round);
				//新增待办
				//String handler = getFirstLevelChecker(userList);
				waitToDoService.newTODO("存量用地审核", "/areaManager/approval?id=" + stockLand.getId(), Constant.WaitToDo_OperType.AUDIT, stockLand.getId(),
						Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_SERIAL);
				
			}else{
				return ResponseMessage.error("请选择部门！");
			}
		//简易流程退回
		}else if (type == 3){
			//将状态设为“退回”
			stockLand.setApprove_status(Constant.LandApproveStatus.REJECT);
			//下一审核人街道
			String checkers = this.getNextChecker(stockLand);
			//保存审核记录，并更新附件
			saveApprovalAndUpdateAttach(slad, id, comment,checkers,Constant.LandApproveStatus.REJECT,Constant.OperType.REJECT,approval_round);
			//新增待办
			String handler = checkers;
			waitToDoService.newTODO("存量用地确认并通知", "/stockLand/confirmPage/" + stockLand.getId(), Constant.WaitToDo_OperType.CONFIRM_AND_NOTIFY, stockLand.getId(),
					Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_SERIAL);
		//退回，
		}else if (type == 4){
			doReject(slad, id, comment, stockLand, approval_round, Constant.LandApproveStatus.REJECT, Constant.OperType.REJECT);
			//进入联合评议
		}else if (type == 7){
			stockLand.setApprove_status(Constant.LandApproveStatus.UNITED_AUDIT);
			//下一审核人，协调工作组
			String userIdInThisGroup = findUserIdByGroupName(Constant.XTGZXZ);
			//保存审核记录，并更新附件
			saveApprovalAndUpdateAttach(slad, id, comment,userIdInThisGroup,Constant.LandApproveStatus.UNITED_AUDIT,Constant.OperType.APPROVED,approval_round);
			//新增待办
			String handler = userIdInThisGroup;
			waitToDoService.newTODO("存量用地审核", "/areaManager/approval?id=" + stockLand.getId(), Constant.WaitToDo_OperType.AUDIT, stockLand.getId(),
					Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_SERIAL);
			
		//进入区政府审核
		}else if(type == 8){
			//合规性审查全部通过后，状态改为政府审核。由协调小组操作
			stockLand.setApprove_status(Constant.LandApproveStatus.GOVERNMENT_AUDIT);
			//下一审核人，协调工作组
			String userIdInThisGroup = findUserIdByGroupName(Constant.XTGZXZ);
			//保存审核记录，并更新附件
			saveApprovalAndUpdateAttach(slad, id, comment,userIdInThisGroup,Constant.LandApproveStatus.GOVERNMENT_AUDIT,Constant.OperType.APPROVED,approval_round);
			//新增待办
			String handler = userIdInThisGroup;
			waitToDoService.newTODO("存量用地审核", "/areaManager/approval?id=" + stockLand.getId(), Constant.WaitToDo_OperType.AUDIT, stockLand.getId(),
					Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_SERIAL);
		//政府审核通过
		}else if(type == 9){
			doApproval(slad,
					id,
					comment,
					stockLand,
					approval_round,
					Constant.LandApproveStatus.APPROVED,
					Constant.OperType.APPROVED);
			//提交联合评议
		}else if(type == 10){
            if(null != apply.getMipMaterials() && apply.getMipMaterials().size()>0) {
                for(StockLandMaterial material : apply.getMipMaterials()) {
					if(null != material.getFileDown() && null != material.getFileDown().getFile_id()) {
						material.setMaterial_type(Constant.LandApplyMaterialType.MAJOR_INVESTMENT_PROJECTS);
						material.setApply_id(id);
						stockLandMaterialService.saveMaterial(material);
					}
                }
            }
			stockLand.setIs_zdxm(apply.getIs_zdxm());
			stockLand.setZdxm_comment(apply.getZdxm_comment());
            stockLand.setApprove_status(Constant.LandApproveStatus.GOVERNMENT_AUDIT);
            //下一审核人，协调工作组
            String userIdInThisGroup = findUserIdByGroupName(Constant.XTGZXZ);
			//保存审核记录，并更新附件
			saveApprovalAndUpdateAttach(slad, id, comment,userIdInThisGroup,Constant.LandApproveStatus.GOVERNMENT_AUDIT,Constant.OperType.APPROVED,approval_round);
			//新增待办
			String handler = userIdInThisGroup;
			waitToDoService.newTODO("存量用地审核", "/areaManager/approval?id=" + stockLand.getId(), Constant.WaitToDo_OperType.AUDIT, stockLand.getId(),
					Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_SERIAL);
		//二次联合评议审核通过
        }else if(type == 11){
            //二次联合评议审核通过后，状态改为政府审核。由协调小组操作
            stockLand.setApprove_status(Constant.LandApproveStatus.GOVERNMENT_AUDIT);
            //下一审核人，协调工作组
            String userIdInThisGroup = findUserIdByGroupName(Constant.XTGZXZ);
			//保存审核记录，并更新附件
			saveApprovalAndUpdateAttach(slad, id, comment,userIdInThisGroup,Constant.LandApproveStatus.GOVERNMENT_AUDIT,Constant.OperType.APPROVED,approval_round);
			//新增待办
			String handler = userIdInThisGroup;
			waitToDoService.newTODO("存量用地审核", "/areaManager/approval?id=" + stockLand.getId(), Constant.WaitToDo_OperType.AUDIT, stockLand.getId(),
					Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_SERIAL);
        }else if(type == 13){
            //简易流程分发，状态改为简易流程会签。由简易流程会签用户组操作
            stockLand.setApprove_status(Constant.LandApproveStatus.JYLCHQ);
            //下一审核人，工业用地简易流程审核组
            String userIdInThisGroup = findUserIdByGroupName(Constant.JYLCSHXZ);
			//保存审核记录，并更新附件
			saveApprovalAndUpdateAttach(slad, id, comment,userIdInThisGroup,Constant.LandApproveStatus.JYLCHQ,Constant.OperType.APPROVED,approval_round);
			//新增待办
			String handler = userIdInThisGroup;
			waitToDoService.newTODO("存量用地审核", "/areaManager/approval?id=" + stockLand.getId(), Constant.WaitToDo_OperType.AUDIT, stockLand.getId(),
					Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_SERIAL);
        }else if(type == 15||type == 14){
        	//简易流程会签
        	if(null != approval){
				String nextChecker = approval.getNextchecker();
				//2.找出下一审核人
				String [] nextCheckerArr = nextChecker.split(",");
				if(null != nextCheckerArr && nextCheckerArr.length > 0){
					//“工业用地简易流程审核组”最后一个人审核
					if(nextCheckerArr.length == 1){
						//当最后一个人审核后，将该单据的状态设为“简易流程汇总”
                        stockLand.setApprove_status(Constant.LandApproveStatus.JYLCHZ);
						//下一审核人到“协调工作组”,
						nextChecker = findUserIdByGroupName(Constant.XTGZXZ);
						//保存审核记录，并更新附件
						saveApprovalAndUpdateAttach(slad, id, comment, nextChecker,Constant.LandApproveStatus.JYLCHZ, Constant.OperType.SUBMIT_COMMENT,approval_round);
						//新增待办
						String handler = nextChecker;
						waitToDoService.newTODO("存量用地审核", "/areaManager/approval?id=" + stockLand.getId(), Constant.WaitToDo_OperType.AUDIT, stockLand.getId(),
								Constant.DictionaryType.STOCKLAND,stockLand.getApply_no(), handler , Constant.WaitToDo_IsSerial.IS_PARALLEL);
						
					}else{
						//不是最后一个人审核
						nextChecker = nextChecker.replace(ShiroUtils.getUserId()+",","");
						//保存审核记录，并更新附件
						saveApprovalAndUpdateAttach(slad, id, comment, nextChecker,Constant.LandApproveStatus.JYLCHQ, Constant.OperType.SUBMIT_COMMENT,approval_round);
						//完成待办
						waitToDoService.completeTODO(stockLand.getId(), Constant.DictionaryType.STOCKLAND);
					}
				}
				
			}

        	// wj 新简易流程通过
        } else if (Objects.equals(type.toString(), Constant.LandApproveStatus.EASY_PROCESS_APPROVED)) {

			doApproval(slad,
					id,
					comment,
					stockLand,
					approval_round,
					Constant.LandApproveStatus.EASY_PROCESS_APPROVED,
					Constant.OperType.APPROVED);

		} else if (Objects.equals(type.toString(), Constant.LandApproveStatus.EASY_PROCESS_DENY)) {
			doReject(slad,
					id,
					comment,
					stockLand,
					approval_round,
					Constant.LandApproveStatus.EASY_PROCESS_DENY,
					Constant.OperType.REJECT);

		} else {
			logger.error("错误状态提交, 错误状态值: {}", type);
			throw new RuntimeException("错误状态提交, 错误状态值");
		}

		//更新单据
		this.updateSelective(stockLand);
		return ResponseMessage.success("审核成功！");
	}

	private void doReject(StockLandApprovalDto slad, int id, String comment, StockLand stockLand, Integer approval_round, String reject, String operaType) {
		//将状态设为“退回”
		stockLand.setApprove_status(reject);
		//下一审核人街道
		String checkers = this.getNextChecker(stockLand);
		//保存审核记录，并更新附件
		saveApprovalAndUpdateAttach(slad, id, comment, checkers, reject, operaType, approval_round);
		//给企业以外的部门发送消息
		//1.先获取企业以外所有的部门id（参与审核的部门id）
		List<String> departments = approvalService.findDepartmentNameByApplyId(id);
		int[] pushIds = departmentService.findDepartmentIdByName(departments);
		int[] streetId = new int[]{stockLand.getStreet_id()};
		stockLand.setApply_type_str(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.STOCKLAND, stockLand.getApply_type()));
		stockLand.setApprove_status_str(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.STOCKLAND_APPROVE_STATUS, stockLand.getApprove_status()));
		messageService.saveMessageAndPush(getDefaultMessage(stockLand), pushIds, 0);
		messageService.saveMessageAndPush(getDefaultMessage(stockLand), streetId, 4);
		//新增待办
		String handler = checkers;
		waitToDoService.newTODO("存量用地确认并通知", "/stockLand/confirmPage/" + stockLand.getId(), Constant.WaitToDo_OperType.CONFIRM_AND_NOTIFY, stockLand.getId(),
				Constant.DictionaryType.STOCKLAND, stockLand.getApply_no(), handler, Constant.WaitToDo_IsSerial.IS_SERIAL);
	}

	/**
	 *
	 * @param slad
	 * @param id
	 * @param comment
	 * @param stockLand
	 * @param approval_round
	 * @param approved
	 * @param approved2
	 */
	private void doApproval(StockLandApprovalDto slad, int id, String comment, StockLand stockLand, Integer approval_round, String approved, String operaType) {
		stockLand.setApprove_status(approved);
		//下一审核人街道
		String checkers = this.getNextChecker(stockLand);
		//保存审核记录，并更新附件
		saveApprovalAndUpdateAttach(slad, id, comment, checkers, approved, operaType, approval_round);
		//给企业以外的部门发送消息
		//1.先获取企业以外所有的部门id（参与审核的部门id）
		List<String> departments = approvalService.findDepartmentNameByApplyId(id);
		int[] pushIds = departmentService.findDepartmentIdByName(departments);
		int[] streetId = new int[]{stockLand.getStreet_id()};
		stockLand.setApply_type_str(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.STOCKLAND, stockLand.getApply_type()));
		stockLand.setApprove_status_str(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.STOCKLAND_APPROVE_STATUS, stockLand.getApprove_status()));
		messageService.saveMessageAndPush(getDefaultMessage(stockLand), pushIds, 0);
		messageService.saveMessageAndPush(getDefaultMessage(stockLand), streetId, 4);
		//新增待办
		String handler = checkers;
		waitToDoService.newTODO("存量用地确认并通知", "/stockLand/confirmPage/" + stockLand.getId(), Constant.WaitToDo_OperType.CONFIRM_AND_NOTIFY, stockLand.getId(),
				Constant.DictionaryType.STOCKLAND, stockLand.getApply_no(), handler, Constant.WaitToDo_IsSerial.IS_SERIAL);
	}

	/**
	 * 判断单据在当前节点是否已经审核过
	 * @param apply_id
	 * @param beforeApproveStatus 单据当前状态
	 * @return
	 */
	public boolean isApproved(Integer apply_id, String beforeApproveStatus) {
		Approval latest =  approvalService.getLatestApproval(apply_id,Constant.DictionaryType.STOCKLAND);
		if(null != latest ) {
			if(latest.getBefore_approvalstatus().equals(beforeApproveStatus)) {
				return true;
			}
		}
		return false;
	}

	//2018-05-28 - 去除当前审核人同一审核层级，同一部门的人，同一层级只需要一个审核
	private String getNextLevelCheckerByDepartment(Integer currCheckerId, String nextChecker) {
		String [] nextCheckerArr = nextChecker.split(",");
		User currChecker = userService.findById(currCheckerId);
		Integer level = currChecker.getApprove_level();
		Integer deptId = currChecker.getDepartment_id();
		//去除相同级别的checker
		for(String userId : nextCheckerArr) {
			User checker = userService.findById(Integer.valueOf(userId));
			if(null != checker.getApprove_level() && checker.getApprove_level().equals(level)
					&& null != checker.getDepartment_id() && checker.getDepartment_id().equals(deptId)) {
				nextChecker = nextChecker.replace(userId + ",", "");
			}
		}
		
		return nextChecker;
	}

	//2018-06-21 - 查找同一部门的领导审核人
	private String getNextLevelByDepartment(Integer currCheckerId, String nextChecker) {
		String nextLevelChecker = "";
		String [] nextCheckerArr = nextChecker.split(",");
		User currChecker = userService.findById(currCheckerId);
		Integer level = currChecker.getApprove_level();
		if(null == level){
			throw new BaseException("当前用户没有审核层级，请检查");
		}
		Integer deptId = currChecker.getDepartment_id();
		//去除相同级别的checker
		for(String userId : nextCheckerArr) {
			User checker = userService.findById(Integer.valueOf(userId));
			if(null == checker.getApprove_level()){
				throw new BaseException("审核组有审核人员没有审核层级，请检查");
			}
			if(null != checker.getApprove_level() && checker.getApprove_level()< level
					&& null != checker.getDepartment_id() && checker.getDepartment_id().equals(deptId)) {
				nextLevelChecker += userId +",";
			}
		}
		
		return nextLevelChecker;
	}
	
	//找到第一审核人
	public String getFirstLevelChecker(List<User> userList){
		String firstLavelChecker = "";
		//合规性审查，部门需要一级二级至少两个审批人
		for(User user : userList) {
			if(user.getApprove_level().equals(1)){
				firstLavelChecker += user.getId() + ",";
			}
		}
		return firstLavelChecker;
	}
	
	public Boolean checkAuditPerson(List<User> userList,String auditType){
		Boolean flag = false;
		if(auditType.equals(Constant.LandApproveStatus.COMPLIANCE_AUDIT)) {
			//合规性审查，部门需要一级二级至少两个审批人
			Boolean haslevel0 = false;
			Boolean haslevel1 = false;
			for(User user : userList) {
				if(user.getApprove_level().equals(0)) {
					haslevel0 = true;
				}else if(user.getApprove_level().equals(1)){
					haslevel1 = true;
				}
			}
			flag = haslevel1 && haslevel0 ;
		}
		return flag;
	}
	
	/**
	 * 存量用地--已审核
	 * @param pageNum
	 * @param pageSize
	 * @param condition
	 * @return
	 */
	public PageInfo<StockLand> findApprovalPageInfo(Integer pageNum, Integer pageSize, SearchCondition condition) {
		condition.setUserId(ShiroUtils.getUserId());
		//同一部门同一审核层级的人可以看见对方审核过的数据
		List<Integer> checker_ids = getSameCheckers();
		if( null != checker_ids && checker_ids.size()>0 ) {
			condition.setChecker_ids(checker_ids);
		}
		PageHelper.startPage(pageNum, pageSize);
		List<StockLand> stockLandss = stockLandDao.findApprovalPageInfo(condition);
		for (StockLand stockLand : stockLandss) {
			stockLand.setApply_time(this.getApplyDate(stockLand.getId()));
			//超过十天
			if ((stockLand.getOverTime() / 24) > 10) {
				stockLand.setOverTimeStr("超出" + String.valueOf((int) Math.floor(stockLand.getOverTime() / 24)) + "天" + (stockLand.getOverTime() % 24) + "小时");
			} else {//少于十天
				stockLand.setOverTimeStr("剩余" + String.valueOf((int) Math.floor(stockLand.getOverTime() / 24)) + "天" + (stockLand.getOverTime() % 24) + "小时");
			}
			//最近一次是否是当前用户审核的，如果是且没有撤回，则可撤回
        	/*Approval latestAllApproval = approvalService.getLatestApprovalAll(stockLand.getId());
        	if(null == latestAllApproval.getIs_withdraw() && null != latestAllApproval.getChecker() && latestAllApproval.getChecker().equals(ShiroUtils.getUserId())) {
        		stockLand.setCanWithdraw(Constant.True_False.TRUE);
        	}*/
        	stockLand.setCanWithdraw(this.canWithdraw(stockLand, ShiroUtils.getUserId()));
		}
		return new PageInfo<StockLand>(stockLandss);
	}

	//当前单据是否可以撤回
	public Integer canWithdraw(StockLand stockLand, int userId) {
		//最近一条审核是自己审核的，可以撤回
		Approval latestAllApproval = approvalService.getLatestApprovalAll(stockLand.getId(),Constant.DictionaryType.STOCKLAND);
		if (latestAllApproval == null){
			return Constant.True_False.FASLE;
		}
    	if(null == latestAllApproval.getIs_withdraw() && null != latestAllApproval.getChecker() && latestAllApproval.getChecker().equals(ShiroUtils.getUserId())) {
    		//stockLand.setCanWithdraw(Constant.True_False.TRUE);
    		return Constant.True_False.TRUE;
    	}
    	//最近一条有效的审核记录，用于获取当前的下一审核人
    	Approval latestApproval = approvalService.getLatestApproval(stockLand.getId(),Constant.DictionaryType.STOCKLAND);
		if (latestApproval == null){
			return Constant.True_False.FASLE;
		}
    	//合规性审查并行审核，每个部门可以单独撤回
    	//1.当前是合规性审查
    	//2.当前用户最近一条审核记录是合规性审核,没有撤回过
    	//3.下一审核层级还没审核
    	if(stockLand.getApprove_status().equals(Constant.LandApproveStatus.COMPLIANCE_AUDIT)) {
    		Approval latestAllApprovalByUser = approvalService.getLatestApprovalAllByUser(stockLand.getId(),Constant.DictionaryType.STOCKLAND,userId);
    		if(null != latestAllApprovalByUser) {
    			if(latestAllApprovalByUser.getApproval_round().equals(latestApproval.getApproval_round())&&
        				null == latestAllApprovalByUser.getIs_withdraw() && latestAllApprovalByUser.getBefore_approvalstatus().equals(Constant.LandApproveStatus.COMPLIANCE_AUDIT)) {
        			//当前用户最近一条审核记录是是合规性审核
        			Integer approveLevel = ShiroUtils.getUserEntity().getApprove_level();
        			if(null != approveLevel && approveLevel.equals(1)) {
        				//是经办人，要判断下一级审核人是否已经审核
        		    	User currUser = ShiroUtils.getUserEntity();
        				
        		    	String[] userIds = latestApproval.getNextchecker().split(",");
        		    	if(userIds.length>0) {
    		        		//判断登录用户的下一审核层级有没有审核
    	        			for(String uId : userIds) {
    	                    	User user = userService.findById(Integer.valueOf(uId));
    	                    	if(null != user.getDepartment_id() && user.getDepartment_id().equals(currUser.getDepartment_id())) {
    	                    		if(null != user.getApprove_level() && null != currUser.getApprove_level() && user.getApprove_level()<currUser.getApprove_level()) {
    	                        		//下一级审核人还没审核，可以撤回
    	                    			return Constant.True_False.TRUE;
    	                        	}else {
    	                        		//下一级审核人已经审核过了，不可撤回
    	                        		return Constant.True_False.FASLE;
    	                        	}
    	                    	}
    	            		}
        		    		
        		    	}
        			}else if(null != approveLevel && approveLevel.equals(0)){
        				//领导，可以撤回
        				return Constant.True_False.TRUE;
        			}
        		}
    		}
    	}else if(stockLand.getApprove_status().equals(Constant.LandApproveStatus.HGXSCTG)) {
    		Approval latestAllApprovalByUser = approvalService.getLatestApprovalAllByUser(stockLand.getId(),Constant.DictionaryType.STOCKLAND,userId);
    		if(null != latestAllApprovalByUser) {
    			if(latestAllApprovalByUser.getApproval_round().equals(latestApproval.getApproval_round())&&
        				null == latestAllApprovalByUser.getIs_withdraw() && latestAllApprovalByUser.getBefore_approvalstatus().equals(Constant.LandApproveStatus.COMPLIANCE_AUDIT)) {
        			//当前用户最近一条审核记录是是合规性审核
        			Integer approveLevel = ShiroUtils.getUserEntity().getApprove_level();
        			if(null != approveLevel && approveLevel.equals(1)) {
        				//是经办人，不可以撤回
        				return Constant.True_False.FASLE;
        			}else if(null != approveLevel && approveLevel.equals(0)){
        				//领导，可以撤回
        				return Constant.True_False.TRUE;
        			}
        		}
    		}
    	}
    	return Constant.True_False.FASLE;
	}
	
	//获取同一部门同一审核层级的
	private List<Integer> getSameCheckers() {
		List<Integer> sameCheckers = new ArrayList<Integer>();
		Integer departId = ShiroUtils.getUserEntity().getDepartment_id();
		Integer level = ShiroUtils.getUserEntity().getApprove_level();
		if(null != departId && null != level) {
			List<User> userList = userService.findUserBydepartmentId(String.valueOf(departId));
			for(User user:userList) {
				if(null != user.getApprove_level() && user.getApprove_level().equals(level)) {
					sameCheckers.add(user.getId());
				}
			}
		}
		return sameCheckers;
	}

	public void saveApprovalAndUpdateAttach(StockLandApprovalDto slad, int id, String comment, String userIdInThisGroup,String afterStatu,String Oper_type,Integer approval_round) {
		Approval approval1 = new Approval();
		String department = "" ;
		if(null != userService.findById(ShiroUtils.getUserId()).getDepartment_id()) {
			Department dept = departmentService.findById(userService.findById(ShiroUtils.getUserId()).getDepartment_id());
			if(null != dept) {
				department = dept.getName();
			}
		}
		approval1.setDepartment(department);
		approval1.setApply_id(id);
		approval1.setType(Constant.DictionaryType.STOCKLAND);
		approval1.setApproval_comment(comment);
		approval1.setBefore_approvalstatus(slad.getStatu());
		approval1.setAfter_approvalstatus(afterStatu);
		approval1.setDeal_time(DateUtil.getTimeString(new Date()));
		approval1.setChecker(ShiroUtils.getUserId());
		approval1.setNextchecker(userIdInThisGroup);
		approval1.setOper_type(Oper_type);
		approval1.setApproval_round(approval_round);
		//保存审核记录
		approvalService.insertAndGetId(approval1);
		updateAttachment(slad, approval1.getId());
	}

	public String  findUserIdByGroupName(String groupName) {
		Group group =  groupService.findByName(groupName,null);
		List<UserGroup> userGroups = userGroupService.findByGroupId(group.getId());
		StringBuffer sb = new StringBuffer("");
		for (UserGroup userGroup : userGroups) {
            sb.append(userGroup.getUser_id()+",");
        }
        return sb.toString();
	}

	private void updateAttachment(StockLandApprovalDto slad, Integer approval_id) {
		if(null != slad.getFileDowns() && slad.getFileDowns().size()>0) {
			for (FileDown file : slad.getFileDowns()) {
				Integer file_id = file.getFile_id();
				if(null != file_id){
					attachmentDao.updateAttachment(Constant.Attachment.STOCKLAND_APPROVE, approval_id, file.getFile_id());
				}
			}
		}

	}

	//默认消息
	public Message getDefaultAuditMessage(StockLand landApply) {
		Message msg = new Message();
		String title = "您有一条存量用地申请待审核！单号（" + landApply.getApply_no() + "）";
		String applyTypeName = landApply.getApply_type_str();
		String approveStatus = landApply.getApprove_status_str();
		String content = "您有一条待审核的存量用地申请 ：" + applyTypeName ;
		content += "（单号：" + landApply.getApply_no() + "）" +"目前审核状态为  " + approveStatus + "。请尽快前去审核！";
		msg.setTitle(title);
		msg.setContent(content);
		return msg;
	}

	//默认消息
	public Message getDefaultMessage(StockLand landApply) {
		Message msg = new Message();
		msg.setBusiness_type(Constant.Message_Business_type.STOCKLAND);
		String title = "您申请过的单号为" + landApply.getApply_no() + "的申请，状态更新啦";
		String applyTypeName = landApply.getApply_type_str();
		String approveStatus = landApply.getApprove_status_str();
		String temp_sate = "";
		if(null != landApply.getTemporary_state()){
			temp_sate = landApply.getTemporary_state().equals(Constant.LandApproveStatus.APPROVED)?Constant.Attach_BunessType.APPROVED:
					(landApply.getTemporary_state().equals(Constant.LandApproveStatus.NOTAPPROVED)?Constant.Attach_BunessType.NOTAPPROVED:Constant.Attach_BunessType.REJECT);
		}


		String content = "您的存量用地申请 ：" + applyTypeName ;
		if(landApply.getApply_type().equals(Constant.LandApplyType.RENT)){
			content += "（单号：" + landApply.getApply_no() + "）" +"目前审核状态为  " +temp_sate + "。请知悉！";
		}else{
			content += "（单号：" + landApply.getApply_no() + "）" +"目前审核状态为  " +approveStatus + "。请知悉！";
		}
		//添加退回或不通过的意见
		Approval approval = approvalService.getLatestApproval(landApply.getId(),Constant.DictionaryType.STOCKLAND);
		if(approval.getOper_type().equals(Constant.OperType.REJECT) || approval.getOper_type().equals(Constant.OperType.NOTAPPROVED)) {
			content += " 审核意见：" + approval.getApproval_comment();
		}
		
		msg.setTitle(title);
		msg.setContent(content);
		return msg;
	}

	public List<ProcessNodeDto> getProcessNodes(StockLand landApply, Boolean isCompany) {
		List<ProcessNodeDto> processNodes = new ArrayList<ProcessNodeDto>();
		if(isCompany) {
			DictionaryItem currentNode = dictionaryItemService.findByTypeAndValue(Constant.DictionaryType.STOCKLAND_APPLY_STATUS, landApply.getApply_status());
			List<DictionaryItem> applyStatusList = dictionaryItemService.findListByTypeName(Constant.DictionaryType.STOCKLAND_APPLY_STATUS);
			if(currentNode.getValue().equals(Constant.LandApplyStatus.NOTPASSED)||currentNode.getValue().equals(Constant.LandApplyStatus.PASSED)) {
				for(DictionaryItem node : applyStatusList) {
					if(currentNode.getSort()>node.getSort()) {
						if(!(node.getValue().equals(Constant.LandApplyStatus.REJECT)||node.getValue().equals(Constant.LandApplyStatus.NOTAPPROVED))) {
							ProcessNodeDto processNode = new ProcessNodeDto(node,false);
							processNodes.add(processNode);
						}
					}
				}
			}else {
				for(DictionaryItem node : applyStatusList) {
					if(currentNode.getSort()>node.getSort()) {
						ProcessNodeDto processNode = new ProcessNodeDto(node,false);
						processNodes.add(processNode);
					}
				}
			}
			
			processNodes.add(new ProcessNodeDto(currentNode,currentNode.getValue().equals(Constant.LandApplyStatus.REJECT)));
				
		}else {
			DictionaryItem currentNode = dictionaryItemService.findByTypeAndValue(Constant.DictionaryType.STOCKLAND_APPROVE_STATUS, landApply.getApprove_status());
			List<DictionaryItem> approveStatusList = approvalService.findProcessNodes(landApply.getId(),Constant.DictionaryType.STOCKLAND_APPROVE_STATUS);
			for(DictionaryItem node : approveStatusList) {
				ProcessNodeDto processNode = new ProcessNodeDto(node,false);
				processNodes.add(processNode);
			}
			processNodes.add(new ProcessNodeDto(currentNode,currentNode.getValue().equals(Constant.LandApproveStatus.REJECT)));
		}
		return processNodes;
	}

	@Transactional
	public String getNextChecker(){
		//根据工作组名称查出工作组
		Group group = groupService.findByNameAndUserType(Constant.HGXSHXZ, null,Constant.UserType.STREET,null);
		StringBuffer sb = new StringBuffer("");
		//如果不为空
		if(null != group) {
			//根据工作组id查出UserGroup
			List<UserGroup> list = userGroupService.findByGroupId(group.getId());
			if (null == list || list.size() == 0) {
				throw new BaseException("本公司所属街道工业用地合规性审核组没有配置人员，请联系街道管理员配置!");
			}
			//构建一个StringBuffer 存放下一审核人id
			for (UserGroup userGroup : list) {
				Integer userId = userGroup.getUser_id();
				sb.append(userId + ",");
			}
		}
		return sb.toString();
	}
	
	@Transactional
	public String getNextChecker(StockLand apply){
		//根据工作组名称查出工作组
		Integer streetId =null;
		if(null != apply.getBuilding_street_id()) {
			streetId = apply.getBuilding_street_id();
		}else {
			streetId = apply.getStreet_id();
		}
		Group group = groupService.findByNameAndUserType(Constant.HGXSHXZ, null,Constant.UserType.STREET,streetId);
		StringBuffer sb = new StringBuffer("");
		//如果不为空
		if(null != group) {
			//根据工作组id查出UserGroup
			List<UserGroup> list = userGroupService.findByGroupId(group.getId());
			if (null == list || list.size() == 0) {
				throw new BaseException("所属街道工业用地合规性审核组没有配置人员，请联系街道管理员配置!");
			}
			//构建一个StringBuffer 存放下一审核人id
			for (UserGroup userGroup : list) {
				Integer userId = userGroup.getUser_id();
				sb.append(userId + ",");
			}
		}
		return sb.toString();
	}


	public String getCompanyRegister(Integer streeId){
		//根据工作组名称查出工作组
		//Group group = groupService.findByNameAndUserType(Constant.QYZCSH, null,Constant.UserType.STREET);
		Group group = new Group();
		group.setName(Constant.QYZCSH);
		group.setUser_type(Constant.UserType.STREET);
		group.setStreet_id(streeId);
		Group group1 = groupService.findOne(group);
		StringBuffer sb = new StringBuffer("");
		//如果不为空
		if(null != group1) {
			//根据工作组id查出UserGroup
			List<UserGroup> list = userGroupService.findByGroupId(group1.getId());
			if (null == list || list.size() == 0) {
				throw new BaseException("本公司所属街道企业注册审核组没有配置人员，请联系街道管理员配置!");
			}
			//构建一个StringBuffer 存放下一审核人id
			for (UserGroup userGroup : list) {
				Integer userId = userGroup.getUser_id();
				sb.append(userId + ",");
			}
		}
		return sb.toString();
	}

	//更新临时状态为null
	public void updateTempporaryStateToNull(Integer id) {
		stockLandDao.updateTempporaryStateToNull(id);
		
	}

	//找出工业用地合规性审核组所有审核人
	public String findComplianceAuditUserIds(Integer apply_id) {
		String checkers="";
		Approval latestApproval = approvalService.getLatestApproval(apply_id,Constant.DictionaryType.STOCKLAND);
		Example example = new Example(Approval.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("type",Constant.DictionaryType.STOCKLAND);
        criteria.andEqualTo("apply_id",apply_id);
        criteria.andEqualTo("del_flag",false);
        if(null != latestApproval && null != latestApproval.getApproval_round()) {
            criteria.andEqualTo("approval_round",latestApproval.getApproval_round());
        }
        criteria.andNotEqualTo("before_approvalstatus", Constant.LandApproveStatus.COMPLIANCE_AUDIT);
        criteria.andEqualTo("after_approvalstatus", Constant.LandApproveStatus.COMPLIANCE_AUDIT);
        List<Approval> approvals = approvalService.selectByExample(example);
        if(null != approvals && approvals.size()>0) {
        	for(Approval appr : approvals) {
            	checkers += appr.getNextchecker();
        	}
        }
		return checkers;
	}

    public List<GovStatisticsDto> getApplyResult(SearchCondition searchCondition) {
		return stockLandDao.getApplyResult(searchCondition);
	}

	public List<GovStatisticsDto> getApplyRate(SearchCondition searchCondition) {
		return stockLandDao.getApplyRate(searchCondition);
	}

	public List<GovStatisticsDto> getStreetHandleCompare(SearchCondition searchCondition) {
		return stockLandDao.getStreetHandleCompare(searchCondition);
	}

	public void getApplyInfo(Integer id, ModelMap modelMap) {
		StockLand landApply = findLandApplyById(id);
		modelMap.put("landApply", landApply);
		List<ProcessNodeDto> processNodes = getProcessNodes(landApply, true);    //流程节点
		modelMap.put("processNodesList", processNodes);
		stockLandMaterialService.getApplyMaterials(landApply, modelMap);
//		modelMap.put("fileUrl", setFileUrl());
		//企业信息
		ProjectApplicationCompanyInfo companyInfo = projectApplicationCompanyInfoService.findByApplyIdAndType(id, Constant.DictionaryType.STOCKLAND);
		if (companyInfo == null) {
			Company company = companyService.getCompanyInfo(landApply.getCompany_id());
			if (Objects.equals(company.getIndustry_code(), "Empty")) {
				company.setIndustry_code(company.getIndustry_name());
			} else {
				company.setIndustry_code(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.INDUSTRY_TYPE, company.getIndustry_code()));
			}
			modelMap.put("companyInfo", company);
		} else {
			if (Objects.equals(companyInfo.getIndustry_code(), "Empty")) {
				companyInfo.setIndustry_code(companyInfo.getIndustry_name());
			} else {
				companyInfo.setIndustry_code(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.INDUSTRY_TYPE, companyInfo.getIndustry_code()));
			}
			modelMap.put("companyInfo", companyInfo);
		}

		//Integer companyId = landApply.getCompany_id();
		//modelMap.put("companyInfo", companyService.getCompanyInfo(companyId));//企业信息
		List<Approval> approvalList = approvalService.getApplyApprovalList(id);
		modelMap.put("approvalList", approvalList);    //流程信息
	}

    public List<StockLand> findListByCondition(SearchCondition searchCondition) {
		return stockLandDao.findListByCondition(searchCondition);
    }
}