meidu2021/daju/target/classes/cn/com/lzt/personnelbasearchivesmanage/controller/PersonnelInfoUploadController.java

package cn.com.lzt.personnelbasearchivesmanage.controller;
import cn.com.lzt.common.entity.WebUploadEntity;
import cn.com.lzt.dingding.service.DingdingService;
import cn.com.lzt.duties.entity.DutiesEntity;
import cn.com.lzt.leave.service.ModifyServiceI;
import cn.com.lzt.personnelbasearchivesmanage.dto.DepartDto;
import cn.com.lzt.personnelbasearchivesmanage.dto.PersonnelBaseArchivesManageInDto;
import cn.com.lzt.personnelbasearchivesmanage.dto.PersonnelBaseArchivesManageOutDto;
import cn.com.lzt.personnelbasearchivesmanage.dto.exportandimportdto.PersonnelBaseArchivesManageExportAndImportDto;
import cn.com.lzt.personnelbasearchivesmanage.dto.exportandimportdto.TSysFileDto;
import cn.com.lzt.personnelbasearchivesmanage.entity.PersonnelBaseArchivesManageEntity;
import cn.com.lzt.personnelbasearchivesmanage.service.PersonnelBaseArchivesManageExportAndImportServiceI;
import cn.com.lzt.personnelbasearchivesmanage.service.PersonnelBaseArchivesManageServiceI;
import cn.com.lzt.post.entity.PostEntity;
import cn.com.lzt.socialsecuritystrategy.entity.SocialSecurityStrategyEntity;
import cn.com.lzt.socialsecuritystrategy.service.SocialSecurityStrategyServiceI;
import cn.com.lzt.userchangeslog.entity.UserChangesLogEntity;
import cn.com.lzt.userchangeslog.service.UserChangesLogServiceI;
import cn.com.lzt.userwagestrategy.entity.UserWagestrategyEntity;
import cn.com.lzt.userwagestrategy.service.UserWagestrategyServiceI;
import com.alibaba.fastjson.JSONObject;
import com.dingtalk.open.client.api.model.corp.CorpUserDetail;
import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Workbook;
import org.jeecgframework.core.beanvalidator.BeanValidators;
import org.jeecgframework.core.common.controller.BaseController;
import org.jeecgframework.core.common.exception.BusinessException;
import org.jeecgframework.core.common.model.json.AjaxJson;
import org.jeecgframework.core.common.model.json.DataGrid;
import org.jeecgframework.core.constant.Globals;
import org.jeecgframework.core.util.*;
import org.jeecgframework.minidao.pojo.MiniDaoPage;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.vo.NormalExcelConstants;
import org.jeecgframework.tag.core.easyui.TagUtil;
import org.jeecgframework.web.system.pojo.base.*;
import org.jeecgframework.web.system.service.DepartServiceI;
import org.jeecgframework.web.system.service.SystemService;
import org.jeecgframework.web.system.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.util.UriComponentsBuilder;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.validation.ConstraintViolation;
import javax.validation.Validator;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**   
 * @Title: Controller  
 * @Description: 员工人事信息上传_内勤用
 * @author onlineGenerator
 * @date 2018-08-03 11:11:11
 * @version V2.0   
 *
 */
@Controller
@RequestMapping("/personnelInfoUploadController")
public class PersonnelInfoUploadController extends BaseController {
	/**
	 * Logger for this class
	 */
	private static final Logger logger = Logger.getLogger(PersonnelInfoUploadController.class);
	
	// 下载路径
	private static final String showAndDownUrl = ResourceUtil.getConfigByName("showAndDownUrl");

	@Autowired
	private PersonnelBaseArchivesManageServiceI personnelBaseArchivesManageService;
	@Autowired
	private UserService userService;
	@Autowired
	private SystemService systemService;
	@Autowired
	private Validator validator;
	
	@Autowired
	private PersonnelBaseArchivesManageExportAndImportServiceI personnelBaseArchivesManageExportAndImportService;
	@Autowired
	private DepartServiceI departService;
	@Autowired
	private DingdingService dingdingService;
	@Autowired
	private UserChangesLogServiceI userChangesLogService;
	@Autowired
	private UserWagestrategyServiceI userWagestrategyService;
	@Autowired
	private SocialSecurityStrategyServiceI socialSecurityStrategyService;
	@Autowired
	private ModifyServiceI modifyService;
	
	/**
	 * 员工人事信息表列表 页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "list")
	public ModelAndView list(HttpServletRequest request) {
		String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
		if (oConvertUtils.isNotEmpty(queryParams)) {
			JSONObject jsonObject =JSONObject.parseObject(queryParams);
			request.setAttribute("queryParams",jsonObject);
		}else {
			JSONObject jsonObject = new JSONObject(); 
			jsonObject.put("userName", "");
			jsonObject.put("departname", "");
			jsonObject.put("orgIds", "");
			jsonObject.put("telphone", "");
			jsonObject.put("idcard", "");
			jsonObject.put("positionStatus", "");
			jsonObject.put("certificateId", "");
			request.setAttribute("queryParams",jsonObject);
		}
		return new ModelAndView("cn/com/lzt/personnelInfoUpload/personnelInfoUploadList");
	}
	
	@RequestMapping(params = "listleave")
	public ModelAndView listleave(HttpServletRequest request) {
		String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
		if (oConvertUtils.isNotEmpty(queryParams)) {
			JSONObject jsonObject =JSONObject.parseObject(queryParams);
			request.setAttribute("queryParams",jsonObject);
		}else {
			JSONObject jsonObject = new JSONObject(); 
			jsonObject.put("userName", "");
			jsonObject.put("departname", "");
			jsonObject.put("orgIds", "");
			jsonObject.put("telphone", "");
			jsonObject.put("idcard", "");
			jsonObject.put("positionStatus", "");
			jsonObject.put("certificateId", "");
			request.setAttribute("queryParams",jsonObject);
		}
		return new ModelAndView("cn/com/lzt/personnelInfoUpload/personnelInfoUploadList-leave");
	}
	
	/**
	 * 项目使用, 过滤用户组织权限
	 * easyui AJAX请求数据
	 * 
	 * @param request
	 * @param response
	 * @param dataGrid
	 * @param user
	 */

	@RequestMapping(params = "program_datagrid")
	public void program_datagrid(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
//		CriteriaQuery cq = new CriteriaQuery(PersonnelBaseArchivesManageEntity.class, dataGrid);
//		//查询条件组装器
//		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, personnelBaseArchivesManage, request.getParameterMap());
//		try{
//		//自定义追加查询条件
//		}catch (Exception e) {
//			throw new BusinessException(e.getMessage());
//		}
//		cq.add();
//		this.personnelBaseArchivesManageService.getDataGridReturn(cq, true);
		
		String departIds = "";
		
		HttpSession session = ContextHolderUtils.getSession();
		TSUser tuser = (TSUser)session.getAttribute("LOCAL_CLINET_USER");
		List<TSUserOrg> jzList = systemService.findHql("from TSUserOrg where tsUser.id=? order by intime desc", tuser.getId());
		// 重新封装检索用的单位字符串
		departIds = "";
		if(jzList == null || jzList.isEmpty()) {
			departIds = "'Null'";
		}else {
			for(TSUserOrg org : jzList) {
				departIds += "'" + org.getTsDepart().getId() + "',";
				
				List<String> deps = departService.getDePartIdAndallSonDepartIds(org.getTsDepart().getId());
				if(deps != null && deps.size()>0) {
					for(String s : deps) {
						departIds += "'" + s + "',";
					}
				}
			}
			if(StringUtil.isNotEmpty(departIds)) {
				departIds = departIds.substring(0,departIds.length() - 1);
			}
		}
	
		
		inDto.setOrgIds(departIds);	
		
		// 获取请求对应的数据权限
		String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
		// 從SESSION中獲取用戶信息
		String sortorder = "";
		String sort = dataGrid.getSort(); // 排序对象
		String order = dataGrid.getOrder(); // 排序方式
		if (StringUtil.isEmpty(sort)) {
			sortorder = " orgId "; //默认userName,userId降序
		} else {
			sortorder = humpToLine(sort) + " " + order; // 处理下划线，拼接排序
		}
		MiniDaoPage<PersonnelBaseArchivesManageOutDto> list = personnelBaseArchivesManageService.getPersonnelBaseArchivesManageList(inDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);

		// list中去除null的废数据
		for(int i = list.getResults().size()-1; i >=0; i--) {
			PersonnelBaseArchivesManageOutDto personnelBaseArchivesManageOutDto = list.getResults().get(i);
			
			// 滤除重复的兼职机构
			Map<String, String> jzMap = new HashMap<String, String>();
			String jzorgIds = personnelBaseArchivesManageOutDto.getJzorgId();
			if(jzorgIds != null && !"".equals(jzorgIds)){
				String[] jzorgIdArr = jzorgIds.split(",");
				for(String jzorgId : jzorgIdArr){
					jzMap.put(jzorgId, jzorgId);
				}
				String ids_processed = "";
				for(String jzorgId : jzMap.values()){
					if("".equals(ids_processed)){
						ids_processed = modifyService.getByorgId(jzorgId);
					}else{
						ids_processed = ids_processed + "," + modifyService.getByorgId(jzorgId);
					}
				}
				list.getResults().get(i).setJzorgId(ids_processed);
			}
			
			// 滤除重复的证书
			Map<String, String> certMap = new HashMap<String, String>();
			String certificateNames = personnelBaseArchivesManageOutDto.getCertificateName();
			if(certificateNames != null && !"".equals(certificateNames)){
				String[] certificateNameArr = certificateNames.split(",");
				for(String certName : certificateNameArr){
					certMap.put(certName, certName);
				}
				String certName_processed = "";
				for(String certName : certMap.values()){
					if("".equals(certName_processed)){
						certName_processed = certName;
					}else{
						certName_processed = certName_processed + "," + certName;
					}
				}
				list.getResults().get(i).setCertificateName(certName_processed);
			}
			
			// 设置组织机构
			String orgId = list.getResults().get(i).getOrgId();
			orgId = modifyService.getByorgId(orgId);
			list.getResults().get(i).setOrgId(orgId);
			if(StringUtil.isEmpty(personnelBaseArchivesManageOutDto.getId())) {
				list.getResults().remove(i);
			}
			
			String positionStatus =list.getResults().get(i).getPositionStatus();
			if(Globals.JOBSTATUS_3.equals(positionStatus) || Globals.JOBSTATUS_4.equals(positionStatus)) {
				list.getResults().remove(i);
			}
		
		}
		
		dataGrid.setTotal(list.getTotal());
		dataGrid.setResults(list.getResults());
		TagUtil.datagrid(response, dataGrid);
	}
	
	/**
	 * 项目使用, 过滤用户组织权限
	 * easyui AJAX请求数据
	 * 
	 * @param request
	 * @param response
	 * @param dataGrid
	 * @param user
	 */

	@RequestMapping(params = "program_leave_datagrid")
	public void program_leave_datagrid(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
//		CriteriaQuery cq = new CriteriaQuery(PersonnelBaseArchivesManageEntity.class, dataGrid);
//		//查询条件组装器
//		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, personnelBaseArchivesManage, request.getParameterMap());
//		try{
//		//自定义追加查询条件
//		}catch (Exception e) {
//			throw new BusinessException(e.getMessage());
//		}
//		cq.add();
//		this.personnelBaseArchivesManageService.getDataGridReturn(cq, true);
		
		String departIds = "";
		
		HttpSession session = ContextHolderUtils.getSession();
		TSUser tuser = (TSUser)session.getAttribute("LOCAL_CLINET_USER");
		List<TSUserOrg> jzList = systemService.findHql("from TSUserOrg where tsUser.id=? order by intime desc", tuser.getId());
		// 重新封装检索用的单位字符串
		departIds = "";
		if(jzList == null || jzList.isEmpty()) {
			departIds = "'Null'";
		}else {
			for(TSUserOrg org : jzList) {
				departIds += "'" + org.getTsDepart().getId() + "',";
				
				List<String> deps = departService.getDePartIdAndallSonDepartIds(org.getTsDepart().getId());
				if(deps != null && deps.size()>0) {
					for(String s : deps) {
						departIds += "'" + s + "',";
					}
				}
			}
			if(StringUtil.isNotEmpty(departIds)) {
				departIds = departIds.substring(0,departIds.length() - 1);
			}
		}
	
		
		inDto.setOrgIds(departIds);	
		
		// 获取请求对应的数据权限
		String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
		// 從SESSION中獲取用戶信息
		String sortorder = "";
		String sort = dataGrid.getSort(); // 排序对象
		String order = dataGrid.getOrder(); // 排序方式
		if (StringUtil.isEmpty(sort)) {
			sortorder = " orgId "; //默认userName,userId降序
		} else {
			sortorder = humpToLine(sort) + " " + order; // 处理下划线，拼接排序
		}
		MiniDaoPage<PersonnelBaseArchivesManageOutDto> list = personnelBaseArchivesManageService.getPersonnelBaseArchivesManageListLeave(inDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);

		// list中去除null的废数据
		for(int i = list.getResults().size()-1; i >=0; i--) {
			PersonnelBaseArchivesManageOutDto personnelBaseArchivesManageOutDto = list.getResults().get(i);
			
			// 滤除重复的兼职机构
			Map<String, String> jzMap = new HashMap<String, String>();
			String jzorgIds = personnelBaseArchivesManageOutDto.getJzorgId();
			if(jzorgIds != null && !"".equals(jzorgIds)){
				String[] jzorgIdArr = jzorgIds.split(",");
				for(String jzorgId : jzorgIdArr){
					jzMap.put(jzorgId, jzorgId);
				}
				String ids_processed = "";
				for(String jzorgId : jzMap.values()){
					if("".equals(ids_processed)){
						ids_processed = modifyService.getByorgId(jzorgId);
					}else{
						ids_processed = ids_processed + "," + modifyService.getByorgId(jzorgId);
					}
				}
				list.getResults().get(i).setJzorgId(ids_processed);
			}
			
			// 滤除重复的证书
			Map<String, String> certMap = new HashMap<String, String>();
			String certificateNames = personnelBaseArchivesManageOutDto.getCertificateName();
			if(certificateNames != null && !"".equals(certificateNames)){
				String[] certificateNameArr = certificateNames.split(",");
				for(String certName : certificateNameArr){
					certMap.put(certName, certName);
				}
				String certName_processed = "";
				for(String certName : certMap.values()){
					if("".equals(certName_processed)){
						certName_processed = certName;
					}else{
						certName_processed = certName_processed + "," + certName;
					}
				}
				list.getResults().get(i).setCertificateName(certName_processed);
			}
			
			// 设置组织机构
			String orgId = list.getResults().get(i).getOrgId();
			orgId = modifyService.getByorgId(orgId);
			list.getResults().get(i).setOrgId(orgId);
			if(StringUtil.isEmpty(personnelBaseArchivesManageOutDto.getId())) {
				list.getResults().remove(i);
			}
			
			String positionStatus =list.getResults().get(i).getPositionStatus();
			if(!Globals.JOBSTATUS_3.equals(positionStatus) && !Globals.JOBSTATUS_4.equals(positionStatus)) {
				list.getResults().remove(i);
			}
		
		}
		
		dataGrid.setTotal(list.getTotal());
		dataGrid.setResults(list.getResults());
		TagUtil.datagrid(response, dataGrid);
	}

	/**
	 * 人事部门使用, 不过滤用户组织权限
	 * easyui AJAX请求数据
	 * 
	 * @param request
	 * @param response
	 * @param dataGrid
	 * @param user
	 */

	@RequestMapping(params = "datagrid")
	public void datagrid(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
//		CriteriaQuery cq = new CriteriaQuery(PersonnelBaseArchivesManageEntity.class, dataGrid);
//		//查询条件组装器
//		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, personnelBaseArchivesManage, request.getParameterMap());
//		try{
//		//自定义追加查询条件
//		}catch (Exception e) {
//			throw new BusinessException(e.getMessage());
//		}
//		cq.add();
//		this.personnelBaseArchivesManageService.getDataGridReturn(cq, true);
		
		String departIds = "";
		
//		HttpSession session = ContextHolderUtils.getSession();
//		TSUser tuser = (TSUser)session.getAttribute("LOCAL_CLINET_USER");
//		departIds = tuser.getDepartid();
		if (null != inDto.getOrgIds() && StringUtil.isNotEmpty(inDto.getOrgIds())) {
			departIds = inDto.getOrgIds();
		}
		// 页面的单位ID
		List<String> departIdByPageList = Arrays.asList(departIds.split(","));
		// 用于检索的单位ID
		List<String> departIdBySearchList = new ArrayList<String>();
		for(String str : departIdByPageList) {
			if(StringUtil.isNotEmpty(str)) {
				departIdBySearchList.add(str);
				List<DepartDto> departDtoList = personnelBaseArchivesManageService.getAllChildrenList(str, null, null);
				for(DepartDto departDto : departDtoList) {
					departIdBySearchList.add(departDto.getId());
				}
			}
		}
		
		// List去重复
		HashSet<String> h = new HashSet<String>(departIdBySearchList); 
		departIdBySearchList.clear(); 
		departIdBySearchList.addAll(h);
		
		// 重新封装检索用的单位字符串
		departIds = "";
		for(String str : departIdBySearchList) {
			departIds += "'" + str + "',";
		}
		if(StringUtil.isNotEmpty(departIds)) {
			departIds = departIds.substring(0,departIds.length() - 1);
		}
		inDto.setOrgIds(departIds);	
		
		// 获取请求对应的数据权限
		String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
		// 從SESSION中獲取用戶信息
		String sortorder = "";
		String sort = dataGrid.getSort(); // 排序对象
		String order = dataGrid.getOrder(); // 排序方式
		if (StringUtil.isEmpty(sort)) {
			sortorder = "orgId"; //默认userName,userId降序
		} else {
			sortorder = humpToLine(sort) + " " + order; // 处理下划线，拼接排序
		}
		MiniDaoPage<PersonnelBaseArchivesManageOutDto> list = personnelBaseArchivesManageService.getPersonnelBaseArchivesManageList(inDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);

		// list中去除null的废数据
		for(int i = list.getResults().size()-1; i >=0; i--) {
			PersonnelBaseArchivesManageOutDto personnelBaseArchivesManageOutDto = list.getResults().get(i);
			
			// 滤除重复的兼职机构
			Map<String, String> jzMap = new HashMap<String, String>();
			String jzorgIds = personnelBaseArchivesManageOutDto.getJzorgId();
			if(jzorgIds != null && !"".equals(jzorgIds)){
				String[] jzorgIdArr = jzorgIds.split(",");
				for(String jzorgId : jzorgIdArr){
					jzMap.put(jzorgId, jzorgId);
				}
				String ids_processed = "";
				for(String jzorgId : jzMap.values()){
					if("".equals(ids_processed)){
						ids_processed = modifyService.getByorgId(jzorgId);
					}else{
						ids_processed = ids_processed + "," + modifyService.getByorgId(jzorgId);
					}
				}
				list.getResults().get(i).setJzorgId(ids_processed);
			}
			
			// 滤除重复的证书
			Map<String, String> certMap = new HashMap<String, String>();
			String certificateNames = personnelBaseArchivesManageOutDto.getCertificateName();
			if(certificateNames != null && !"".equals(certificateNames)){
				String[] certificateNameArr = certificateNames.split(",");
				for(String certName : certificateNameArr){
					certMap.put(certName, certName);
				}
				String certName_processed = "";
				for(String certName : certMap.values()){
					if("".equals(certName_processed)){
						certName_processed = certName;
					}else{
						certName_processed = certName_processed + "," + certName;
					}
				}
				list.getResults().get(i).setCertificateName(certName_processed);
			}
			
			String userType = list.getResults().get(i).getUserType();
			if(Globals.userType_0.equals(userType)) {
				list.getResults().remove(i);
			}else if(StringUtil.isEmpty(personnelBaseArchivesManageOutDto.getId())) {
				list.getResults().remove(i);
			}
			
			// 设置组织机构
			String orgId = list.getResults().get(i).getOrgId();
			orgId = modifyService.getByorgId(orgId);
			list.getResults().get(i).setOrgId(orgId);
		}
		
		dataGrid.setTotal(list.getTotal());
		dataGrid.setResults(list.getResults());
		TagUtil.datagrid(response, dataGrid);
	}
	
	/**
	 * 驼峰转下划线
	 * 
	 * @param str需要转换的字符串
	 * @return
	 */
	private String humpToLine(String str) {
		Pattern humpPattern = Pattern.compile("[A-Z]");
		Matcher matcher = humpPattern.matcher(str);
		StringBuffer sb = new StringBuffer();
		while (matcher.find()) {
			matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
		}
		matcher.appendTail(sb);
		return sb.toString();
	}
	
	
	/**
	 * 新增TAB 页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "goAddTab")
	public ModelAndView goAddTab(String id, HttpServletRequest request) {
		request.setAttribute("id", id);
		String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
		if (oConvertUtils.isNotEmpty(queryParams)) {
			request.setAttribute("queryParams",queryParams);
		}
		return new ModelAndView("cn/com/lzt/personnelInfoUpload/neiqin_personelInfoUpload-add-tab");
	}
	/**
	 * 编辑TAB 页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "goUpdateTab")
	public ModelAndView goUpdateTab(String id, HttpServletRequest request) {
		request.setAttribute("id", id);
		String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
		if (oConvertUtils.isNotEmpty(queryParams)) {
			request.setAttribute("queryParams",queryParams);
		}
		return new ModelAndView("cn/com/lzt/personnelInfoUpload/personnelInfoUpload-update-tab");
	}
	
	/**
	 * 编辑基本信息 页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "goUpdateBase")
	public ModelAndView goUpdateBase(String userId, HttpServletRequest request) {
		if (StringUtil.isNotEmpty(userId)) {
			TSUser userInfo = userService.get(TSUser.class, userId);
			request.setAttribute("userInfo", userInfo);
			this.idandname(request, userInfo);
			this.getOrgInfos(request, userInfo);
			this.getJzOrgInfos(request, userInfo);
		}
		return new ModelAndView("cn/com/lzt/personnelInfoUpload/userInfo-base-update");
	}
	
	
	/**
	 * 编辑证书信息 页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "goUpdateCertificate")
	public ModelAndView goUpdateCertificate(String id, HttpServletRequest request) {
		return new ModelAndView("cn/com/lzt/personnelInfoUpload/personnelBaseArchivesManage-add");
	}
	
	/**
	 * 编辑人事合同信息 页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "goUpdateHetong")
	public ModelAndView goUpdateHetong(String userId, HttpServletRequest request) {
		String personnelHql = "from PersonnelBaseArchivesManageEntity where userid=? ";
		// 职务名
		String dutiesName= "";
		// 岗位名
		String postName = "";
		List<PersonnelBaseArchivesManageEntity> personnelBaseArchivesManageEntityList = personnelBaseArchivesManageService.findHql(personnelHql, userId);
		PersonnelBaseArchivesManageEntity personnelBaseArchivesManageEntity	= new PersonnelBaseArchivesManageEntity();
		if(personnelBaseArchivesManageEntityList.size() > 0) {
			personnelBaseArchivesManageEntity = personnelBaseArchivesManageEntityList.get(0);
			if(StringUtil.isNotEmpty(personnelBaseArchivesManageEntity.getBelongDutiesid())) {
				DutiesEntity dutiesEntity = systemService.getEntity(DutiesEntity.class, personnelBaseArchivesManageEntity.getBelongDutiesid());
				dutiesName = dutiesEntity.getDutiesName();
			}
			if(StringUtil.isNotEmpty(personnelBaseArchivesManageEntity.getInPostid())) {
				PostEntity postEntity = systemService.getEntity(PostEntity.class, personnelBaseArchivesManageEntity.getInPostid());
				postName = postEntity.getPostName();
			}
		} else {
			personnelBaseArchivesManageEntity.setUserid(userId);
		}

		// 查询主组织
		StringBuilder mainOrgSql = new StringBuilder();
		mainOrgSql.append(" SELECT ");
		mainOrgSql.append(" depart.departname departname");
		mainOrgSql.append(" FROM t_s_user_org userOrg ");
		mainOrgSql.append(" LEFT JOIN t_s_depart depart ON userOrg.org_id = depart.id ");
		mainOrgSql.append(" WHERE ");
		mainOrgSql.append(" userOrg.user_id = '" + userId + "'");
		mainOrgSql.append(" AND userOrg.status = '0' ");
		mainOrgSql.append(" AND userOrg.ifpluralism <> '1' ");
		List<Map<String, Object>> mainOrgMapList = systemService.findForJdbc(mainOrgSql.toString());

		// 查询兼职组织
		StringBuilder parttimeOrgSql = new StringBuilder();
		parttimeOrgSql.append(" SELECT ");
		parttimeOrgSql.append(" depart.departname departname");
		parttimeOrgSql.append(" FROM t_s_user_org userOrg ");
		parttimeOrgSql.append(" LEFT JOIN t_s_depart depart ON userOrg.org_id = depart.id ");
		parttimeOrgSql.append(" WHERE ");
		parttimeOrgSql.append(" userOrg.user_id = '" + userId + "'");
		parttimeOrgSql.append(" AND userOrg.status = '0' ");
		parttimeOrgSql.append(" AND userOrg.ifpluralism = '1' ");
		List<Map<String, Object>> parttimeOrgMapList = systemService.findForJdbc(parttimeOrgSql.toString());
		
		// 单位名称
		String mainOrg = "";
		// 兼职单位名
		String parttimeOrg = "";
		
		if(mainOrgMapList.size() > 0) {
			mainOrg = (String)mainOrgMapList.get(0).get("departname");
		}
		
		if(parttimeOrgMapList.size() > 0) {
			for(Map<String, Object> orgStr : parttimeOrgMapList) {
				parttimeOrg += (String)orgStr.get("departname") + ",";
			}
			parttimeOrg = parttimeOrg.substring(0,parttimeOrg.length() - 1);
		}
		
		request.setAttribute("personnelInfo", personnelBaseArchivesManageEntity);
		request.setAttribute("mainOrg", mainOrg);
		request.setAttribute("parttimeOrg", parttimeOrg);
		request.setAttribute("dutiesName", dutiesName);
		request.setAttribute("postName", postName);
		
		return new ModelAndView("cn/com/lzt/personnelInfoUpload/renshi-hetong-update");
	}
	
	/**
	 * 编辑人员照片 页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "goUpdatePhoto")
	public ModelAndView goUpdatePhoto(String userId, HttpServletRequest request) {
		
		// 用户照片有无Flg
		String photoFlg = "0";
		String photoUrl = "";
		
		StringBuilder mainOrgSql = new StringBuilder();
		mainOrgSql.append(" SELECT ");
		mainOrgSql.append(" file_url ");
		mainOrgSql.append(" FROM t_sys_file ");
		mainOrgSql.append(" WHERE ");
		mainOrgSql.append(" busi_table = 't_s_base_user' ");
		mainOrgSql.append(" AND taget_type = 'userPhoto' ");
		mainOrgSql.append(" AND busi_id = '" + userId +"' ");
		List<Map<String, Object>> userPhotoMapList = systemService.findForJdbc(mainOrgSql.toString());
		
		if(userPhotoMapList.size() > 0) {
			photoFlg = "1";
			photoUrl = (String) userPhotoMapList.get(0).get("file_url");
		}
		request.setAttribute("userId", userId);
		request.setAttribute("photoFlg", photoFlg);
		request.setAttribute("photoUrl", photoUrl);
		
		request.setAttribute("showAndDownUrl", showAndDownUrl);
		return new ModelAndView("cn/com/lzt/personnelInfoUpload/userPhoto");
	}
	
	/**
	 * 编辑附件 页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "goAccessory")
	public ModelAndView goAccessory(String userId, HttpServletRequest request) {
		
		return new ModelAndView("cn/com/lzt/personnelInfoUpload/userAccessory");
	}
	
	
	
	/**
	 * 保存新增/更新人事数据
	 * 
	 * @return
	 */
	@RequestMapping(params = "savePersonnelData")
	@ResponseBody
	public AjaxJson savePersonnelData(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request){
		String message = "";
		AjaxJson j = new AjaxJson();
		// 根据userId判断用户是否已经维护了员工人事信息表
		String personnelBaseArchivesManageByUserIdHql = "from PersonnelBaseArchivesManageEntity where userid = ?";
		List<PersonnelBaseArchivesManageEntity> personnelBaseArchivesManageEntityList = personnelBaseArchivesManageService.findHql(personnelBaseArchivesManageByUserIdHql, personnelBaseArchivesManage.getUserid());
		if(personnelBaseArchivesManageEntityList.size() > 0) {
			PersonnelBaseArchivesManageEntity personInDB = personnelBaseArchivesManageEntityList.get(0);
			if(personInDB.getBelongDutiesid() != null && !personInDB.getBelongDutiesid().equals(personnelBaseArchivesManage.getBelongDutiesid())) {
				j.setSuccess(false);
				j.setMsg("没有【职务变动】的权限，请联系人力资源部");
				return j;
			}
			personnelBaseArchivesManage.setId(personInDB.getId());
		}
		
		if (StringUtil.isNotEmpty(personnelBaseArchivesManage.getId())) {
			PersonnelBaseArchivesManageEntity t = personnelBaseArchivesManageService.get(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
			try {
				// 默认项目录入的员工都是一线员工
				personnelBaseArchivesManage.setManagerType(Globals.MANAGETYPE_2);
				personnelBaseArchivesManage.setIfremind(Globals.SHIFOU_01_1);
				personnelBaseArchivesManage.setAutoCorrection(Globals.SHIFOU_01_1);
				personnelBaseArchivesManage.setPositionStatus(Globals.JOBSTATUS_1);
				// 维护员工人事变动表数据
				if(Globals.JOBSTATUS_1.equals(personnelBaseArchivesManage.getPositionStatus()) && !Globals.JOBSTATUS_1.equals(t.getPositionStatus())
						|| Globals.JOBSTATUS_2.equals(personnelBaseArchivesManage.getPositionStatus()) && !Globals.JOBSTATUS_2.equals(t.getPositionStatus())) {
					this.saveUserChangesLog(personnelBaseArchivesManage.getUserid(), personnelBaseArchivesManage.getIfpayment(), personnelBaseArchivesManage.getPositionStatus());
				}
				// 试用期为【无】时，转正日期=合同开始日期
				if(Globals.SHIYONGQI_0.equals(personnelBaseArchivesManage.getTrialPeriod().toString())) {
					t.setCorrectionDate(personnelBaseArchivesManage.getContractStime());
				}
				if(personnelBaseArchivesManage.getBelongDutiesid() != null && !personnelBaseArchivesManage.getBelongDutiesid().equals(t.getBelongDutiesid())) {
					resetDutyAndPost(personnelBaseArchivesManage);
				}
				
				MyBeanUtils.copyBeanNotNull2Bean(personnelBaseArchivesManage, t);
			
				personnelBaseArchivesManageService.saveOrUpdate(t);
				message = "员工人事信息更新成功";
				j.setSuccess(true);
				systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
			} catch (Exception e) {
				e.printStackTrace();
				message = "员工人事信息更新失败";
				j.setSuccess(false);
				throw new BusinessException(e.getMessage());
			}
		} else {
			try{
				// 默认项目录入的员工都是一线员工
				personnelBaseArchivesManage.setManagerType(Globals.MANAGETYPE_2);
				personnelBaseArchivesManage.setIfremind(Globals.SHIFOU_01_1);
				personnelBaseArchivesManage.setAutoCorrection(Globals.SHIFOU_01_1);
				personnelBaseArchivesManage.setPositionStatus(Globals.JOBSTATUS_1);
				// 维护员工人事变动表数据
				if(Globals.JOBSTATUS_1.equals(personnelBaseArchivesManage.getPositionStatus())
						|| Globals.JOBSTATUS_2.equals(personnelBaseArchivesManage.getPositionStatus())) {
					this.saveUserChangesLog(personnelBaseArchivesManage.getUserid(), personnelBaseArchivesManage.getIfpayment(), personnelBaseArchivesManage.getPositionStatus());
				}
				// 试用期为【无】时，转正日期=合同开始日期
				if(Globals.SHIYONGQI_0.equals(personnelBaseArchivesManage.getTrialPeriod().toString())) {
					personnelBaseArchivesManage.setCorrectionDate(personnelBaseArchivesManage.getContractStime());
				}
				if(personnelBaseArchivesManage.getBelongDutiesid() != null) {
					resetDutyAndPost(personnelBaseArchivesManage);
				}
				
				personnelBaseArchivesManageService.save(personnelBaseArchivesManage);
				message = "员工人事信息添加成功";
				j.setSuccess(true);
				systemService.addLog(message, Globals.Log_Type_INSERT, Globals.Log_Leavel_INFO);
			}catch(Exception e){
				e.printStackTrace();
				message = "员工人事信息添加失败";
				j.setSuccess(false);
				throw new BusinessException(e.getMessage());
			}
		}
		j.setMsg(message);
		return j;
	}
	
	
	/**
	 * @param personnelBaseArchivesManage
	 */
	private void resetDutyAndPost(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage) {
		String duty_id = personnelBaseArchivesManage.getBelongDutiesid();
		if(duty_id == null) {
			return;
		}
		
		DutiesEntity dutiesEntity = systemService.getEntity(DutiesEntity.class, duty_id);
		if(dutiesEntity != null) {
			personnelBaseArchivesManage.setInPostid(dutiesEntity.getPost());
			personnelBaseArchivesManage.setManagerType(dutiesEntity.getManageType());
		}
	}

	/**
	 * 保存员工基本信息数据
	 * 
	 * @return
	 */
/*	@RequestMapping(params = "saveUserData")
	@ResponseBody
	public AjaxJson saveUserData(TSUser userInfo, HttpServletRequest request){
		String message = "";
		AjaxJson j = new AjaxJson();
		TSUser t = userService.get(TSUser.class, userInfo.getId());
		try {
			MyBeanUtils.copyBeanNotNull2Bean(userInfo, t);
			userService.saveOrUpdate(t);
			message = "员工基本信息更新成功";
			systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
		} catch (Exception e) {
			e.printStackTrace();
			message = "员工基本信息更新失败";
			throw new BusinessException(e.getMessage());
		}
		j.setMsg(message);
		return j;
	}*/
	
	
	/**
	 * 逻辑删除用户
	 * @author zhijia.wang
	 * 2017-12-27 pm
	 * @param wagestrategy
	 * @param request
	 * @return
	 */
	@RequestMapping(params = "logicDel")
	@ResponseBody
	public AjaxJson logicDel(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request) {
		String message = null;
		AjaxJson j = new AjaxJson();
		if("admin".equals(personnelBaseArchivesManage.getUserid())){
			message = "超级管理员[admin]不可删除";
			j.setSuccess(false);
			j.setMsg(message);
			return j;
		}
		TSUser user = systemService.getEntity(TSUser.class, personnelBaseArchivesManage.getId());
		try{
			if (!Globals.User_ADMIN.equals(user.getStatus())) {
				user.setDeleteFlag(Globals.Delete_Forbidden);
				// 逻辑删除用户，并把删除状态设置到Redis
				userService.logicDelAndPutRedis(user);
				message = "用户：" + user.getUserName() + "删除成功";
				systemService.addLog(message, Globals.Log_Type_DEL, Globals.Log_Leavel_INFO);
				logger.info("[" + IpUtil.getIpAddr(request) + "][逻辑删除用户]" + message);
				j.setSuccess(true);
			} else {
				message = "超级管理员不可删除";
				j.setSuccess(false);
			}
		}catch(Exception e){
			e.printStackTrace();
			message = "参数异常,用户删除失败,请重试.";
			j.setSuccess(false);
			throw new BusinessException(e.getMessage());
		}
		j.setMsg(message);
		return j;
	}
	
	
	
	/**
	 * 删除员工人事信息表
	 * 
	 * @return
	 */
	@RequestMapping(params = "doDel")
	@ResponseBody
	public AjaxJson doDel(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request) {
		String message = null;
		AjaxJson j = new AjaxJson();
		personnelBaseArchivesManage = systemService.getEntity(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
		message = "员工人事信息表删除成功";
		try{
			personnelBaseArchivesManageService.delete(personnelBaseArchivesManage);
			systemService.addLog(message, Globals.Log_Type_DEL, Globals.Log_Leavel_INFO);
		}catch(Exception e){
			e.printStackTrace();
			message = "员工人事信息表删除失败";
			throw new BusinessException(e.getMessage());
		}
		j.setMsg(message);
		return j;
	}
	
	/**
	 * 批量删除员工人事信息表
	 * 
	 * @return
	 */
	 @RequestMapping(params = "doBatchDel")
	@ResponseBody
	public AjaxJson doBatchDel(String ids,HttpServletRequest request){
		String message = null;
		AjaxJson j = new AjaxJson();
		message = "员工人事信息表删除成功";
		try{
			for(String id:ids.split(",")){
				PersonnelBaseArchivesManageEntity personnelBaseArchivesManage = systemService.getEntity(PersonnelBaseArchivesManageEntity.class, 
				id
				);
				personnelBaseArchivesManageService.delete(personnelBaseArchivesManage);
				systemService.addLog(message, Globals.Log_Type_DEL, Globals.Log_Leavel_INFO);
			}
		}catch(Exception e){
			e.printStackTrace();
			message = "员工人事信息表删除失败";
			throw new BusinessException(e.getMessage());
		}
		j.setMsg(message);
		return j;
	}


	/**
	 * 添加员工人事信息表
	 * 
	 * @param ids
	 * @return
	 */
	@RequestMapping(params = "doAdd")
	@ResponseBody
	public AjaxJson doAdd(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request) {
		String message = null;
		AjaxJson j = new AjaxJson();
		message = "员工人事信息表添加成功";
		try{
			personnelBaseArchivesManageService.save(personnelBaseArchivesManage);
			systemService.addLog(message, Globals.Log_Type_INSERT, Globals.Log_Leavel_INFO);
		}catch(Exception e){
			e.printStackTrace();
			message = "员工人事信息表添加失败";
			throw new BusinessException(e.getMessage());
		}
		j.setMsg(message);
		return j;
	}
	
	/**
	 * 更新员工人事信息表
	 * 
	 * @param ids
	 * @return
	 */
	@RequestMapping(params = "doUpdate")
	@ResponseBody
	public AjaxJson doUpdate(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request) {
		String message = null;
		AjaxJson j = new AjaxJson();
		message = "员工人事信息表更新成功";
		PersonnelBaseArchivesManageEntity t = personnelBaseArchivesManageService.get(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
		try {
			MyBeanUtils.copyBeanNotNull2Bean(personnelBaseArchivesManage, t);
			personnelBaseArchivesManageService.saveOrUpdate(t);
			systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
		} catch (Exception e) {
			e.printStackTrace();
			message = "员工人事信息表更新失败";
			throw new BusinessException(e.getMessage());
		}
		j.setMsg(message);
		return j;
	}
	

	/**
	 * 员工人事信息表新增页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "goAdd")
	public ModelAndView goAdd(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest req) {
		if (StringUtil.isNotEmpty(personnelBaseArchivesManage.getId())) {
			personnelBaseArchivesManage = personnelBaseArchivesManageService.getEntity(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
			req.setAttribute("personnelBaseArchivesManagePage", personnelBaseArchivesManage);
		}
		return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManage-add");
	}
//	/**
//	 * 员工人事信息表编辑页面跳转
//	 * 
//	 * @return
//	 */
//	@RequestMapping(params = "goUpdateHetong")
//	public ModelAndView goUpdateHetong(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest req) {
//		if (StringUtil.isNotEmpty(personnelBaseArchivesManage.getId())) {
//			personnelBaseArchivesManage = personnelBaseArchivesManageService.getEntity(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
//			req.setAttribute("personnelBaseArchivesManagePage", personnelBaseArchivesManage);
//		}
//		return new ModelAndView("cn/com/lzt/personnelInfoUpload/renshi-hetong-update");
//	}
	
	/**
	 * 导入功能跳转
	 * 
	 * @return
	 */
	/*@RequestMapping(params = "upload")
	public ModelAndView upload(HttpServletRequest req) {
		req.setAttribute("controller_name","personnelBaseArchivesManageController");
		return new ModelAndView("common/upload/pub_excel_upload");
	}*/
	
	/**
	 * 导入功能跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "upload")
	public ModelAndView uploadTest(HttpServletRequest req) {
		req.setAttribute("controller_name","personnelBaseArchivesManageController");
		return new ModelAndView("common/upload/uploadzbw/excel_upload");
	}
	
	/**
	 * 导出excel
	 * 
	 * @param request
	 * @param response
	 */
	@RequestMapping(params = "exportXls")
	public void exportXls(PersonnelBaseArchivesManageInDto personnelBaseArchivesManageInDto,HttpServletRequest request,HttpServletResponse response
			, DataGrid dataGrid,ModelMap modelMap) {
		
		
		/*//标题   该list中用于存储标题的信息，每一个ExcelExportEntity 表示一列，根据List 的入栈顺序，由左至右，一次排序
        List<ExcelExportEntity> entityList = new ArrayList<ExcelExportEntity>();  
		ExcelExportEntity head1=new ExcelExportEntity("项目名称", "pid", 15);
		entityList.add(head1); 
		ExcelExportEntity head2=new ExcelExportEntity("岗位分配", "overallSituation", 15);
		entityList.add(head2); 
		ExcelExportEntity head3=new ExcelExportEntity("分配人", "setterId", 15);
		entityList.add(head3);
		
		//组建数据集
        List<Map<String,Object>> dataResult = new ArrayList<Map<String,Object>>();  
        List<ProjectPostGeneralEntity> projectPostGeneralEntityList=new ArrayList<ProjectPostGeneralEntity>();
        
        StringBuffer hql = new StringBuffer(" from ProjectPostGeneralEntity t where 1=1 and t.deleteFlag = '0' ");
        if(projectPostGeneral.getPid()!=null&&projectPostGeneral.getPid().length()>0){
        	hql.append(" and t.pid = ? ");
        	projectPostGeneralEntityList = projectPostGeneralService.findHql(hql.toString(),projectPostGeneral.getPid());
        }else{
        	projectPostGeneralEntityList = projectPostGeneralService.findHql(hql.toString());
        }
        
        for (int i = 0; i < projectPostGeneralEntityList.size(); i++) {
        	Map<String, Object> map = new HashMap<String, Object>();  
			map.put("pid", departMap.get(projectPostGeneralEntityList.get(i).getPid()));
			map.put("overallSituation", projectPostGeneralEntityList.get(i).getOverallSituation());
			map.put("setterId", baseUserMap.get(projectPostGeneralEntityList.get(i).getSetterId()));
			dataResult.add(map);  
		}
		
		modelMap.put(MapExcelConstants.ENTITY_LIST, entityList);  
        modelMap.put(MapExcelConstants.MAP_LIST, dataResult);
        modelMap.put(NormalExcelConstants.FILE_NAME,"员工人事信息");
        modelMap.put(NormalExcelConstants.PARAMS,new ExportParams("员工人事信息列表", "导出人:"+ResourceUtil.getSessionUser().getRealName(),
    			"导出信息"));
        return MapExcelConstants.JEECG_MAP_EXCEL_VIEW;*/
		
		/*try {
			PersonnelBaseArchivesManageExportAndImportService.exportXls(personnelBaseArchivesManageInDto);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		PersonnelBaseArchivesManageEntity personnelBaseArchivesManage=new PersonnelBaseArchivesManageEntity();
		CriteriaQuery cq = new CriteriaQuery(PersonnelBaseArchivesManageEntity.class, dataGrid);
		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, personnelBaseArchivesManage, request.getParameterMap());
		List<PersonnelBaseArchivesManageEntity> personnelBaseArchivesManages = this.personnelBaseArchivesManageService.getListByCriteriaQuery(cq,false);
		modelMap.put(NormalExcelConstants.FILE_NAME,"员工人事信息表");
		modelMap.put(NormalExcelConstants.CLASS,PersonnelBaseArchivesManageEntity.class);
		modelMap.put(NormalExcelConstants.PARAMS,new ExportParams("员工人事信息表列表", "导出人:"+ResourceUtil.getSessionUser().getRealName(),
			"导出信息"));
		modelMap.put(NormalExcelConstants.DATA_LIST,personnelBaseArchivesManages);
		return NormalExcelConstants.JEECG_EXCEL_VIEW;*/
		
//		String codedFileName = "临时文件"+System.currentTimeMillis();
		String codedFileName = "员工基本档案列表";
		List<Map<String, Object>> modelMapList = null;
		try {
			modelMapList = personnelBaseArchivesManageExportAndImportService.exportXls(personnelBaseArchivesManageInDto);
		} catch (Exception e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		Workbook workbook = personnelBaseArchivesManageExportAndImportService.getWorkBook(modelMapList);
		 
		if (workbook instanceof HSSFWorkbook) {
			codedFileName +=".xls";
		} else {
			codedFileName +=".xlsx";
		}
		try {
		if (personnelBaseArchivesManageExportAndImportService.isIE(request)) {
				codedFileName = java.net.URLEncoder.encode(codedFileName, "UTF8");
		} else {
			codedFileName = new String(codedFileName.getBytes("UTF-8"), "ISO-8859-1");
		}
		response.setHeader("content-disposition", "attachment;filename=" + codedFileName);
		ServletOutputStream out = response.getOutputStream();
		workbook.write(out);
		out.flush();
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	
	@RequestMapping(params = "exportXls4Perm")
	public void exportXls4Perm(PersonnelBaseArchivesManageInDto personnelBaseArchivesManageInDto,HttpServletRequest request,HttpServletResponse response
			, DataGrid dataGrid,ModelMap modelMap) {
		String codedFileName = "项目员工档案";
		List<Map<String, Object>> modelMapList = null;
		try {
			HttpSession session = ContextHolderUtils.getSession();
			TSUser tuser = (TSUser)session.getAttribute("LOCAL_CLINET_USER");
			modelMapList = personnelBaseArchivesManageExportAndImportService.exportXls4Perm(personnelBaseArchivesManageInDto, tuser.getId());
		} catch (Exception e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		Workbook workbook = personnelBaseArchivesManageExportAndImportService.getWorkBook(modelMapList);
		 
		if (workbook instanceof HSSFWorkbook) {
			codedFileName +=".xls";
		} else {
			codedFileName +=".xlsx";
		}
		try {
		if (personnelBaseArchivesManageExportAndImportService.isIE(request)) {
				codedFileName = java.net.URLEncoder.encode(codedFileName, "UTF8");
		} else {
			codedFileName = new String(codedFileName.getBytes("UTF-8"), "ISO-8859-1");
		}
		response.setHeader("content-disposition", "attachment;filename=" + codedFileName);
		ServletOutputStream out = response.getOutputStream();
		workbook.write(out);
		out.flush();
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	
	/**
	 * 导出excel 使模板
	 * 
	 * @param request
	 * @param response
	 */
	@RequestMapping(params = "exportXlsByT")
	public String exportXlsByT(PersonnelBaseArchivesManageExportAndImportDto personnelBaseArchivesManageExportAndImportDto,HttpServletRequest request,HttpServletResponse response
			, DataGrid dataGrid,ModelMap modelMap) {
    	modelMap.put(NormalExcelConstants.FILE_NAME,"员工人事信息表");
    	modelMap.put(NormalExcelConstants.CLASS,PersonnelBaseArchivesManageExportAndImportDto.class);
    	modelMap.put(NormalExcelConstants.PARAMS,new ExportParams("员工人事信息列表", "导出人:"+ResourceUtil.getSessionUser().getRealName(),
    	"导出信息"));
    	modelMap.put(NormalExcelConstants.DATA_LIST,new ArrayList());
    	return NormalExcelConstants.JEECG_EXCEL_VIEW;
	}
	
	/**
	 * 导入功能
	 * @author zbw
	 * 2017-12-13
	 * @param request
	 * @param response
	 * @return
	 */
	@SuppressWarnings("unchecked")
	@RequestMapping(params = "importExcel", method = RequestMethod.POST)
	@ResponseBody
	public AjaxJson importExcel(HttpServletRequest request, HttpServletResponse response) {
		AjaxJson j = new AjaxJson();
		try {
			long start = System.currentTimeMillis();
			j=personnelBaseArchivesManageExportAndImportService.importExcelPersonnelBaseArchivesManage(request, response);
			if(j.getAttributes()!=null){
				Map<String, Object> deleteMap=j.getAttributes();
				List<String> userNameList=new ArrayList<String>();
				for(java.util.Map.Entry<String, Object> entry  :deleteMap.entrySet()){  
//		            System.out.println("键:"+ entry.getKey()+" 值:"+ entry.getValue()); 
					userNameList.add(entry.getKey());
		        }
				if(userNameList.size()>0){
					personnelBaseArchivesManageExportAndImportService.deleteUserByUserName(userNameList);
				}
				
			}
			long end = System.currentTimeMillis();
			System.out.println(end-start);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			j.setMsg("导入失败");
			j.setSuccess(false);
		}
		return j;
	}
	
	/**
	 * 导入功能
	 * @author zbw
	 * 2017-12-13
	 * @param request
	 * @param response
	 * @return
	 */
	/*@SuppressWarnings("unchecked")
	@RequestMapping(params = "importExcel", method = RequestMethod.POST)
	@ResponseBody
	public AjaxJson importExcel(HttpServletRequest request, HttpServletResponse response) {
		AjaxJson j = new AjaxJson();
		
		MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
		Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
		for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
			MultipartFile file = entity.getValue();// 获取上传文件对象
			ImportParams params = new ImportParams();
			params.setTitleRows(2);
			params.setHeadRows(1);
			params.setNeedSave(true);
			try {
				List<PersonnelBaseArchivesManageExportAndImportDto> personnelBaseArchivesManageExportAndImportDtoList = ExcelImportUtil.importExcel(file.getInputStream(),PersonnelBaseArchivesManageExportAndImportDto.class,params);
				for (PersonnelBaseArchivesManageExportAndImportDto personnelBaseArchivesManageExportAndImportDto : personnelBaseArchivesManageExportAndImportDtoList) {
//					personnelBaseArchivesManageService.save(personnelBaseArchivesManageExportAndImportDto);
				}
				j.setMsg("文件导入成功！");
			} catch (Exception e) {
				j.setMsg("文件导入失败！");
				logger.error(ExceptionUtil.getExceptionMessage(e));
			}finally{
				try {
					file.getInputStream().close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return j;
	}*/
	
	@RequestMapping(method = RequestMethod.GET)
	@ResponseBody
	public List<PersonnelBaseArchivesManageEntity> list() {
		List<PersonnelBaseArchivesManageEntity> listPersonnelBaseArchivesManages=personnelBaseArchivesManageService.getList(PersonnelBaseArchivesManageEntity.class);
		return listPersonnelBaseArchivesManages;
	}
	
	@RequestMapping(value = "/{id}", method = RequestMethod.GET)
	@ResponseBody
	public ResponseEntity<?> get(@PathVariable("id") String id) {
		PersonnelBaseArchivesManageEntity task = personnelBaseArchivesManageService.get(PersonnelBaseArchivesManageEntity.class, id);
		if (task == null) {
			return new ResponseEntity(HttpStatus.NOT_FOUND);
		}
		return new ResponseEntity(task, HttpStatus.OK);
	}

	@RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE)
	@ResponseBody
	public ResponseEntity<?> create(@RequestBody PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, UriComponentsBuilder uriBuilder) {
		//调用JSR303 Bean Validator进行校验，如果出错返回含400错误码及json格式的错误信息.
		Set<ConstraintViolation<PersonnelBaseArchivesManageEntity>> failures = validator.validate(personnelBaseArchivesManage);
		if (!failures.isEmpty()) {
			return new ResponseEntity(BeanValidators.extractPropertyAndMessage(failures), HttpStatus.BAD_REQUEST);
		}

		//保存
		try{
			personnelBaseArchivesManageService.save(personnelBaseArchivesManage);
		} catch (Exception e) {
			e.printStackTrace();
			return new ResponseEntity(HttpStatus.NO_CONTENT);
		}
		//按照Restful风格约定，创建指向新任务的url, 也可以直接返回id或对象.
		String id = personnelBaseArchivesManage.getId();
		URI uri = uriBuilder.path("/rest/personnelBaseArchivesManageController/" + id).build().toUri();
		HttpHeaders headers = new HttpHeaders();
		headers.setLocation(uri);

		return new ResponseEntity(headers, HttpStatus.CREATED);
	}

	@RequestMapping(value = "/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
	public ResponseEntity<?> update(@RequestBody PersonnelBaseArchivesManageEntity personnelBaseArchivesManage) {
		//调用JSR303 Bean Validator进行校验，如果出错返回含400错误码及json格式的错误信息.
		Set<ConstraintViolation<PersonnelBaseArchivesManageEntity>> failures = validator.validate(personnelBaseArchivesManage);
		if (!failures.isEmpty()) {
			return new ResponseEntity(BeanValidators.extractPropertyAndMessage(failures), HttpStatus.BAD_REQUEST);
		}

		//保存
		try{
			personnelBaseArchivesManageService.saveOrUpdate(personnelBaseArchivesManage);
		} catch (Exception e) {
			e.printStackTrace();
			return new ResponseEntity(HttpStatus.NO_CONTENT);
		}

		//按Restful约定，返回204状态码, 无内容. 也可以返回200状态码.
		return new ResponseEntity(HttpStatus.NO_CONTENT);
	}

	@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
	@ResponseStatus(HttpStatus.NO_CONTENT)
	public void delete(@PathVariable("id") String id) {
		personnelBaseArchivesManageService.deleteEntityById(PersonnelBaseArchivesManageEntity.class, id);
	}
	
	
	
	/**
	 * 处理消息到期提醒逻辑
	 * 
	 * @return
	 */
//	http://192.168.100.117:8080/hgl/personnelBaseArchivesManageController/dealMessageExpirationAlert.do
	@RequestMapping(params="dealMessageExpirationAlert")
	@ResponseBody
	public String dealMessageExpirationAlert() {
		try {
			personnelBaseArchivesManageService.dealMessageExpirationAlert();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return "操作成功";
	}
	
	
	/**
	 * 员工照片批量上传
	 * 证书批量上传
	 * 附件追加批量上传
	 * 文件管理表列表 页面跳转
	 * 
	 * @return
	 */
	@RequestMapping(params = "batchUploadFile")
	public ModelAndView batchUploadFile(TSysFileDto tSysFileDto,HttpServletRequest request, HttpServletRequest req,WebUploadEntity webUpload) {
		if (null == webUpload) {
			webUpload = new WebUploadEntity();
		}
		
		if(tSysFileDto.getTagetType()!=null&&tSysFileDto.getTagetType().length()!=0){
			if(tSysFileDto.getTagetType().equals(Globals.taget_type_0)){
				webUpload.setBusiTable("t_s_base_user");
				webUpload.setBizType(Globals.taget_type_0);
				webUpload.setRemark("员工照片批量上传");
				webUpload.setExtensions("jpg,png");
				webUpload.setBusiId(Globals.busi_id_batch);
			}else if(tSysFileDto.getTagetType().equals(Globals.taget_type_1)){
				webUpload.setBusiTable("t_bus_user_certificate");
				webUpload.setBizType(Globals.taget_type_1);
				webUpload.setRemark("员工证书批量上传");
				webUpload.setExtensions("jpg,png,pdf,doc,docx,xls,xlsx");
				webUpload.setBusiId(Globals.busi_id_batch);
			}else if(tSysFileDto.getTagetType().equals(Globals.taget_type_2)){
				webUpload.setBusiTable("t_bus_accessory");
				webUpload.setBizType(Globals.taget_type_2);
				webUpload.setRemark("员工附件追加批量上传");
				webUpload.setExtensions("jpg,png,pdf,doc,docx,xls,xlsx");
				webUpload.setBusiId(Globals.busi_id_batch);
			}
			req.setAttribute("tagetType", tSysFileDto.getTagetType());
		}else{
			webUpload.setBusiTable("t_s_base_user");
			webUpload.setBizType(Globals.taget_type_0);
			webUpload.setRemark("员工照片批量上传");
			webUpload.setExtensions("jpg,png");
			webUpload.setBusiId(Globals.busi_id_batch);
			req.setAttribute("tagetType", Globals.taget_type_0);
		}
		
		String curUserName = ResourceUtil.getSessionUser().getUserName();
		req.setAttribute("curUserName", curUserName);
		req.setAttribute("webUpload", webUpload);
		req.setAttribute("showAndDownUrl", showAndDownUrl);
		
		return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/batchUploadFile/tSysUploadFileList");
	}
	
	/**
	 * 证书批量上传
	 * 文件管理表列表 页面跳转
	 * 
	 * @return
	 */
	/*@RequestMapping(params = "batchUploadFileCertificate")
	public ModelAndView batchUploadFileCertificate(HttpServletRequest request, HttpServletRequest req,WebUploadEntity webUpload) {
		if (null == webUpload) {
			webUpload = new WebUploadEntity();
		}
		String curUserName = ResourceUtil.getSessionUser().getUserName();
		req.setAttribute("curUserName", curUserName);
		req.setAttribute("webUpload", webUpload);
		return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/batchUploadFile/tSysFileCertificateList");
	}*/
	
	
	/**
	 * 附件追加批量上传
	 * 文件管理表列表 页面跳转
	 * 
	 * @return
	 */
	/*@RequestMapping(params = "batchUploadFileAccessory")
	public ModelAndView batchUploadFileAccessory(HttpServletRequest request, HttpServletRequest req,WebUploadEntity webUpload) {
		if (null == webUpload) {
			webUpload = new WebUploadEntity();
		}
		String curUserName = ResourceUtil.getSessionUser().getUserName();
		req.setAttribute("curUserName", curUserName);
		req.setAttribute("webUpload", webUpload);
		return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/batchUploadFile/tSysFileAccessoryList");
	}*/
	
	
	/**
	 * 员工照片查询
	 * 证书查询
	 * 附件追加查询
	 * easyui AJAX请求数据
	 * 
	 * @param request
	 * @param response
	 * @param dataGrid
	 * @param user
	 */

	@RequestMapping(params = "batchUploadFileList")
	public void batchUploadFileList(TSysFileDto tSysFileDto,HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
		/*CriteriaQuery cq = new CriteriaQuery(TSysFileEntity.class, dataGrid);
		//查询条件组装器
		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, tSysFile, request.getParameterMap());
		try{
			//自定义追加查询条件
			//查询文件名称
			cq.like("fileName", tSysFile.getFileName());
			
			if(tSysFile.getTagetType()!=null){
				cq.eq("tagetType", tSysFile.getTagetType());
			}else{
				cq.eq("tagetType", "userPhoto");
			}
			
			
			//排序
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("createDate", "desc");
			cq.setOrder(map);
		}catch (Exception e) {
			throw new BusinessException(e.getMessage());
		}
		cq.add();
		this.personnelBaseArchivesManageService.getDataGridReturn(cq, true);
		TagUtil.datagrid(response, dataGrid);*/
		if(tSysFileDto.getTagetType()==null){
			tSysFileDto.setTagetType("userPhoto");
		}
		MiniDaoPage<TSysFileDto> tSysFileDtoList =null;
		String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
		try {
			tSysFileDtoList = personnelBaseArchivesManageExportAndImportService.getTSysFileDtoPage(tSysFileDto, dataGrid.getPage(), dataGrid.getRows(),authSql);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		for (int i = 0; i < tSysFileDtoList.getResults().size(); i++) {
//			TSysFileEntity tSysFileEntity = (TSysFileEntity) tSysFileDtoList.getResults();
			String fileName =tSysFileDtoList.getResults().get(i).getFileName();
			String fileType = fileName.substring(fileName.lastIndexOf(".") + 1);
			if("jpg".equals(fileType) || "png".equals(fileType) || "pdf".equals(fileType)) {
//				tSysFileEntity.setIsPreviewFlg("1");
				tSysFileDtoList.getResults().get(i).setIsPreviewFlg("1");
			} else {
//				tSysFileEntity.setIsPreviewFlg("0");
				tSysFileDtoList.getResults().get(i).setIsPreviewFlg("0");
			}
			
		}
		
		dataGrid.setTotal(tSysFileDtoList.getTotal());
		dataGrid.setResults(tSysFileDtoList.getResults());
		TagUtil.datagrid(response, dataGrid);
		
		
	}
	
	/**
	 * 证书查询
	 * easyui AJAX请求数据
	 * 
	 * @param request
	 * @param response
	 * @param dataGrid
	 * @param user
	 */

	/*@RequestMapping(params = "batchUploadFileCertificateList")
	public void batchUploadFileCertificateList(TSysFileEntity tSysFile,HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
		CriteriaQuery cq = new CriteriaQuery(TSysFileEntity.class, dataGrid);
		//查询条件组装器
		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, tSysFile, request.getParameterMap());
		try{
			//自定义追加查询条件
			//查询文件名称
			cq.like("fileName", tSysFile.getFileName());
			
			cq.eq("tagetType", "userCertificate");
			
			//排序
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("createDate", "desc");
			cq.setOrder(map);
		}catch (Exception e) {
			throw new BusinessException(e.getMessage());
		}
		cq.add();
		this.personnelBaseArchivesManageService.getDataGridReturn(cq, true);
		TagUtil.datagrid(response, dataGrid);
	}*/
	
	/**
	 * 附件追加查询
	 * easyui AJAX请求数据
	 * 
	 * @param request
	 * @param response
	 * @param dataGrid
	 * @param user
	 */

	/*@RequestMapping(params = "batchUploadFileAccessoryList")
	public void batchUploadFileAccessoryList(TSysFileEntity tSysFile,HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
		CriteriaQuery cq = new CriteriaQuery(TSysFileEntity.class, dataGrid);
		//查询条件组装器
		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, tSysFile, request.getParameterMap());
		try{
			//自定义追加查询条件
			//查询文件名称
			cq.like("fileName", tSysFile.getFileName());
			
			cq.eq("tagetType", "userAccessory");
			
			//排序
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("createDate", "desc");
			cq.setOrder(map);
		}catch (Exception e) {
			throw new BusinessException(e.getMessage());
		}
		cq.add();
		this.personnelBaseArchivesManageService.getDataGridReturn(cq, true);
		TagUtil.datagrid(response, dataGrid);
	}*/
	
	
	
	
//-----------------------------------------------------------------------------------------------------------

	/**
	 * 弹出新建员工页面
	 * @param user
	 * @param req
	 * @return
	 */
	@RequestMapping(params = "goAddBase")
	public ModelAndView goAddBase(TSUser userInfo, HttpServletRequest req) {
		if (StringUtil.isNotEmpty(userInfo.getId())) {
			userInfo = systemService.getEntity(TSUser.class, userInfo.getId());
			req.setAttribute("userInfo", userInfo);
			this.idandname(req, userInfo);
			this.getOrgInfos(req, userInfo);
			this.getJzOrgInfos(req, userInfo);
		}
        return new ModelAndView("cn/com/lzt/personnelInfoUpload/userInfo-base-add");
	}
	
	public void idandname(HttpServletRequest req, TSUser user) {
		List<TSRoleUser> roleUsers = systemService.findByProperty(TSRoleUser.class, "TSUser.id", user.getId());
		String roleId = "";
		String roleName = "";
		if (roleUsers.size() > 0) {
			for (TSRoleUser tRoleUser : roleUsers) {
				roleId += tRoleUser.getTSRole().getId() + ",";
				roleName += tRoleUser.getTSRole().getRoleName() + ",";
			}
		}
		req.setAttribute("id", roleId);
		req.setAttribute("roleName", roleName);
	}
	
	
	public void getOrgInfos(HttpServletRequest req, TSUser user) {
//			List<TSUserOrg> tSUserOrgs = systemService.findByProperty(TSUserOrg.class, "tsUser.id", user.getId());
		// 查询项目经理的所属机构 by zhijia.wang
		List<TSUserOrg> tSUserOrgs = new ArrayList<TSUserOrg>();
		List<TSUserOrg> normalList = systemService.findHql(
				"from TSUserOrg where tsUser=? and ifpluralism=? and status=? order by intime desc", user, Globals.PLURALISM_NO.toString(), Globals.BELONG_STATUS_NORMAL.toString());
		if(normalList!=null && normalList.size()>0){
			tSUserOrgs.addAll(normalList);
		}else{
			List<TSUserOrg> moveList = systemService.findHql(
					"from TSUserOrg where tsUser=? and ifpluralism=? order by intime desc", user, Globals.PLURALISM_NO.toString());
			if(moveList!=null && moveList.size()>0){
				tSUserOrgs.add(moveList.get(0));
			}
		}
		
		String orgIds = "";
		String departname = "";
		if (tSUserOrgs.size() > 0) {
			for (TSUserOrg tSUserOrg : tSUserOrgs) {
				orgIds += tSUserOrg.getTsDepart().getId() + ",";
				departname += tSUserOrg.getTsDepart().getDepartname() + ",";
			}
		}
		req.setAttribute("orgIds", orgIds);
		if(StringUtil.isNotEmpty(departname)) {
			departname = departname.substring(0, departname.length() - 1);
		}
		req.setAttribute("departname", departname);
	}
	
	public void getJzOrgInfos(HttpServletRequest req, TSUser user) {
//			List<TSUserOrg> tSUserOrgs = systemService.findByProperty(TSUserOrg.class, "tsUser.id", user.getId());
		// 查询项目经理的兼容机构 by zhijia.wang
		List<TSUserOrg> tSUserOrgs = systemService.findHql("from TSUserOrg where tsUser=? and ifpluralism=? and status=? ", user, Globals.PLURALISM_YES.toString(), Globals.BELONG_STATUS_NORMAL.toString());
		String jzorgIds = "";
		String jzdepartname = "";
		if (tSUserOrgs.size() > 0) {
			for (TSUserOrg tSUserOrg : tSUserOrgs) {
				jzorgIds += tSUserOrg.getTsDepart().getId() + ",";
				jzdepartname += tSUserOrg.getTsDepart().getDepartname() + ",";
			}
		}
		req.setAttribute("jzorgIds", jzorgIds);
		if(StringUtil.isNotEmpty(jzdepartname)) {
			jzdepartname = jzdepartname.substring(0, jzdepartname.length() - 1);
		}
		req.setAttribute("jzdepartname", jzdepartname);
	}
	
	
	
	/**
	 * 新建员工基本信息
	 * 
	 * @param user
	 * @param req
	 * @return
	 */
	@RequestMapping(params = "saveUser")
	@ResponseBody
	public AjaxJson saveUser(HttpServletRequest req, TSUser user) {
		String message = null;
		AjaxJson j = new AjaxJson();
		if(user.getMobilePhone() == null || user.getMobilePhone().length() ==0) {
			message = "员工: " + user.getUserName() + "手机号不能为空";
			j.setSuccess(false);
		}
//		String roleid = oConvertUtils.getString(req.getParameter("roleid"));
		
		String yxyg_roleid = null;// 一线员工的角色ID
		List<TSRole> yxyg_roleList = systemService.findByProperty(TSRole.class, "roleCode", Globals.roleCode_yxyg);
		if(yxyg_roleList != null && yxyg_roleList.size() > 0){
			yxyg_roleid = yxyg_roleList.get(0).getId();// 一线员工的角色ID
		}
		
		String roleid = null;
//		if(Globals.userType_1.equals(user.getUserType())){
		//
		roleid = yxyg_roleid;
//		}
		
		// 模拟一线员工密码,不需要使用
		String password = "aaaaaa";
		
		/**
		TSUser users = systemService.findUniqueByProperty(TSUser.class, "userName",user.getUserName());
		if (users != null) {
			message = "员工: " + users.getUserName() + "已经存在";
			j.setSuccess(false);
		*/
		// 获取用户信息
		StringBuilder suserSqlidcard = new StringBuilder();
					
		suserSqlidcard.append(" SELECT ");
		suserSqlidcard.append(" suser.id ");
		suserSqlidcard.append(" FROM t_s_user suser ");
		suserSqlidcard.append(" LEFT JOIN t_s_base_user sbaseuser ON suser.id = sbaseuser.id ");
		suserSqlidcard.append(" WHERE ");
		suserSqlidcard.append(" suser.idcard = '" + user.getIdcard() + "' ");
		suserSqlidcard.append(" AND sbaseuser.delete_flag <> '1' ");
		List<Map<String, Object>> suserMapList = systemService.findForJdbc(suserSqlidcard.toString());
		
		StringBuilder suserSql2 = new StringBuilder();
		suserSql2.append(" SELECT ");
		suserSql2.append(" id ");
		suserSql2.append(" FROM t_s_base_user ");
		suserSql2.append(" WHERE ");
		suserSql2.append(" username = '" + user.getMobilePhone() + "' ");
		suserSql2.append(" AND delete_flag <> '1'");
		List<Map<String, Object>> suserMapList2 = systemService.findForJdbc(suserSql2.toString());
		if(suserMapList.size() > 0){
			message = "员工身份证号: " + user.getIdcard() + "已经存在";
			j.setSuccess(false);
		}
		else if(suserMapList2.size() > 0){
			message = "员工手机号: " + user.getMobilePhone() + "已经存在，无法同步到考勤机。请尝试另一个手机号。";
			j.setSuccess(false);
		}else {
			// 加盐
			//user.setPassword(PasswordUtil.encrypt(user.getUserName(), password, PasswordUtil.getStaticSalt()));
			if(user.getRealName() != null) {
				String trim = user.getRealName().replaceAll(" ", "");
				user.setRealName(trim);
			}
			if(user.getIdcard() != null) {
				String up = user.getIdcard().toUpperCase();
				user.setIdcard(up);
			}
			user.setUserName(user.getMobilePhone());
			user.setPassword(PasswordEncodeUtil.getMD5(password));
			user.setStatus(Globals.User_Normal);
			user.setDeleteFlag(Globals.Delete_Normal);
			user.setDingIsSynchronization(Globals.DingIsSynchronization_NO.toString());//是否同步到钉钉：0不同步
			//systemService.save(user);
			userService.saveOrUpdateUser(user);
			// 保存1个组织机构
			String msg = saveUserOrgList(req, user);
			if(msg != null && !"".equals(msg.trim())){
            	j.setMsg(msg);
				j.setSuccess(false);
				return j;
            }
			message = "员工: " + user.getUserName() + "基本信息添加成功";
			j.setSuccess(true);
			if (StringUtil.isNotEmpty(roleid)) {
				saveRoleUser(user, roleid);
			}
			
			String orgIds = oConvertUtils.getString(req.getParameter("orgIds"));//兼职机构ID数组
	        List<String> orgIdList = extractIdListByComma(orgIds);
			TSDepart depart = departService.getEntity(TSDepart.class, orgIdList.get(0));
			
			if(StringUtil.isNotEmpty(depart.getDingdepartid())) {
				List<Long> departIdList = new ArrayList<Long>();
				departIdList.add(Long.valueOf(depart.getDingdepartid()));
				
				CorpUserDetail corpUserDetail = dingdingService.getUser(user.getId());
				boolean dingFlg = false;
				if(StringUtil.isNotEmpty(corpUserDetail.getUserid())) {
					dingFlg = dingdingService.updateUser(user.getId(), user.getRealName(), departIdList,user.getMobilePhone(), user.getUserName());
				} else {
					dingFlg = dingdingService.createUser(user.getId(), user.getRealName(), departIdList,user.getMobilePhone(), user.getUserName());
				}
				if(dingFlg) {
					message = "数据保存成功，考勤机同步成功！";
					user.setDingIsSynchronization(Globals.DingIsSynchronization_YES.toString());
				}else{
					message = "数据保存成功，考勤机同步失败！";
					user.setDingIsSynchronization(Globals.DingIsSynchronization_NO.toString());
				}
			} else {
				message = "数据保存成功，所属部门没有同步到考勤机，同步失败！";
			}
			systemService.saveOrUpdate(user);
			
			try {
				//处理附件追加用户默认固定附件类型
				personnelBaseArchivesManageService.dealAccessoryIsFixedDefault(user.getId());
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			systemService.addLog(message, Globals.Log_Type_INSERT, Globals.Log_Leavel_INFO);
		}

		j.setMsg(message);
		logger.info("["+IpUtil.getIpAddr(req)+"][添加编辑员工]"+message);
		return j;
	}
	
	
	/**
	 * 编辑员工基本信息
	 * 
	 * @return
	 */
	@RequestMapping(params = "updateUserData")
	@ResponseBody
	public AjaxJson updateUserData(TSUser userInfo, HttpServletRequest req){
		String message = "";
		AjaxJson j = new AjaxJson();
		
		if(StringUtil.isNotEmpty(userInfo.getId())) {
			
			// 判断身份证号是否重复
			StringBuilder suserSql = new StringBuilder();
			
			suserSql.append(" SELECT ");
			suserSql.append(" suser.id ");
			suserSql.append(" FROM t_s_user suser ");
			suserSql.append(" LEFT JOIN t_s_base_user sbaseuser ON suser.id = sbaseuser.id ");
			suserSql.append(" WHERE ");
			suserSql.append(" suser.idcard = '" + userInfo.getIdcard() + "' ");
			suserSql.append(" And suser.id != '" + userInfo.getId() + "' ");
			suserSql.append(" AND sbaseuser.delete_flag <> '1' ");
			List<Map<String, Object>> suserMapList = systemService.findForJdbc(suserSql.toString());
			
			if(suserMapList.size() > 0) {
				message = "身份证号已经存在，更新失败！";
				j.setSuccess(false);
		       	j.setMsg(message);
				return j;
			}
			
			TSUser users = systemService.getEntity(TSUser.class, userInfo.getId());
			if(users.getUserType().equals("0")) {
				message = "无权进行项目管理人员的信息修改，请联系人事部门";
				j.setSuccess(false);
		       	j.setMsg(message);
				return j;
			}
			// 设置用户角色相关信息start
//			List<TSRoleUser> ru = systemService.findByProperty(TSRoleUser.class, "TSUser.id", userInfo.getId());
//			if(users.getUserType() != null && !"".equals(users.getUserType())){
//				if(Globals.userType_0.equals(users.getUserType()) && Globals.userType_1.equals(userInfo.getUserType())){// 由管理员工改为普通员工
//					systemService.deleteAllEntitie(ru);
//					String yxyg_roleid = null;// 一线员工的角色ID
//					List<TSRole> yxyg_roleList = systemService.findByProperty(TSRole.class, "roleCode", Globals.roleCode_yxyg);
//					if(yxyg_roleList != null && yxyg_roleList.size() > 0){
//						yxyg_roleid = yxyg_roleList.get(0).getId();// 一线员工的角色ID
//					}
//					message = "员工: " + users.getUserName() + "基本信息更新成功";
//					j.setSuccess(true);
//					if(StringUtil.isNotEmpty(yxyg_roleid)) {
//						this.saveRoleUser(users, yxyg_roleid);
//					}
//				}else if(Globals.userType_1.equals(users.getUserType()) && Globals.userType_0.equals(userInfo.getUserType())){// 由普通员工改为管理员工
//					systemService.deleteAllEntitie(ru);
//				}
//			}else{
//				if(Globals.userType_1.equals(userInfo.getUserType())){// 修改为普通员工
//					systemService.deleteAllEntitie(ru);
//					String yxyg_roleid = null;// 一线员工的角色ID
//					List<TSRole> yxyg_roleList = systemService.findByProperty(TSRole.class, "roleCode", Globals.roleCode_yxyg);
//					if(yxyg_roleList != null && yxyg_roleList.size() > 0){
//						yxyg_roleid = yxyg_roleList.get(0).getId();// 一线员工的角色ID
//					}
//					message = "员工: " + users.getUserName() + "基本信息更新成功";
//					j.setSuccess(true);
//					if(StringUtil.isNotEmpty(yxyg_roleid)) {
//						this.saveRoleUser(users, yxyg_roleid);
//					}
//				}else{
//					systemService.deleteAllEntitie(ru);
//				}
//			}
			// 设置用户角色相关信息end
			
			if(userInfo.getRealName() != null) {
				String trim = userInfo.getRealName().replaceAll(" ", "");
				userInfo.setRealName(trim);
			}
			if(userInfo.getIdcard() != null) {
				String up = userInfo.getIdcard().toUpperCase();
				userInfo.setIdcard(up);
			}
//			users.setUserType(userInfo.getUserType());// 设置员工类型
			users.setOfficePhone(userInfo.getOfficePhone());
			users.setEmail(userInfo.getEmail());
			users.setDevFlag(userInfo.getDevFlag());// 开发权限标志
			users.setGender(userInfo.getGender());
			users.setNation(userInfo.getNation());
			users.setIdcard(userInfo.getIdcard());
			users.setAddress(userInfo.getAddress());
			users.setHkaddress(userInfo.getHkaddress());
			users.setUserNum(userInfo.getUserNum());
			users.setHktype(userInfo.getHktype());
			users.setEducation(userInfo.getEducation());
			
//	          systemService.executeSql("delete from t_s_user_org where user_id=? ", user.getId());
			// 保存1个组织机构
			String msg = saveUserOrgList(req, userInfo);
            if(msg != null && !"".equals(msg.trim())){
            	j.setMsg(msg);
				j.setSuccess(false);
				return j;
            }
//	          users.setTSDepart(user.getTSDepart());
			users.setStatus(userInfo.getStatus());// 员工状态
			users.setActivitiSync(userInfo.getActivitiSync());// 是否同步工作流引擎
			users.setDingIsSynchronization(userInfo.getDingIsSynchronization());// 是否同步到钉钉
			//systemService.updateEntitie(users);
			
			String orgIds = oConvertUtils.getString(req.getParameter("orgIds"));// 兼职机构ID数组
	        List<String> orgIdList = extractIdListByComma(orgIds);
			TSDepart depart = departService.getEntity(TSDepart.class, orgIdList.get(0));
			
			if(StringUtil.isNotEmpty(depart.getDingdepartid())) {
				List<Long> departIdList = new ArrayList<Long>();
				departIdList.add(Long.valueOf(depart.getDingdepartid()));
				
				CorpUserDetail corpUserDetail = dingdingService.getUser(userInfo.getId());
				boolean dingFlg = false;
				if(StringUtil.isNotEmpty(corpUserDetail.getUserid())) {
					dingFlg = dingdingService.updateUser(userInfo.getId(), userInfo.getRealName(), departIdList,userInfo.getMobilePhone(), userInfo.getUserName());
				} else {
					dingFlg = dingdingService.createUser(userInfo.getId(), userInfo.getRealName(), departIdList,userInfo.getMobilePhone(), userInfo.getUserName());
				}
				if(dingFlg) {
					message = "数据保存成功，钉钉数据同步成功！";
					users.setDingIsSynchronization(Globals.DingIsSynchronization_YES.toString());
				}else{
					message = "数据保存成功，钉钉数据同步失败！";
					users.setDingIsSynchronization(Globals.DingIsSynchronization_NO.toString());
				}
			} else {
				message = "数据保存成功，所属部门没有同步到钉钉，同步失败！";
			}
//			systemService.updateEntitie(users);
			userService.saveOrUpdateUser(users);////将该员工同步至工作流内
			systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
		}else{
			message = "数据异常！";
			j.setSuccess(false);
		}
		j.setMsg(message);
		logger.info("["+IpUtil.getIpAddr(req)+"][编辑员工]"+message);
		return j;
	}
	
	
    /**
     * 保存 用户-组织机构 关系信息
     * @param request request
     * @param user user
     */
    private String saveUserOrgList(HttpServletRequest request, TSUser user) {
        String orgIds = oConvertUtils.getString(request.getParameter("orgIds"));//组织机构ID数组
//        String jzorgIds = oConvertUtils.getString(request.getParameter("jzorgIds"));//兼职机构ID数组
        String msg = null;
//-------------------------设置该用户的组织机构关系-------------------------
        List<String> orgIdList = extractIdListByComma(orgIds);
        String orgId = orgIdList.get(0);//目前规定一个人只能有一个组织机构
        
		//查询该用户所有的组织机构
		List<TSUserOrg> userOrgList = systemService.findHql("from TSUserOrg where tsUser.id=? and ifpluralism=? order by intime desc", user.getId(), Globals.PLURALISM_NO.toString());
		if(userOrgList!=null && userOrgList.size()>0){
			TSUserOrg uo = userOrgList.get(0);//取出该用户最新的一条组织机构关系记录
			
			if(!uo.getTsDepart().getId().equals(orgId)){//如果数据库中最新的一条数据的组织机构ID 和页面传过来的ID不一样
				boolean delFlag = false;
				if(uo.getStatus().equals(Globals.BELONG_STATUS_NORMAL.toString())){
					delFlag = true;
				}
				if(getProjectStatus(orgId)){
					if(delFlag){
						systemService.delete(uo);
					}
					TSDepart depart = new TSDepart();
					depart.setId(orgId);
					TSUserOrg userOrg = new TSUserOrg();
					userOrg.setTsUser(user);
					userOrg.setTsDepart(depart);
					userOrg.setIfpluralism(Globals.PLURALISM_NO.toString());
					userOrg.setStatus(Globals.BELONG_STATUS_NORMAL.toString());
					userOrg.setIntime(new Date());
					systemService.save(userOrg);
				}else{
					msg = "该组织机构已停用，不可选！";
				}
			}
		}else{//该用户还没有组织机构，说明是新建的用户，所以直接插入一条组织机构关系即可
			if(getProjectStatus(orgId)){
				TSDepart depart = new TSDepart();
				depart.setId(orgId);
				TSUserOrg userOrg = new TSUserOrg();
				userOrg.setTsUser(user);
				userOrg.setTsDepart(depart);
				userOrg.setIfpluralism(Globals.PLURALISM_NO.toString());
				userOrg.setStatus( Globals.BELONG_STATUS_NORMAL.toString());
				userOrg.setIntime(new Date());
				systemService.save(userOrg);
			}else{
				msg = "该组织机构已停用，不可选！";
			}
		}
		
		
//-------------------------设置该用户的兼职机构-------------------------
//		List<String> orgIdList_jz = extractIdListByComma(jzorgIds);
//		List<TSUserOrg> jzuserOrg4AddList = new ArrayList<TSUserOrg>();
//		List<TSUserOrg> jzuserOrg4DelList = new ArrayList<TSUserOrg>();
//		
//		Map<String, String> jzOrgMap = new HashMap<String, String>();
//		if(orgIdList_jz!=null && orgIdList_jz.size()>0){
//			for(String jzorgId : orgIdList_jz){
//				jzOrgMap.put(jzorgId, null);
//			}
//		}
//		
//		//查询该用户所有的兼职机构关系
//		List<TSUserOrg> jzList = systemService.findHql("from TSUserOrg where tsUser.id=? and ifpluralism=? order by intime desc", user.getId(), Globals.PLURALISM_YES.toString());
//		if(jzList!=null && jzList.size()>0){
//			Map<String, TSUserOrg> myJzOrgMap = new HashMap<String, TSUserOrg>();
//			for(TSUserOrg jz : jzList){
//				myJzOrgMap.put(jz.getTsDepart().getId(), jz);
//			}
//			
//			for(int i=0; i<jzList.size(); i++){
//				TSUserOrg jz = jzList.get(i);//用户原兼职机构关系
//				if(orgIdList_jz!=null && orgIdList_jz.size()>0){
//					for(String jzorgId : orgIdList_jz){
//						if(jz.getTsDepart().getId().equals(jzorgId)){//如果数据库中最新的一条数据的组织机构ID 和页面传过来的ID一样
//							jzOrgMap.remove(jzorgId);
//							myJzOrgMap.remove(jzorgId);
//						}
//					}
//				}else{
//					if(jz.getStatus().equals(Globals.BELONG_STATUS_NORMAL.toString())){
//						jzuserOrg4DelList.add(jz);
//					}
//				}
//			}
//			
//			if(!jzOrgMap.isEmpty()){
//				for(String key : jzOrgMap.keySet()){
//					if(!getProjectStatus(key)){
//						TSDepart depart = departService.getEntity(TSDepart.class, key);
//						msg = depart.getDepartname()+"  已停用，请选择其他兼职机构";
//						return msg;
//					}
//					TSDepart depart = new TSDepart();
//					depart.setId(key);
//					TSUserOrg userOrg_jz = new TSUserOrg();
//					userOrg_jz.setTsUser(user);
//					userOrg_jz.setTsDepart(depart);
//					userOrg_jz.setIfpluralism(Globals.PLURALISM_YES.toString());//1是兼职机构
//					userOrg_jz.setStatus(Globals.BELONG_STATUS_NORMAL.toString());//0正常
//					userOrg_jz.setIntime(new Date());
//					jzuserOrg4AddList.add(userOrg_jz);
//				}
//			}
//			if(!myJzOrgMap.isEmpty()){
//				for(String key : myJzOrgMap.keySet()){
//					TSUserOrg ts = myJzOrgMap.get(key);
//					if(ts.getStatus().equals(Globals.BELONG_STATUS_NORMAL.toString())){
//						jzuserOrg4DelList.add(ts);
//					}
//				}
//			}
//			
//			if(!jzuserOrg4DelList.isEmpty()){
//	            systemService.deleteAllEntitie(jzuserOrg4DelList);
//	        }
//			if(!jzuserOrg4AddList.isEmpty()){
//	            systemService.batchSave(jzuserOrg4AddList);
//	        }
//			
//		}else{
//			if(orgIdList_jz!=null && orgIdList_jz.size()>0){
//				for(String jzorgId : orgIdList_jz){
//					if(!getProjectStatus(jzorgId)){
//						TSDepart depart = departService.getEntity(TSDepart.class, jzorgId);
//						msg = depart.getDepartname()+"  已停用，请选择其他兼职机构";
//						return msg;
//					}
//					TSDepart depart = new TSDepart();
//					depart.setId(jzorgId);
//					TSUserOrg userOrg_jz = new TSUserOrg();
//					userOrg_jz.setTsUser(user);
//					userOrg_jz.setTsDepart(depart);
//					userOrg_jz.setIfpluralism(Globals.PLURALISM_YES.toString());//1是兼职机构
//					userOrg_jz.setStatus(Globals.BELONG_STATUS_NORMAL.toString());//0正常
//					userOrg_jz.setIntime(new Date());
//					jzuserOrg4AddList.add(userOrg_jz);
//				}
//			}
//			if(!jzuserOrg4AddList.isEmpty()){
//	            systemService.batchSave(jzuserOrg4AddList);
//	        }
//		}
		return msg;
    }
    
    
	/**
	 * 查询项目停用、启用情况
	 * @param id
	 * @return
	 */
    private boolean getProjectStatus(String id){
    	TSDepart t = systemService.get(TSDepart.class, id);
    	if(t.getStatus().equals(Globals.Enabled_Status.toString())){
    		return true;//启用
    	}else{
    		return false;//停用
    	}
    }
    
    /**
     * 保存用户与角色的关系列表
     * @param user
     * @param roleidstr
     */
/*    protected void saveRoleUser(TSUser user, String roleidStr) {
		String[] roleids = roleidStr.split(",");
		List<TSRoleUser> rUserList = new ArrayList<TSRoleUser>();
		for (int i = 0; i < roleids.length; i++) {
			TSRoleUser rUser = new TSRoleUser();
			TSRole role = systemService.getEntity(TSRole.class, roleids[i]);
			rUser.setTSRole(role);
			rUser.setTSUser(user);
			rUserList.add(rUser);
		}
		if(rUserList != null && rUserList.size() > 0){
			systemService.batchSave(rUserList);
		}
	}*/
    
    protected void saveRoleUser(TSUser user, String roleidStr) {
		String[] roleids = roleidStr.split(",");
		for (int i = 0; i < roleids.length; i++) {
			TSRoleUser rUser = new TSRoleUser();
			TSRole role = systemService.getEntity(TSRole.class, roleids[i]);
			rUser.setTSRole(role);
			rUser.setTSUser(user);
			systemService.save(rUser);
		}
	}
	
    
    
    /**
	 * 钉钉同步用户
	 * 
	 * @author id 用户ID
	 */
	@RequestMapping(params = "synchronization")
	@ResponseBody
	public AjaxJson synchronization(String id, HttpServletRequest req) {
		AjaxJson j = new AjaxJson();
		String message = null;
		TSUser user = systemService.getEntity(TSUser.class, id);
		
		String dingDepartIdString = "";
		// 查询主组织
		StringBuilder mainOrgSql = new StringBuilder();
		mainOrgSql.append(" SELECT ");
		mainOrgSql.append(" depart.dingdepartid dingdepartid ");
		mainOrgSql.append(" FROM t_s_user_org userOrg ");
		mainOrgSql.append(" LEFT JOIN t_s_depart depart ON userOrg.org_id = depart.id ");
		mainOrgSql.append(" WHERE ");
		mainOrgSql.append(" userOrg.user_id = '" + id + "'");
		mainOrgSql.append(" AND userOrg.status = '0' ");
		mainOrgSql.append(" AND userOrg.ifpluralism <> '1' ");
		List<Map<String, Object>> mainOrgMapList = systemService.findForJdbc(mainOrgSql.toString());

		if(mainOrgMapList.size() > 0) {
			dingDepartIdString = (String)mainOrgMapList.get(0).get("dingdepartid");
		}
		CorpUserDetail dingUserInfo = dingdingService.getUser(id);
		if(StringUtil.isNotEmpty(dingUserInfo.getUserid())) {
			if(StringUtil.isNotEmpty(dingDepartIdString)) {
				List<Long> departIdList = new ArrayList<Long>();
				departIdList.add(Long.valueOf(dingDepartIdString));
				boolean dingFlg = dingdingService.updateUser(id, user.getRealName(), departIdList,user.getMobilePhone(), user.getUserName());
				if(dingFlg) {
					message = "钉钉数据同步成功";
					j.setSuccess(true);
					user.setDingIsSynchronization("1");
				}else{
					message = "钉钉数据同步失败";
					j.setSuccess(false);
					user.setDingIsSynchronization("0");
				}
			} else {
				message = "所属部门没有同步到钉钉，同步失败";
				j.setSuccess(false);
				user.setDingIsSynchronization("0");
			}
		} else {
			if(StringUtil.isNotEmpty(dingDepartIdString)) {
				List<Long> departIdList = new ArrayList<Long>();
				departIdList.add(Long.valueOf(dingDepartIdString));
				boolean dingFlg = dingdingService.createUser(id, user.getRealName(), departIdList,user.getMobilePhone(), user.getUserName());
				if(dingFlg) {
					message = "钉钉数据同步成功";
					j.setSuccess(true);
					user.setDingIsSynchronization("1");
				}else{
					message = "钉钉数据同步失败";
					j.setSuccess(false);
					user.setDingIsSynchronization("0");
				}
			} else {
				message = "所属部门没有同步到钉钉，同步失败";
				j.setSuccess(false);
				user.setDingIsSynchronization("0");
			}
		}

		userService.updateEntitie(user);
		j.setMsg(message);
		return j;
	}
	
	/**
	 * 保存员工人事变动信息
	 * 
	 * @param userId 用户ID
	 * @param ifpayment 是否缴金人员
	 * @param positionStatus 在职状态
	 * @throws Exception
	 */
	private void saveUserChangesLog(String userId, String ifpayment, String positionStatus) throws Exception {
		// 查询用户信息
		TSBaseUser userInfo = userService.get(TSBaseUser.class, userId);
		
		// 查询主组织
		StringBuilder mainOrgSql = new StringBuilder();
		mainOrgSql.append(" SELECT ");
		mainOrgSql.append(" org_id orgId");
		mainOrgSql.append(" FROM t_s_user_org ");
		mainOrgSql.append(" WHERE ");
		mainOrgSql.append(" user_id = '" + userId + "'");
		mainOrgSql.append(" AND status = '0' ");
		mainOrgSql.append(" AND ifpluralism <> '1' ");
		List<Map<String, Object>> mainOrgMapList = systemService.findForJdbc(mainOrgSql.toString());
		String mainOrgId = "";
		if(mainOrgMapList.size() > 0) {
			mainOrgId = (String)mainOrgMapList.get(0).get("orgId");
		}
		
		// 缴金人员，入职，显示人员变动信息，缴金状态"待缴金"
		// 协议人员，入职，显示人员变动信息，缴金状态为空，状态栏为空
		// 缴金单位，关联到员工工资策略中的社保单位
		// 查询登录人名字
		String loginUserName = ResourceUtil.getSessionUser().getRealName();
		
		UserChangesLogEntity userChangesLogEntity = new UserChangesLogEntity();
		userChangesLogEntity.setChangeTime(new Date());
		userChangesLogEntity.setUserCode(userInfo.getUserName());
		userChangesLogEntity.setUserName(userInfo.getRealName());
		userChangesLogEntity.setBelongUnitid(mainOrgId);
		userChangesLogEntity.setInUnitid("");
		if(Globals.JOBSTATUS_1.equals(positionStatus)) {
			userChangesLogEntity.setChangeType(Globals.CHANGE_TYPE_RUZHI);
		}
		if(Globals.JOBSTATUS_2.equals(positionStatus)) {
			userChangesLogEntity.setChangeType(Globals.CHANGE_TYPE_ZHUANZHENG);
		}
		userChangesLogEntity.setApplicant(loginUserName);
		if(Globals.SHIFOU_01_1.equals(ifpayment)) {
			String payUnit = "";
			String userWagestrategyHql = "from UserWagestrategyEntity where userid = ?";
			List<UserWagestrategyEntity> UserWagestrategyEntityList = userWagestrategyService.findHql(userWagestrategyHql,userId);
			if(UserWagestrategyEntityList.size() > 0) {
				String socialSecurityStrategyid = UserWagestrategyEntityList.get(0).getSocialSecurityStrategyid();
				// 查询用户信息
				SocialSecurityStrategyEntity socialSecurityStrategyEntity = socialSecurityStrategyService.get(SocialSecurityStrategyEntity.class, socialSecurityStrategyid);
				if(null != socialSecurityStrategyEntity) {
					payUnit = socialSecurityStrategyEntity.getSocialSecurityUnit();
				}
			}
			userChangesLogEntity.setPayUnit(payUnit);
			userChangesLogEntity.setPayRemindStatus(Globals.PAY_REMIND_STATUS_0);
		} else {
			userChangesLogEntity.setPayUnit("");
			userChangesLogEntity.setPayRemindStatus("");
		}
		userChangesLogService.save(userChangesLogEntity);
	}
}