YgglController.java

/**
 * @date 2019年11月15日  
 * @author 翁东州
 * @方法中文名称:
 */
package cn.timer.api.controller.yggl;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;

import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import javax.transaction.Transactional;
import javax.websocket.server.PathParam;

import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.util.StringUtil;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.BetweenFormater.Level;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import cn.timer.api.bean.qyzx.QyzxEmpEntAsso;
import cn.timer.api.bean.qyzx.QyzxEmpLogin;
import cn.timer.api.bean.yggl.YgglAttaClfjb;
import cn.timer.api.bean.yggl.YgglAttaCzjlb;
import cn.timer.api.bean.yggl.YgglAttaGzjlb;
import cn.timer.api.bean.yggl.YgglAttaGzk;
import cn.timer.api.bean.yggl.YgglAttaHtxxb;
import cn.timer.api.bean.yggl.YgglAttaJjlxr;
import cn.timer.api.bean.yggl.YgglAttaJyjlb;
import cn.timer.api.bean.yggl.YgglAttaLxxxb;
import cn.timer.api.bean.yggl.YgglAttaPxjlxxb;
import cn.timer.api.bean.yggl.YgglAttaSbgjj;
import cn.timer.api.bean.yggl.YgglAttaZcxxb;
import cn.timer.api.bean.yggl.YgglAttaZszjb;
import cn.timer.api.bean.yggl.YgglMainEmp;
import cn.timer.api.bean.yggl.YgglMainLzb;
import cn.timer.api.bean.zzgl.ZzglBmgwM;
import cn.timer.api.config.annotation.CurrentUser;
import cn.timer.api.config.annotation.UserBean;
import cn.timer.api.config.enuminterface.YgEnumInterface;
import cn.timer.api.config.enums.CommonEnum;
import cn.timer.api.dao.qyzx.QyzxEmpLoginMapper;
import cn.timer.api.dao.yggl.YgAreaDtoMapper;
import cn.timer.api.dao.yggl.YgCityDtoMapper;
import cn.timer.api.dao.yggl.YgMzDtoMapper;
import cn.timer.api.dao.yggl.YgProDtoMapper;
import cn.timer.api.dao.yggl.YgglMainEmpMapper;
import cn.timer.api.dao.yggl.YgglMainLzbMapper;

import cn.timer.api.dao.zzgl.ZzglBmgwMMapper;
import cn.timer.api.dto.yggl.AddygdaDto;
import cn.timer.api.dto.yggl.LoginerChargeDto;
import cn.timer.api.dto.yggl.LzbQueryDto;
import cn.timer.api.dto.yggl.LzygQueryDto;
import cn.timer.api.dto.yggl.YgAreaDto;
import cn.timer.api.dto.yggl.YgCityDto;
import cn.timer.api.dto.yggl.YgDrjqbDto;
import cn.timer.api.dto.yggl.YgDrsDto;
import cn.timer.api.dto.yggl.YgKVDto;
import cn.timer.api.dto.yggl.YgProDto;
import cn.timer.api.dto.yggl.YgQueryDto;
import cn.timer.api.dto.yggl.YgbintuDto;
import cn.timer.api.dto.yggl.YgglCartogramDto;
import cn.timer.api.dto.yggl.YgjgDto;
import cn.timer.api.dto.yggl.YgmzDto;
import cn.timer.api.dto.yggl.YgCartogramDto;
import cn.timer.api.dto.yggl.YgzzDto;
import cn.timer.api.utils.Md5;
import cn.timer.api.utils.Result;
import cn.timer.api.utils.ResultUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

/**
 * @date 2019年11月15日
 * @author 翁东州
 * @方法中文名称:
 */
@Api(tags = "3.员工管理")
@RestController
@Transactional
@RequestMapping(value = "/yggl", produces = { "application/json" })
public class YgglController {

	@Autowired
	private YgglMainEmpMapper ygglMainEmpMapper;

	@Autowired
	private QyzxEmpLoginMapper qyzxEmpLoginMapper;

	@Autowired
	private YgglMainLzbMapper ygglMainLzbMapper;

	@Autowired
	private ZzglBmgwMMapper zzglBmgwMMapper;

	// weng(籍贯)
	@Autowired
	private YgAreaDtoMapper ygAreaDtoMapper;
	@Autowired
	private YgCityDtoMapper ygCityDtoMapper;
	@Autowired
	private YgProDtoMapper ygProDtoMapper;

	// weng(民族)
	@Autowired
	private YgMzDtoMapper ygMzDtoMapper;
	
	/**
	 * 获取登录人的相关信息
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/loginmessage")
	@ApiOperation(value = " 获取登录人的相关信息", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 68)
	public Result<YgglMainEmp> loginmessage(@CurrentUser UserBean userBean) {
		Integer empNum = userBean.getEmpNum();
		Integer orgCode = userBean.getOrgCode();
		YgglMainEmp ygglMainEmp=new LambdaQueryChainWrapper<YgglMainEmp>(ygglMainEmpMapper)
				.select(YgglMainEmp::getBmgwId,YgglMainEmp::getName,YgglMainEmp::getRzTime,YgglMainEmp::getEmpNum).
				eq(YgglMainEmp::getEmpNum, empNum).eq(YgglMainEmp::getOrgCode, orgCode).one();
		Integer gw = ygglMainEmp.getBmgwId();
		ZzglBmgwM bmid = new LambdaQueryChainWrapper<ZzglBmgwM>(zzglBmgwMMapper).select(ZzglBmgwM::getUpId).eq(ZzglBmgwM::getId, gw).eq(ZzglBmgwM::getOrgCode, orgCode).one();
		ygglMainEmp.setUnionid(bmid.toString());
		return ResultUtil.data(ygglMainEmp, "部门id返回字段为unionid");
	}
	/**
	 * 获取登录人和上级主管的empNum和名称
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/loginerChargers")
	@ApiOperation(value = " 获取登录人和上级主管的empNum和名称", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 69)
	public Result<List<LoginerChargeDto>> loginerChargers(@CurrentUser UserBean userBean) {
		Integer orgCode = userBean.getOrgCode();
		ArrayList<Integer> list = new ArrayList<Integer>();
		Integer empNum = userBean.getEmpNum();
		Integer gw = empNumConfirm(orgCode, empNum).getBmgwId();
		List<ZzglBmgwM> zzglBmgwMs = new LambdaQueryChainWrapper<ZzglBmgwM>(zzglBmgwMMapper).eq(ZzglBmgwM::getOrgCode, orgCode).list();
		//获取该员工的上级部门id 的数组list
		ZzglBmgwM.getUpDepts(list, gw, zzglBmgwMs);
		List<Integer> leaderList = new ArrayList<Integer>();
		for (Integer zzglId : list) {
			for (ZzglBmgwM zzglBmgwM : zzglBmgwMs) {
				if (zzglId.equals(zzglBmgwM.getId()) && zzglBmgwM.getLeader()!=null) {
					
					leaderList.add(zzglBmgwM.getLeader());
				}
			}
		}
		List<YgglMainEmp> ygglMainEmps = empNumsConfirm(orgCode, leaderList);
		List<LoginerChargeDto> loginerChargeDtos =new ArrayList<LoginerChargeDto>();
		for (YgglMainEmp m : ygglMainEmps) {
			loginerChargeDtos.add(new LoginerChargeDto(m.getEmpNum(),m.getName()));
		}
		Collections.reverse(loginerChargeDtos);
		return ResultUtil.data(loginerChargeDtos, "获取上级部门的部门id");
	}
	//根据传来的empNum获取该人员信息，没有则传全部
	public List<YgglMainEmp> empNumsConfirm(Integer orgCode,List<Integer> empNumList) {
		List<YgglMainEmp> all = new LambdaQueryChainWrapper<YgglMainEmp>(ygglMainEmpMapper).eq(YgglMainEmp::getOrgCode, orgCode).list();
		List<YgglMainEmp> ygglMainEmps = new ArrayList<YgglMainEmp>();
		if (empNumList.size()!=0) {
			for (Integer empNum : empNumList) {
				all.stream().filter(item -> empNum.equals(item.getEmpNum())).forEach(action ->{
					ygglMainEmps.add(action);
				});
			}
		}else {
			ygglMainEmps.addAll(all);
		}
		
		return ygglMainEmps;
	}
	//根据传来的empNum获取该人员信息
	public YgglMainEmp empNumConfirm(Integer orgCode,Integer empNum) {
		YgglMainEmp one = new LambdaQueryChainWrapper<YgglMainEmp>(ygglMainEmpMapper).eq(YgglMainEmp::getOrgCode, orgCode).eq(YgglMainEmp::getEmpNum, empNum).one();
		return one;
	}
	
	
	
	
	/**
	 * 获取用户头像
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/headphotos")
	@ApiOperation(value = "获取用户头像", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 70)
	public Result<List<YgglMainEmp>> headphotos(@CurrentUser UserBean userBean, @RequestBody List<Integer> empNumList) {
		if (empNumList.size()==0) {
			return ResultUtil.error("请输入empNum数组");
		}
		List<YgglMainEmp> yglList = YgglMainEmp.builder().build().selectList(new QueryWrapper<YgglMainEmp>().lambda()
				.eq(YgglMainEmp::getOrgCode, userBean.getOrgCode()).in(YgglMainEmp::getEmpNum, empNumList).select(YgglMainEmp::getId,YgglMainEmp::getName,YgglMainEmp::getHeadUrl));
		for (YgglMainEmp yg : yglList) {
			if (StringUtil.isEmpty(yg.getHeadUrl())) {
				yg.setHeadUrl("");
			}
		}
		return ResultUtil.data(yglList, "获取用户头像组成功");
	}
	/**
	 * 获取员工档案
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/ygda")
	@ApiOperation(value = "获取员工档案", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 1)
	public Result<YgglMainEmp> selectygda(@CurrentUser UserBean userBean) {
		Integer empNum = userBean.getEmpNum();
		Integer orgCode = userBean.getOrgCode();
		QueryWrapper<YgglMainEmp> queryWrapper = new QueryWrapper<>();
		queryWrapper.eq("org_code", orgCode).eq("emp_num", empNum);
		YgglMainEmp ygglMainEmp = YgglMainEmp.builder().build().selectOne(queryWrapper);
		Date rz = ygglMainEmp.getRzTime();
		if (rz != null) {
			ygglMainEmp.setWorkTime(DateUtil.formatBetween(rz, new Date(), Level.DAY));
		}
		return ResultUtil.data(ygglMainEmp, "获取员工档案成功");
	}

	// 获取员工档案
	@GetMapping(value = "/ygda/{empNum}")
	@ApiOperation(value = "获取员工档案(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 2)
	public Result<YgglMainEmp> selectygda(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		Integer orgCode = userBean.getOrgCode();
		QueryWrapper<YgglMainEmp> queryWrapper = new QueryWrapper<>();
		queryWrapper.eq("org_code", orgCode).eq("emp_num", empNum);
		YgglMainEmp ygglMainEmp = YgglMainEmp.builder().build().selectOne(queryWrapper);
		Date rz = ygglMainEmp.getRzTime();
		if (rz != null) {
			ygglMainEmp.setWorkTime(DateUtil.formatBetween(ygglMainEmp.getRzTime(), new Date(), Level.DAY));
		}
		return ResultUtil.data(ygglMainEmp, "获取员工档案成功");
	}

	/**
	 * 根据岗位id获取员工档案部门岗位名称
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/ygdabm/{gwid}")
	@ApiOperation(value = "获取员工档案部门岗位名称", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 3)
	public Result<String> selectbmgw(@CurrentUser UserBean userBean, @PathVariable Integer gwid) {
		if (gwid == null || gwid == 0) {
			return ResultUtil.data("无岗位", "获取员工档案部门岗位名称成功");
		}
		Integer orgCode = userBean.getOrgCode();
		QueryWrapper<ZzglBmgwM> queryWrapper = new QueryWrapper<>();
		queryWrapper.eq("org_code", orgCode).eq("id", gwid);
		ZzglBmgwM zzglBmgwM = ZzglBmgwM.builder().build().selectOne(queryWrapper);
		String gw = null;
		Integer bmid = null;
		if (zzglBmgwM != null) {
			gw = zzglBmgwM.getName();
			bmid = zzglBmgwM.getUpId();
		}
		// QueryWrapper<ZzglBmgwM> queryWrapper1 = new QueryWrapper<>();
		// queryWrapper1.eq("org_code", orgCode).eq("up_dept_id", gwid);
		ZzglBmgwM z = ZzglBmgwM.builder().build()
				.selectOne(new QueryWrapper<ZzglBmgwM>().eq("org_code", orgCode).eq("id", bmid));
		String bm = null;
		if (z != null) {
			bm = z.getName();
		}
		String bmgw = bm + "/" + gw;
		return ResultUtil.data(bmgw, "获取员工档案部门岗位名称成功");
	}

	/**
	 * 添加员工档案(weng)
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/addygda")
	@ApiOperation(value = "添加员工档案", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 4)
	public Result<Object> addygda(@CurrentUser UserBean userBean, @RequestBody AddygdaDto addygdaDto) {
		Integer orgCode = userBean.getOrgCode();
		String name = addygdaDto.getName();
		String phone = addygdaDto.getPhone();
		Integer zjType = addygdaDto.getZjType();
		String zjNum = addygdaDto.getZjNum();
		Integer jobType = addygdaDto.getJobType();
//		Date rzTime = addygdaDto.getRzTime();// ?????????????为什么新添加员工不给默认入职日期?????????????????????????
		Date rzTime = new Date();
		Integer syq = addygdaDto.getSyq();
		Integer sex = addygdaDto.getSex();
		if (StrUtil.hasBlank(phone) || StrUtil.hasBlank(name) || StrUtil.hasBlank(zjNum)) {
			return ResultUtil.error("请输入员工姓名,手机号和身份证号");
		}
		QyzxEmpLogin login = new LambdaQueryChainWrapper<QyzxEmpLogin>(qyzxEmpLoginMapper)
				.eq(!StrUtil.hasBlank(phone), QyzxEmpLogin::getPhone, phone).one();
		if (login == null) {
			QyzxEmpLogin qyzxEmpLogin = QyzxEmpLogin.builder().phone(phone).pw(Md5.md5("123456"))
					.sts(CommonEnum.U_STS_ON.getType()).orgId(userBean.getOrgCode()).username(name).build();
			if (!qyzxEmpLogin.insert()) {
				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
				return ResultUtil.error("添加员工登录表失败,请检查输入信息");
			}
			// 添加三张表
			// 员工权限表(未定)
			// 员工企业关联表和员工档案,员工成长表(未定)
			QyzxEmpEntAsso.builder().empNum(qyzxEmpLogin.getId()).orgCode(orgCode)
					.userType(CommonEnum.U_TYPE_EMP.getType()).status(1).build().insert();// usertype2普通员工 status1正常
			YgglMainEmp ygglMainEmp = YgglMainEmp.builder().name(name).phone(phone).zjType(zjType).zjNum(zjNum)
					.jobType(jobType).rzTime(rzTime).syq(syq).sex(sex).empNum(qyzxEmpLogin.getId()).orgCode(orgCode)
					.build();

			ygglMainEmp.insert();
			new LambdaUpdateChainWrapper<YgglMainEmp>(ygglMainEmpMapper)
					.set(addygdaDto.getBmgwId() != null, YgglMainEmp::getBmgwId, addygdaDto.getBmgwId())
					.eq(YgglMainEmp::getOrgCode, orgCode).eq(YgglMainEmp::getId, ygglMainEmp.getId()).update();
			return ResultUtil.data(ygglMainEmp, "新添加员工档案成功!");
		} else {

			YgglMainEmp ishad = YgglMainEmp.builder().build()
					.selectOne(new QueryWrapper<YgglMainEmp>().eq("phone", phone).eq("org_code", orgCode));

			if (ishad == null) {
				// 添加三张表
				// 员工权限表(未定)
				QyzxEmpEntAsso.builder().empNum(login.getId()).orgCode(orgCode).userType(2).status(1).build().insert();// usertype2普通员工
																														// status1正常
				YgglMainEmp ygglMainEmp = YgglMainEmp.builder().name(name).phone(phone).zjType(zjType).zjNum(zjNum)
						.jobType(jobType).rzTime(rzTime).syq(syq).sex(sex).empNum(login.getId()).orgCode(orgCode)
						.build();
				ygglMainEmp.insert();
				new LambdaUpdateChainWrapper<YgglMainEmp>(ygglMainEmpMapper)
						.set(addygdaDto.getBmgwId() != null, YgglMainEmp::getBmgwId, addygdaDto.getBmgwId())
						.eq(YgglMainEmp::getOrgCode, orgCode).eq(YgglMainEmp::getId, ygglMainEmp.getId()).update();
				return ResultUtil.data(ygglMainEmp, "添加员工档案成功!");
			} else {
				return ResultUtil.error("该手机号已被使用,请输入正确手机号");
			}
		}
	}

	/**
	 * 修改员工档案
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/updateygda")
	@ApiOperation(value = "修改员工档案", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 5)
	public Result<Object> updateygda(@CurrentUser UserBean userBean, @RequestBody YgglMainEmp ygglMainEmp) {

		if (ygglMainEmp.getEmpNum() != null) {
			UpdateWrapper<YgglMainEmp> updateWrapper = new UpdateWrapper<YgglMainEmp>();
			updateWrapper.eq("org_code", userBean.getOrgCode()).eq("emp_num", ygglMainEmp.getEmpNum());
			ygglMainEmp.update(updateWrapper);
			return ResultUtil.data(ygglMainEmp, "修改成功");
		}
		return ResultUtil.error("请确认该员工是否存在！");
	}

	/**
	 * 员工搜索
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/ygquery")
	@ApiOperation(value = "员工搜索/分页", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 6)
	public Result<Object> ygquery(@CurrentUser UserBean userBean, @RequestBody YgQueryDto ygQueryDto) {
		Integer orgCode = userBean.getOrgCode();
		Integer b = ygQueryDto.getBmgwid();
		ArrayList<Integer> bList = new ArrayList<Integer>();
		List<ZzglBmgwM> zzglBmgwMs = new LambdaQueryChainWrapper<ZzglBmgwM>(zzglBmgwMMapper)
				.eq(ZzglBmgwM::getOrgCode, orgCode).list();
		ZzglBmgwM.getDepts(bList, b, zzglBmgwMs);

		Integer j = ygQueryDto.getJobStatus();
		Integer t = ygQueryDto.getJobType();
		String q = ygQueryDto.getQuery();
		Page<YgglMainEmp> page = new Page<YgglMainEmp>(
				ygQueryDto.getCurrentPage() == null ? 1 : ygQueryDto.getCurrentPage(),
				ygQueryDto.getTotalPage() == null ? 10 : ygQueryDto.getTotalPage());
		QueryWrapper<YgglMainEmp> queryWrapper = new QueryWrapper<>();
		queryWrapper.select("name", "emp_num", "bmgw_id", "rz_time", "job_type", "phone", "job_status")
				.ne("job_status", YgEnumInterface.jobStatus.YILIZHI.getType()).eq("org_code", orgCode).eq(t != null && t > -1, "job_type", t)
				.eq(j != null && j > -1, "job_status", j).in(!bList.isEmpty(), "bmgw_id", bList)
				.and(!StrUtil.hasBlank(q), wq -> wq.like("name", q).or().like("phone", q));

//		List<YgglMainEmp> lo = YgglMainEmp.builder().build().selectList(queryWrapper);
		IPage<YgglMainEmp> ygglMainEmpPage = YgglMainEmp.builder().build().selectPage(page, queryWrapper);
		// List<YgglMainEmp> ygglMainEmps = ygglMainEmpPage.getRecords();
		return ResultUtil.data(ygglMainEmpPage, "员工搜索成功");
		// return ResultUtil.data(ygglMainEmpPage, ygglMainEmps, "员工搜索成功");
	}

	/**
	 * 导入威力加强版
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/ygdas")
	@ApiOperation(value = "导入威力加强版", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 7)
	public Result<List<YgDrjqbDto>> ygdr(@CurrentUser UserBean userBean, @RequestBody YgDrsDto drList) {
		drList.setOrgCode(userBean.getOrgCode());
		YgDrsDto tofList = errorFilter(drList);// 滤嘴，过滤信息
		if (tofList.getDrList().size() == 0)
			return ResultUtil.data(tofList.getErrorList(), "导入发生错误人员名单");
		YgDrsDto tof = optFilter(tofList);// 彻底规范好数据
		List<YgDrjqbDto> trueList = tof.getDrList();// 拿出正确的信息
		List<YgDrjqbDto> errorList = tof.getErrorList();// 拿出错误的信息
		if (trueList.size() == 0)
			return ResultUtil.data(errorList, "导入发生错误人员名单");
		for (YgDrjqbDto e : trueList) {
			QyzxEmpLogin login = new LambdaQueryChainWrapper<QyzxEmpLogin>(qyzxEmpLoginMapper)
					.eq(QyzxEmpLogin::getPhone, e.getPhone()).one();
			// 证件类型为0
			Integer jobType = Integer.valueOf(e.getJobType());// 工作类型
			Integer syq = Integer.valueOf(e.getSyq());// 试用期
			Integer sex = Integer.valueOf(e.getSex());// 性别,还差一个岗位
			Integer gw = e.getHavebmid();
			String jobNum = e.getYgnbgh();
			Integer jg = e.getJg();
			Date birthday = e.getBirthday();
			// 入职日期
			Date rzdate = new Date();
			SimpleDateFormat straight = new SimpleDateFormat("yyyy-MM-dd");// 正杠
			if (e.getRzTime().indexOf("-") != -1) {
				try {
					rzdate = straight.parse(e.getRzTime());
				} catch (ParseException PException) {
					PException.printStackTrace();
					e.setError("请填写正确的时间格式");
					errorList.add(e);
					continue;
				}
			}
			// 判断是否已有员工登录表
			if (login == null) {// 添加三张表
				QyzxEmpLogin qyzxEmpLogin = QyzxEmpLogin.builder().phone(e.getPhone()).pw(Md5.md5("123456"))
						.sts(CommonEnum.U_STS_ON.getType()).orgId(userBean.getOrgCode()).username(e.getName()).build();
				if (!qyzxEmpLogin.insert()) {
					TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
					e.setError("员工无法添加！");
					errorList.add(e);
					continue;
				}
				// 员工权限表(未定)
				// 员工企业关联表和员工档案,员工成长表(未定)
				QyzxEmpEntAsso.builder().empNum(qyzxEmpLogin.getId()).orgCode(userBean.getOrgCode()).userType(2)
						.status(1).build().insert();// userType2普通员工，status1正常
				YgglMainEmp emp = YgglMainEmp.builder().name(e.getName()).phone(e.getPhone()).zjType(0).zjNum(e.getZj())
						.jobType(jobType).rzTime(rzdate).updateTime(new Date()).updateMan(userBean.getEmpNum()).syq(syq)
						.sex(sex).jobNum(jobNum).bmgwId(gw).empNum(qyzxEmpLogin.getId()).orgCode(userBean.getOrgCode())
						.build();
				emp.insert();
				new LambdaUpdateChainWrapper<YgglMainEmp>(ygglMainEmpMapper)
						.eq(YgglMainEmp::getOrgCode, userBean.getOrgCode()).eq(YgglMainEmp::getId, emp.getId())
						.set(birthday != null, YgglMainEmp::getBirthday, birthday)
						.set(jg != null && jg != 0, YgglMainEmp::getJg, jg).update();

				// return ResultUtil.data(ygglMainEmp, "新添加员工档案成功!");
			} else {
				// 添加两张表
				YgglMainEmp ishad = YgglMainEmp.builder().build().selectOne(new QueryWrapper<YgglMainEmp>()
						.eq("phone", e.getPhone()).eq("org_code", userBean.getOrgCode()));
				if (ishad == null) {
					// 员工权限表(未定)
					QyzxEmpEntAsso.builder().empNum(login.getId()).orgCode(userBean.getOrgCode()).userType(2).status(1)
							.build().insert();// userType2普通员工，status1正常
					YgglMainEmp emp = YgglMainEmp.builder().name(e.getName()).phone(e.getPhone()).zjType(0)
							.zjNum(e.getZj()).jobType(jobType).rzTime(rzdate).updateTime(new Date())
							.updateMan(userBean.getEmpNum()).syq(syq).sex(sex).jobNum(jobNum).empNum(login.getId())
							.orgCode(userBean.getOrgCode()).build();
					emp.insert();
					new LambdaUpdateChainWrapper<YgglMainEmp>(ygglMainEmpMapper)
							.eq(YgglMainEmp::getOrgCode, userBean.getOrgCode()).eq(YgglMainEmp::getId, emp.getId())
							.set(birthday != null, YgglMainEmp::getBirthday, birthday)
							.set(jg != null && jg != 0, YgglMainEmp::getJg, jg).update();
				} else {
					e.setError("该手机号码已被使用");
					errorList.add(e);
					continue;

				}
			}
		}
		if (errorList.size() == 0) {
			return ResultUtil.success("员工全部导入成功！");
		}
		return ResultUtil.data(errorList, "导入发生错误人员名单");
	}

	// 错误选项过滤器
	public YgDrsDto errorFilter(YgDrsDto ygDrsDto) {
		List<YgDrjqbDto> drList = ygDrsDto.getDrList();
		List<YgDrjqbDto> newList = new ArrayList<YgDrjqbDto>(drList);
		List<YgDrjqbDto> errorList = ygDrsDto.getErrorList();
		Integer orgCode = ygDrsDto.getOrgCode();

		Iterator<YgDrjqbDto> itDr = drList.iterator();
		@SuppressWarnings("unused")
		YgDrjqbDto a = drList.get(0);// 一个员工导入
		Integer size = drList.size();
		for (Integer i = 0; i < size; i++) {//
			YgDrjqbDto d = newList.get(i);// 计数器
			if (itDr.hasNext()) {
				a = itDr.next();

			}
			// 请填写必填项
			String name = newList.get(i).getName();
			String phone = newList.get(i).getPhone();
			String sex = newList.get(i).getSex();
			String zj = newList.get(i).getZj();
			if (StrUtil.hasBlank(name) || StrUtil.hasBlank(phone) || StrUtil.hasBlank(sex) || StrUtil.hasBlank(zj)) {
				d.setError("请填写必填项");
				errorList.add(d);
				itDr.remove();
				i++;
				continue;
			}
			// 手机号码格式不对
			String regex = "^((13[0-9])|(14[5|7])|(15([0-3]|[5-9]))|(17[013678])|(18[0,5-9]))\\d{8}$";
			if (phone.length() != 11) {
				d.setError("手机号应为11位数");
				errorList.add(d);
				itDr.remove();
				i++;
				continue;
			}
			Pattern p = Pattern.compile(regex);
			Matcher m = p.matcher(phone);
			boolean isMatch = m.matches();
			if (!isMatch) {
				d.setError("手机号格式不对");
				errorList.add(d);
				itDr.remove();
				i++;
				continue;
			}
			// 手机号码已被使用
			QyzxEmpLogin login = new LambdaQueryChainWrapper<QyzxEmpLogin>(qyzxEmpLoginMapper)
					.eq(QyzxEmpLogin::getPhone, phone).eq(QyzxEmpLogin::getOrgId, orgCode).one();
			if (login != null) {
				d.setError("手机号码已被使用");
				errorList.add(d);
				itDr.remove();
				i++;
				continue;
			}
			// 证件号码信息有误
			if (zj == null || "".equals(zj)) {
				d.setError("证件号码信息有误");
				errorList.add(d);
				itDr.remove();
				i++;
				continue;
			}
			String regularExpression = "(^[1-9]\\d{5}(18|19|20)\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$)|"
					+ "(^[1-9]\\d{5}\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}$)";
			boolean matches = zj.matches(regularExpression);
			if (!matches) {
				d.setError("证件号码信息有误");
				errorList.add(d);
				itDr.remove();
				i++;
				continue;
			}
			try {
				if (zj.length() == 18) {
					char[] charArray = zj.toCharArray();
					// 前十七位加权因子
					int[] idCardWi = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
					// 这是除以11后，可能产生的11位余数对应的验证码
					String[] idCardY = { "1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2" };
					int sum = 0;
					for (Integer j = 0; j < idCardWi.length; j++) {
						int current = Integer.parseInt(String.valueOf(charArray[j]));
						int count = current * idCardWi[j];
						sum += count;
					}
					char idCardLast = charArray[17];
					int idCardMod = sum % 11;
					if (idCardY[idCardMod].toUpperCase().equals(String.valueOf(idCardLast).toUpperCase())) {
						// System.out.println("成功，接着完善员工的个人信息");
						String birth = zj.substring(6, 14);
						String birthday = birth.substring(0, 4) + "-" + birth.substring(4, 6) + "-"
								+ birth.substring(6, 8);
						SimpleDateFormat straight = new SimpleDateFormat("yyyy-MM-dd");
						d.setBirthday(straight.parse(birthday));
						d.setJg(Integer.parseInt(zj.substring(0, 6)));
					} else {
						// System.out.println("身份证最后一位:" + String.valueOf(idCardLast).toUpperCase() +
						// "错误,正确的应该是:" + idCardY[idCardMod].toUpperCase());
						// return false;
						d.setError("证件号码信息有误");
						errorList.add(d);
						itDr.remove();
						i++;
						continue;
					}
				} else {
					// 给15位数的添加生日籍贯
					String birth = zj.substring(6, 12);
					String birthday = "19" + birth.substring(0, 2) + "-" + birth.substring(2, 4) + "-"
							+ birth.substring(4, 6);
					SimpleDateFormat straight = new SimpleDateFormat("yyyy-MM-dd");
					d.setBirthday(straight.parse(birthday));
					d.setJg(Integer.parseInt(zj.substring(0, 6)));
				}
			} catch (Exception e) {
				e.printStackTrace();
				// System.out.println("异常:" + zj);
				// return false;
				d.setError("证件号码信息有误");
				errorList.add(d);
				itDr.remove();
				i++;
				continue;
			}
			// 部门岗位有误
			String oneb = newList.get(i).getOneb();
			String twob = newList.get(i).getTwob();
			String threeb = newList.get(i).getThreeb();
			String fourb = newList.get(i).getFourb();
			String gw = newList.get(i).getGw();
			String[] bms = { oneb, twob, threeb, fourb };
			if (StrUtil.hasBlank(gw) && StrUtil.hasBlank(oneb) && StrUtil.hasBlank(twob) && StrUtil.hasBlank(threeb)
					&& StrUtil.hasBlank(fourb)) { // 没填写岗位，通过~ //
			} else {
				// 填写了部门岗位,办他！
				Integer isHaveBmgw = isHavebmgw(bms, gw, orgCode);
				if (isHaveBmgw == 0) {
					d.setError("部门岗位有误");
					errorList.add(d);
					itDr.remove();
					i++;
					continue;
				} else {
					// 获取到部门岗位id啦！
					d.setHavebmid(isHaveBmgw);
				}
			}

		} // for循环完毕！
		YgDrsDto tofList = new YgDrsDto(drList, errorList, orgCode);
		return tofList;
	}

	// 选填项过滤器
	public YgDrsDto optFilter(YgDrsDto ygDrsDto) {
		List<YgDrjqbDto> drList = ygDrsDto.getDrList();
		List<YgDrjqbDto> newList = new ArrayList<YgDrjqbDto>(drList);
		List<YgDrjqbDto> errorList = ygDrsDto.getErrorList();
		Integer orgCode = ygDrsDto.getOrgCode();

		Iterator<YgDrjqbDto> itDr = drList.iterator();
		@SuppressWarnings("unused")
		YgDrjqbDto a = drList.get(0);// 一个员工导入
		Integer size = drList.size();
		for (Integer i = 0; i < size; i++) {//
			YgDrjqbDto d = newList.get(i);// 计数器
			if (itDr.hasNext()) {
				a = itDr.next();
			}
			// for (YgDrjqbDto d : drList) {
			String ygnbgh = d.getYgnbgh();
			String sex = d.getSex();
			String jobType = d.getJobType();
			String jobStatus = d.getJobStatus();
			String rzTime = d.getRzTime();
			String syq = d.getSyq();

			String zy = d.getZy();
			String address = d.getAddress();
			String hjAddress = d.getHkAddress();
			String qq = d.getQq();
			String weixin = d.getWeixin();
			String email = d.getEmail();
			String[] bathroom = { ygnbgh, sex, jobType, jobStatus, rzTime, syq, zy, address, hjAddress, qq, weixin,
					email };
			boolean child = takeshower(bathroom);
			if (child == false) {
				d.setError("填写内容不要大于50字数");
				errorList.add(d);
				itDr.remove();
				i++;
				continue;
			}
			// 公司内部工号
			if (ygnbgh != null && ygnbgh.length() != 0) {
				d.setYgnbgh(ygnbgh.trim());
			} else {
				SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
				String bh = format.format(new Date()) + orgCode + i + System.currentTimeMillis();
				d.setYgnbgh(bh);
			}
			// 男女(最大优化)
			d.setSex(YgEnumInterface.sex.isMan(sex));
			// 工作性质(最大优化)
			d.setJobType(YgEnumInterface.YgJobType.choose(jobType));
			// 员工状态(最大优化)
			d.setJobStatus(YgEnumInterface.jobStatus.isZhen(jobStatus));
			// 入职日期(最大优化)
			d.setRzTime(YgEnumInterface.rzTime.tranTime2(YgEnumInterface.rzTime.tranTime(rzTime)));
			// 试用期(最大优化)
			d.setSyq(YgEnumInterface.syq.choose(syq));
		}
		YgDrsDto clear = new YgDrsDto(drList, errorList, orgCode);
		return clear;
	}

	// 浴池,洗去选填项字节大于100的选项
	public boolean takeshower(String[] bathroom) {
		for (String b : bathroom) {
			if (b.length() > 100) {
				return false;
			}
		}
		return true;
	}

	// 判断是否导入组织部门
	public Integer isHavebmgw(String[] bms, String gw, Integer orgCode) {
		// 将姓名转为部门岗位对象
		List<ZzglBmgwM> gwList = new ArrayList<ZzglBmgwM>();
		// 判断有几个部门,且这几个部门是否属实,里面不包括岗位
		for (String bm : bms) {
			if (!StrUtil.hasBlank(bm)) {
				ZzglBmgwM ibm = new LambdaQueryChainWrapper<ZzglBmgwM>(zzglBmgwMMapper).eq(ZzglBmgwM::getName, bm)
						.eq(ZzglBmgwM::getOrgCode, orgCode).eq(ZzglBmgwM::getType, 0).one(); // 选择部门类型0为部门，1为岗位
				if (ibm == null) {
					return 0;
				} // 找不到有相关名称的部门则报错
				gwList.add(ibm);
			} else {
				break;
			}
		}
		Integer qiantao = qiantao(gwList, gw, 0, orgCode);
		if (qiantao != 0) {
			return qiantao;// 组织部门成立！
		} else {
			return 0;// 失败
		}

	};

	// 判断是否导入组织部门的嵌套并寻找到正确岗位id
	public Integer qiantao(List<ZzglBmgwM> gwList, String gw, Integer upid, Integer orgCode) {
		// 重写
		if (upid != 0 && !gwList.get(0).getUpId().equals(upid)) {
			return 0;
		}
		upid = gwList.get(0).getId();

		if (gwList.size() == 1) {
			ZzglBmgwM igw = new LambdaQueryChainWrapper<ZzglBmgwM>(zzglBmgwMMapper).eq(ZzglBmgwM::getName, gw)
					.eq(ZzglBmgwM::getUpId, upid).eq(ZzglBmgwM::getOrgCode, orgCode).eq(ZzglBmgwM::getType, 1).one();
			if (igw == null) {
				return 0;
			}
			return igw.getId();
		}
		gwList.remove(0);
		Integer q = qiantao(gwList, gw, upid, orgCode);
		return q;
	};

	/**
	 * 导出员工
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/ygdas")
	@ApiOperation(value = "导出", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 8)
	public Result<List<YgglMainEmp>> selectygdas(@CurrentUser UserBean userBean) {
		int[] jList = { 1, 2, 3 };
		List<YgglMainEmp> list = new LambdaQueryChainWrapper<YgglMainEmp>(ygglMainEmpMapper)
				.eq(YgglMainEmp::getOrgCode, userBean.getOrgCode()).in(YgglMainEmp::getJobStatus, jList).list();
		return ResultUtil.data(list, "导出员工成功");
	}

	/**
	 * 获取员工教育经历表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/jyjlb")
	@ApiOperation(value = "获取员工教育经历表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 9)
	public Result<List<YgglAttaJyjlb>> selectjyjlb(@CurrentUser UserBean userBean) {
		List<YgglAttaJyjlb> ygglAttaJyjlbss = YgglAttaJyjlb.builder().build()
				.selectList(new QueryWrapper<YgglAttaJyjlb>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaJyjlbss, "获取员工教育经历表成功");
	}

	// 获取员工教育经历表
	@GetMapping(value = "/jyjlb/{empNum}")
	@ApiOperation(value = "获取员工教育经历表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 10)
	public Result<List<YgglAttaJyjlb>> selectjyjlb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaJyjlb> ygglAttaJyjlbs = YgglAttaJyjlb.builder().build().selectList(
				new QueryWrapper<YgglAttaJyjlb>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaJyjlbs, "获取员工教育经历表成功");
	}

	/**
	 * 添加/修改员工教育经历表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/jyjlb")
	@ApiOperation(value = "添加/修改员工教育经历表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 11)
	public Result<YgglAttaJyjlb> addjyjlb(@CurrentUser UserBean userBean, @RequestBody YgglAttaJyjlb ygglAttaJyjlb) {
		ygglAttaJyjlb.setEmpNum(ygglAttaJyjlb.getEmpNum());
		ygglAttaJyjlb.setOrgCode(userBean.getOrgCode());
		ygglAttaJyjlb.insertOrUpdate();
		return ResultUtil.data(ygglAttaJyjlb, "添加/修改员工教育经历表成功");
	}

	/**
	 * 删除员工教育经历表
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/jyjlb/{id}")
	@ApiOperation(value = "删除员工教育经历表", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 12)
	public Result<Boolean> deljyjlb(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaJyjlb.builder().build()
				.delete(new QueryWrapper<YgglAttaJyjlb>().eq("org_code", orgCode).eq("id", id)), "删除员工教育经历表成功");
	}

	/**
	 * 获取员工培训经历信息表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/pxjlxxb")
	@ApiOperation(value = "获取员工培训经历信息表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 13)
	public Result<List<YgglAttaPxjlxxb>> selectpxjlxxb(@CurrentUser UserBean userBean) {
		List<YgglAttaPxjlxxb> ygglAttaPxjlxxbs = YgglAttaPxjlxxb.builder().build()
				.selectList(new QueryWrapper<YgglAttaPxjlxxb>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaPxjlxxbs, "获取员工培训经历信息表成功");
	}

	// 获取员工培训经历信息表
	@GetMapping(value = "/pxjlxxb/{empNum}")
	@ApiOperation(value = "获取员工培训经历信息表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 14)
	public Result<List<YgglAttaPxjlxxb>> selectpxjlxxb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaPxjlxxb> ygglAttaPxjlxxbs = YgglAttaPxjlxxb.builder().build().selectList(
				new QueryWrapper<YgglAttaPxjlxxb>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaPxjlxxbs, "获取员工培训经历信息表成功");
	}

	/**
	 * 添加/修改员工培训经历信息表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/pxjlxxb")
	@ApiOperation(value = "添加/修改员工培训经历信息表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 15)
	public Result<YgglAttaPxjlxxb> addpxjlxxb(@CurrentUser UserBean userBean,
			@RequestBody YgglAttaPxjlxxb ygglAttaPxjlxxb) {
		ygglAttaPxjlxxb.setEmpNum(ygglAttaPxjlxxb.getEmpNum());
		ygglAttaPxjlxxb.setOrgCode(userBean.getOrgCode());
		ygglAttaPxjlxxb.insertOrUpdate();
		return ResultUtil.data(ygglAttaPxjlxxb, "添加/修改员工培训经历信息表成功");
	}

	/**
	 * 删除员工培训经历信息表
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/pxjlxxb/{id}")
	@ApiOperation(value = "删除员工培训经历信息表", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 16)
	public Result<Boolean> delpxjlxxb(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaPxjlxxb.builder().build()
				.delete(new QueryWrapper<YgglAttaPxjlxxb>().eq("org_code", orgCode).eq("id", id)), "删除员工培训经历信息表成功");
	}

	/**
	 * 获取员工工作经历表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/gzjlb")
	@ApiOperation(value = "获取员工工作经历表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 17)
	public Result<List<YgglAttaGzjlb>> selectgzjlb(@CurrentUser UserBean userBean) {
		List<YgglAttaGzjlb> ygglAttaGzjlbs = YgglAttaGzjlb.builder().build()
				.selectList(new QueryWrapper<YgglAttaGzjlb>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaGzjlbs, "获取员工工作经历表成功");
	}

	// 获取员工工作经历表
	@GetMapping(value = "/gzjlb/{empNum}")
	@ApiOperation(value = "获取员工工作经历表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 18)
	public Result<List<YgglAttaGzjlb>> selectgzjlb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaGzjlb> ygglAttaGzjlbs = YgglAttaGzjlb.builder().build().selectList(
				new QueryWrapper<YgglAttaGzjlb>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaGzjlbs, "获取员工工作经历表成功");
	}

	/**
	 * 添加/修改员工工作经历表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/gzjlb")
	@ApiOperation(value = "添加/修改员工工作经历表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 19)
	public Result<YgglAttaGzjlb> addgzjlb(@CurrentUser UserBean userBean, @RequestBody YgglAttaGzjlb ygglAttaGzjlb) {
		ygglAttaGzjlb.setEmpNum(ygglAttaGzjlb.getEmpNum());
		ygglAttaGzjlb.setOrgCode(userBean.getOrgCode());
		ygglAttaGzjlb.insertOrUpdate();
		return ResultUtil.data(ygglAttaGzjlb, "添加/修改员工工作经历表成功");
	}

	/**
	 * 删除员工工作经历表
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/gzjlb/{id}")
	@ApiOperation(value = "删除员工工作经历表", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 20)
	public Result<Boolean> delgzjlb(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaGzjlb.builder().build()
				.delete(new QueryWrapper<YgglAttaGzjlb>().eq("org_code", orgCode).eq("id", id)), "删除员工工作经历表成功");
	}

	/**
	 * 获取员工职称信息表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/zcxxb")
	@ApiOperation(value = "获取员工职称信息表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 21)
	public Result<List<YgglAttaZcxxb>> selectzcxxb(@CurrentUser UserBean userBean) {
		List<YgglAttaZcxxb> ygglAttaZcxxbs = YgglAttaZcxxb.builder().build()
				.selectList(new QueryWrapper<YgglAttaZcxxb>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaZcxxbs, "获取员工职称信息表成功");
	}

	// 获取员工职称信息表
	@GetMapping(value = "/zcxxb/{empNum}")
	@ApiOperation(value = "获取员工职称信息表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 22)
	public Result<List<YgglAttaZcxxb>> selectzcxxb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaZcxxb> ygglAttaZcxxbs = YgglAttaZcxxb.builder().build().selectList(
				new QueryWrapper<YgglAttaZcxxb>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaZcxxbs, "获取员工职称信息表成功");
	}

	/**
	 * 添加/修改员工职称信息表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/zcxxb")
	@ApiOperation(value = "添加/修改员工职称信息表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 23)
	public Result<YgglAttaZcxxb> addzcxxb(@CurrentUser UserBean userBean, @RequestBody YgglAttaZcxxb ygglAttaZcxxb) {
		ygglAttaZcxxb.setEmpNum(ygglAttaZcxxb.getEmpNum());
		ygglAttaZcxxb.setOrgCode(userBean.getOrgCode());
		ygglAttaZcxxb.insertOrUpdate();
		return ResultUtil.data(ygglAttaZcxxb, "添加/修改员工职称信息表成功");
	}

	/**
	 * 删除员工职称信息表
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/zcxxb/{id}")
	@ApiOperation(value = "删除员工职称信息表", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 24)
	public Result<Boolean> delzcxxb(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaZcxxb.builder().build()
				.delete(new QueryWrapper<YgglAttaZcxxb>().eq("org_code", orgCode).eq("id", id)), "删除员工职称信息表成功");
	}

	/**
	 * 获取员工证书证件表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/zszjb")
	@ApiOperation(value = "获取员工证书证件表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 25)
	public Result<List<YgglAttaZszjb>> selectzszjb(@CurrentUser UserBean userBean) {
		List<YgglAttaZszjb> ygglAttaZszjbs = YgglAttaZszjb.builder().build()
				.selectList(new QueryWrapper<YgglAttaZszjb>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaZszjbs, "获取员工证书证件表成功");
	}

	// 获取员工证书证件表
	@GetMapping(value = "/zszjb/{empNum}")
	@ApiOperation(value = "获取员工证书证件表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 26)
	public Result<List<YgglAttaZszjb>> selectzszjb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaZszjb> ygglAttaZszjbs = YgglAttaZszjb.builder().build().selectList(
				new QueryWrapper<YgglAttaZszjb>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaZszjbs, "获取员工证书证件表成功");
	}

	/**
	 * 添加/修改员工证书证件表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/zszjb")
	@ApiOperation(value = "添加/修改员工证书证件表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 27)
	public Result<YgglAttaZszjb> addzszjb(@CurrentUser UserBean userBean, @RequestBody YgglAttaZszjb ygglAttaZszjb) {
		ygglAttaZszjb.setEmpNum(ygglAttaZszjb.getEmpNum());
		ygglAttaZszjb.setOrgCode(userBean.getOrgCode());
		ygglAttaZszjb.insertOrUpdate();
		return ResultUtil.data(ygglAttaZszjb, "添加/修改员工证书证件表成功");
	}

	/**
	 * 删除员工证书证件表
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/zszjb/{id}")
	@ApiOperation(value = "删除员工证书证件表", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 28)
	public Result<Boolean> delzszjb(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaZszjb.builder().build()
				.delete(new QueryWrapper<YgglAttaZszjb>().eq("org_code", orgCode).eq("id", id)), "删除员工证书证件表成功");
	}

	/**
	 * 获取员工联系信息表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/lxxxb")
	@ApiOperation(value = "获取员工联系信息表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 29)
	public Result<List<YgglAttaLxxxb>> selectlxxxb(@CurrentUser UserBean userBean) {
		List<YgglAttaLxxxb> ygglAttaLxxxbs = YgglAttaLxxxb.builder().build()
				.selectList(new QueryWrapper<YgglAttaLxxxb>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaLxxxbs, "获取员工联系信息表成功");
	}

	// 获取员工联系信息表
	@GetMapping(value = "/lxxxb/{empNum}")
	@ApiOperation(value = "获取员工联系信息表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 30)
	public Result<List<YgglAttaLxxxb>> selectlxxxb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaLxxxb> ygglAttaLxxxbs = YgglAttaLxxxb.builder().build().selectList(
				new QueryWrapper<YgglAttaLxxxb>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaLxxxbs, "获取员工联系信息表成功");
	}

	/**
	 * 添加/修改员工联系信息表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/lxxxb")
	@ApiOperation(value = "添加/修改员工联系信息表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 31)
	public Result<YgglAttaLxxxb> addlxxxb(@CurrentUser UserBean userBean, @RequestBody YgglAttaLxxxb ygglAttaLxxxb) {
		ygglAttaLxxxb.setEmpNum(ygglAttaLxxxb.getEmpNum());
		ygglAttaLxxxb.setOrgCode(userBean.getOrgCode());
		ygglAttaLxxxb.insertOrUpdate();
		return ResultUtil.data(ygglAttaLxxxb, "添加/修改员工联系信息表成功");
	}

	/**
	 * 删除员工联系信息表
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/lxxxb/{id}")
	@ApiOperation(value = "删除员工联系信息表", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 32)
	public Result<Boolean> dellxxxb(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaLxxxb.builder().build()
				.delete(new QueryWrapper<YgglAttaLxxxb>().eq("org_code", orgCode).eq("id", id)), "删除员工联系信息表成功");
	}

	/**
	 * 获取员工紧急联系人表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/jjlxr")
	@ApiOperation(value = "获取员工紧急联系人表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 33)
	public Result<List<YgglAttaJjlxr>> selectjjlxr(@CurrentUser UserBean userBean) {
		List<YgglAttaJjlxr> ygglAttaJjlxrs = YgglAttaJjlxr.builder().build()
				.selectList(new QueryWrapper<YgglAttaJjlxr>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaJjlxrs, "获取员工紧急联系人表成功");
	}

	// 获取员工紧急联系人表
	@GetMapping(value = "/jjlxr/{empNum}")
	@ApiOperation(value = "获取员工紧急联系人表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 34)
	public Result<List<YgglAttaJjlxr>> selectjjlxr(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaJjlxr> ygglAttaJjlxrs = YgglAttaJjlxr.builder().build().selectList(
				new QueryWrapper<YgglAttaJjlxr>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaJjlxrs, "获取员工紧急联系人表成功");
	}

	/**
	 * 添加/修改员工紧急联系人表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/jjlxr")
	@ApiOperation(value = "添加/修改员工紧急联系人表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 35)
	public Result<YgglAttaJjlxr> addjjlxr(@CurrentUser UserBean userBean, @RequestBody YgglAttaJjlxr ygglAttaJjlxr) {
		ygglAttaJjlxr.setEmpNum(ygglAttaJjlxr.getEmpNum());
		ygglAttaJjlxr.setOrgCode(userBean.getOrgCode());
		ygglAttaJjlxr.insertOrUpdate();
		return ResultUtil.data(ygglAttaJjlxr, "添加/修改员工紧急联系人表成功");
	}

	/**
	 * 删除员工紧急联系人表
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/jjlxr/{id}")
	@ApiOperation(value = "删除员工紧急联系人表", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 36)
	public Result<Boolean> deljjlxr(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaJjlxr.builder().build()
				.delete(new QueryWrapper<YgglAttaJjlxr>().eq("org_code", orgCode).eq("id", id)), "删除员工紧急联系人表成功");
	}

	// 获取工资卡信息
	/**
	 * 获取员工工资卡信息
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/gzk")
	@ApiOperation(value = "获取员工工资卡信息", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 37)
	public Result<List<YgglAttaGzk>> selectgzk(@CurrentUser UserBean userBean) {
		List<YgglAttaGzk> ygglAttaGzks = YgglAttaGzk.builder().build().selectList(new QueryWrapper<YgglAttaGzk>()
				.eq("org_code", userBean.getOrgCode()).eq("emp_num", userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaGzks, "获取工资卡信息成功");
	}

	// 获取工资卡信息
	@GetMapping(value = "/gzk/{empNum}")
	@ApiOperation(value = "获取员工工资卡信息(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 38)
	public Result<List<YgglAttaGzk>> selectgzk(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaGzk> ygglAttaGzks = YgglAttaGzk.builder().build().selectList(
				new QueryWrapper<YgglAttaGzk>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaGzks, "获取工资卡信息成功");
	}

	/**
	 * 添加/修改工资卡信息
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/gzk")
	@ApiOperation(value = "添加/修改工资卡信息", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 39)
	public Result<YgglAttaGzk> addgzk(@CurrentUser UserBean userBean, @RequestBody YgglAttaGzk ygglAttaGzk) {
		ygglAttaGzk.setEmpNum(ygglAttaGzk.getEmpNum());
		ygglAttaGzk.setOrgCode(userBean.getOrgCode());
		ygglAttaGzk.insertOrUpdate();
		return ResultUtil.data(ygglAttaGzk, "添加/修改工资卡信息成功");
	}

	/**
	 * 删除工资卡信息
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/gzk/{id}")
	@ApiOperation(value = "删除工资卡信息", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 40)
	public Result<Boolean> delgzk(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaGzk.builder().build()
				.delete(new QueryWrapper<YgglAttaGzk>().eq("org_code", orgCode).eq("id", id)), "删除工资卡信息成功");
	}

	/**
	 * 获取员工合同信息表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/htxxb")
	@ApiOperation(value = "获取员工合同信息表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 41)
	public Result<List<YgglAttaHtxxb>> selecthtxxb(@CurrentUser UserBean userBean) {
		List<YgglAttaHtxxb> ygglAttaHtxxbs = YgglAttaHtxxb.builder().build()
				.selectList(new QueryWrapper<YgglAttaHtxxb>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaHtxxbs, "获取员工合同信息表成功");
	}

	// 获取员工合同信息表
	@GetMapping(value = "/htxxb/{empNum}")
	@ApiOperation(value = "获取员工合同信息表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 42)
	public Result<List<YgglAttaHtxxb>> selecthtxxb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaHtxxb> ygglAttaHtxxbs = YgglAttaHtxxb.builder().build().selectList(
				new QueryWrapper<YgglAttaHtxxb>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaHtxxbs, "获取员工合同信息表成功");
	}

	/**
	 * 添加/修改员工合同信息表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/htxxb")
	@ApiOperation(value = "添加/修改员工合同信息表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 43)
	public Result<YgglAttaHtxxb> addhtxxb(@CurrentUser UserBean userBean, @RequestBody YgglAttaHtxxb ygglAttaHtxxb) {
		ygglAttaHtxxb.setEmpNum(ygglAttaHtxxb.getEmpNum());
		ygglAttaHtxxb.setOrgCode(userBean.getOrgCode());
		ygglAttaHtxxb.insertOrUpdate();
		return ResultUtil.data(ygglAttaHtxxb, "添加/修改员工合同信息表成功");
	}

	/**
	 * 删除员工合同信息表
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/htxxb/{id}")
	@ApiOperation(value = "删除员工合同信息表", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 44)
	public Result<Boolean> delhtxxb(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaHtxxb.builder().build()
				.delete(new QueryWrapper<YgglAttaHtxxb>().eq("org_code", orgCode).eq("id", id)), "删除员工合同信息表成功");
	}

	/**
	 * 获取员工材料附件表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/clfjb")
	@ApiOperation(value = "获取员工材料附件表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 45)
	public Result<List<YgglAttaClfjb>> selectclfjb(@CurrentUser UserBean userBean) {
		List<YgglAttaClfjb> ygglAttaClfjbs = YgglAttaClfjb.builder().build()
				.selectList(new QueryWrapper<YgglAttaClfjb>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaClfjbs, "获取员工材料附件表成功");
	}

	// 获取员工材料附件表
	@GetMapping(value = "/clfjb/{empNum}")
	@ApiOperation(value = "获取员工材料附件表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 46)
	public Result<List<YgglAttaClfjb>> selectclfjb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaClfjb> ygglAttaClfjbs = YgglAttaClfjb.builder().build().selectList(
				new QueryWrapper<YgglAttaClfjb>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaClfjbs, "获取员工材料附件表成功");
	}

	/**
	 * 添加/修改员工材料附件表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/clfjb")
	@ApiOperation(value = "添加/修改员工材料附件表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 47)
	public Result<YgglAttaClfjb> addclfjb(@CurrentUser UserBean userBean, @RequestBody YgglAttaClfjb ygglAttaClfjb) {
		ygglAttaClfjb.setOrgCode(userBean.getOrgCode());
		ygglAttaClfjb.setEmpNum(ygglAttaClfjb.getEmpNum());
		ygglAttaClfjb.insertOrUpdate();
		return ResultUtil.data(ygglAttaClfjb, "添加/修改员工材料附件表成功");
	}

	/**
	 * 删除员工材料附件表
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/clfjb/{id}")
	@ApiOperation(value = "删除员工材料附件表", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 48)
	public Result<Boolean> delclfjb(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaClfjb.builder().build()
				.delete(new QueryWrapper<YgglAttaClfjb>().eq("org_code", orgCode).eq("id", id)), "删除员工材料附件表成功");
	}

	/**
	 * 获取成长记录表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/czjlb")
	@ApiOperation(value = "获取成长记录表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 49)
	public Result<List<YgglAttaCzjlb>> selectczjlb(@CurrentUser UserBean userBean) {
		List<YgglAttaCzjlb> ygglAttaCzjlbs = YgglAttaCzjlb.builder().build()
				.selectList(new QueryWrapper<YgglAttaCzjlb>().eq("org_code", userBean.getOrgCode()).eq("emp_num",
						userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaCzjlbs, "获取成长记录表成功");
	}

	// 获取成长记录表
	@GetMapping(value = "/czjlb/{empNum}")
	@ApiOperation(value = "获取成长记录表(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 50)
	public Result<List<YgglAttaCzjlb>> selectczjlb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		List<YgglAttaCzjlb> ygglAttaCzjlbs = YgglAttaCzjlb.builder().build().selectList(
				new QueryWrapper<YgglAttaCzjlb>().eq("org_code", userBean.getOrgCode()).eq("emp_num", empNum));
		return ResultUtil.data(ygglAttaCzjlbs, "获取员工成长记录表成功");
	}

	/**
	 * 添加/修改成长记录表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/czjlb")
	@ApiOperation(value = "添加/修改成长记录表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 51)
	public Result<YgglAttaCzjlb> addczjlb(@CurrentUser UserBean userBean, @RequestBody YgglAttaCzjlb ygglAttaCzjlb) {
		ygglAttaCzjlb.setEmpNum(ygglAttaCzjlb.getEmpNum());
		ygglAttaCzjlb.setOrgCode(userBean.getOrgCode());
		ygglAttaCzjlb.insertOrUpdate();
		return ResultUtil.data(ygglAttaCzjlb, "添加/修改成长记录表成功");
	}

	/**
	 * 获取单个离职员工信息(管)
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/lzb/{empNum}")
	@ApiOperation(value = "获取单个离职员工信息(管)", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 52)
	public Result<YgglMainLzb> selectlzb(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {
		YgglMainLzb lzyg = new LambdaQueryChainWrapper<YgglMainLzb>(ygglMainLzbMapper)
				.eq(YgglMainLzb::getOrgCode, userBean.getOrgCode()).eq(YgglMainLzb::getEmpNum, empNum).one();
		return ResultUtil.data(lzyg, "获取单个离职员工信息(管)成功");
	}

	/**
	 * 员工转正
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/ygzz")
	@ApiOperation(value = "员工转正", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 53)
	public Result<Void> ygzz(@CurrentUser UserBean userBean, @RequestBody YgzzDto ygzzDto) {
		UpdateWrapper<YgglMainEmp> updateWrapper = new UpdateWrapper<YgglMainEmp>();
		updateWrapper.eq("emp_num", ygzzDto.getEmpNum());
		YgglMainEmp.builder().jobStatus(2).zzTime(ygzzDto.getZzTime()).sjzzTime(new Date())
				.zzRemark(ygzzDto.getZzRemark()).build().update(updateWrapper);
		return ResultUtil.success("转正成功！");
	}

	/**
	 * 计划离职 type2-3
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/addlzjh")
	@ApiOperation(value = "添加离职计划", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 54)
	public Result<YgglMainLzb> addjhlz(@CurrentUser UserBean userBean, @RequestBody LzygQueryDto lzygQueryDto) {
		QueryWrapper<YgglMainEmp> queryWrapper = new QueryWrapper<YgglMainEmp>();
		queryWrapper.eq("emp_num", lzygQueryDto.getEmpNum()).eq("org_code", userBean.getOrgCode());
		YgglMainEmp ygglMainEmp = YgglMainEmp.builder().build().selectOne(queryWrapper);
		YgglMainLzb ygglMainLzb = YgglMainLzb.builder().empNum(lzygQueryDto.getEmpNum()).build();
		// 移动员工表数据到离职表
		BeanUtil.copyProperties(ygglMainEmp, ygglMainLzb);
		ygglMainLzb.insert();

		UpdateWrapper<YgglMainEmp> updateWrapper = new UpdateWrapper<YgglMainEmp>();
		updateWrapper.eq("emp_num", lzygQueryDto.getEmpNum());
		UpdateWrapper<YgglMainLzb> updateWrapper1 = new UpdateWrapper<YgglMainLzb>();
		updateWrapper1.eq("emp_num", lzygQueryDto.getEmpNum());
		YgglMainEmp.builder().empNum(lzygQueryDto.getEmpNum()).jobStatus(3).build().update(updateWrapper);
		YgglMainLzb.builder().jobStatus(YgEnumInterface.jobStatus.LIZHIZHONG.getType()).lzTime(lzygQueryDto.getLzTime()).lzyy(lzygQueryDto.getLzyy())
				.lzbz(lzygQueryDto.getLzbz()).build().update(updateWrapper1);
		// 删除员工表
//		ygglMainEmp.deleteById();
		// 删除员工登陆表
//		QyzxEmpLogin qyzxEmpLogin = QyzxEmpLogin.builder().id(ygglMainLzb.getEmpNum()).build();
//		qyzxEmpLogin.deleteById();
		return ResultUtil.data(ygglMainLzb, "添加待离职员工成功");
	}

	/**
	 * 确认离职 type3-4
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/qrlz")
	@ApiOperation(value = "确认离职", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 55)
	public Result<Void> addlzb(@CurrentUser UserBean userBean, @RequestBody LzygQueryDto lzygQueryDto) {
		QueryWrapper<YgglMainEmp> queryWrapper = new QueryWrapper<YgglMainEmp>();
		queryWrapper.eq("emp_num", lzygQueryDto.getEmpNum());
		UpdateWrapper<YgglMainEmp> updateWrapper = new UpdateWrapper<YgglMainEmp>();
		updateWrapper.eq("emp_num", lzygQueryDto.getEmpNum());
		UpdateWrapper<YgglMainLzb> updateWrapper1 = new UpdateWrapper<YgglMainLzb>();
		updateWrapper1.eq("emp_num", lzygQueryDto.getEmpNum());
		YgglMainEmp.builder().empNum(lzygQueryDto.getEmpNum()).jobStatus(YgEnumInterface.jobStatus.YILIZHI.getType()).build().update(updateWrapper);
		YgglMainLzb.builder().empNum(lzygQueryDto.getEmpNum()).jobStatus(YgEnumInterface.jobStatus.YILIZHI.getType()).sjlzTime(new Date()).build()
				.update(updateWrapper1);
		// 查询该员工的关联表
		QueryWrapper<QyzxEmpEntAsso> queryWrapper1 = new QueryWrapper<QyzxEmpEntAsso>();
		queryWrapper1.eq("emp_num", lzygQueryDto.getEmpNum());
		// 确认离职 删除员工关联表
		QyzxEmpEntAsso qyzxEmpEntAsso = QyzxEmpEntAsso.builder().empNum(lzygQueryDto.getEmpNum()).build();
		qyzxEmpEntAsso.delete(queryWrapper1);
		return ResultUtil.success("确认离职员工成功");
	}

	/**
	 * 放弃离职 type3-2
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/fqlz")
	@ApiOperation(value = "放弃离职", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 56)
	public Result<Void> fqlz(@CurrentUser UserBean userBean, @RequestBody LzygQueryDto lzygQueryDto) {
		UpdateWrapper<YgglMainEmp> updateWrapper = new UpdateWrapper<YgglMainEmp>();
		updateWrapper.eq("emp_num", lzygQueryDto.getEmpNum());
		YgglMainEmp.builder().jobStatus(YgEnumInterface.jobStatus.ZHENSHI.getType()).build().update(updateWrapper);
		QueryWrapper<YgglMainLzb> queryWrapper = new QueryWrapper<YgglMainLzb>();
		queryWrapper.eq("emp_num", lzygQueryDto.getEmpNum());
		// 删除离职表
		YgglMainLzb.builder().id(lzygQueryDto.getEmpNum()).build().delete(queryWrapper);

		return ResultUtil.success("放弃成功");
	}

	@PostMapping(value = "/tzlzyy")
	@ApiOperation(value = "调整离职", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 56)
	public Result<YgglMainLzb> tzlzyy(@CurrentUser UserBean userBean, @RequestBody YgglMainLzb ygglMainLzb) {

		if (ygglMainLzb.getEmpNum() != null) {
			UpdateWrapper<YgglMainLzb> updateWrapper = new UpdateWrapper<YgglMainLzb>();
			updateWrapper.eq("org_code", userBean.getOrgCode()).eq("emp_num", ygglMainLzb.getEmpNum());
			ygglMainLzb.update(updateWrapper);
			return ResultUtil.data(ygglMainLzb, "修改成功");
		}
		return ResultUtil.error("请确认该员工是否存在！");

	}

	/**
	 * 查询离职员工列表
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/querylzyg")
	@ApiOperation(value = "查询离职员工列表", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 57)
	public Result<Object> querylzyg(@CurrentUser UserBean userBean, @RequestBody LzbQueryDto lzygQueryDto) {
		lzygQueryDto.setOrgCode(userBean.getOrgCode());

		IPage<YgglMainLzb> page = new Page<YgglMainLzb>(
				lzygQueryDto.getCurrentPage() == null ? 1 : lzygQueryDto.getCurrentPage(),
				lzygQueryDto.getTotalPage() == null ? 10 : lzygQueryDto.getTotalPage());
		List<YgglMainLzb> lzb = ygglMainLzbMapper.queryLzb(page, lzygQueryDto);
		return ResultUtil.data(page, lzb, "离职员工搜索成功");
	}

	/**
	 * 展示民族/展示所有民族
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/mz/{id}")
	@ApiOperation(value = "展示民族/展示所有民族", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 59)
	public Result<List<YgmzDto>> selectmzs(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		if (id == null || id == 0) {
			List<YgmzDto> allmz = new LambdaQueryChainWrapper<YgmzDto>(ygMzDtoMapper).list();
			return ResultUtil.data(allmz, "展示所有民族");
		}
		List<YgmzDto> mz = new LambdaQueryChainWrapper<YgmzDto>(ygMzDtoMapper).eq(YgmzDto::getNumber, id).list();
		return ResultUtil.data(mz, "展示该民族");
	}

	/**
	 * 展示籍贯/展示所有籍贯
	 * 
	 * @param
	 * @return
	 *//*
		 * @PostMapping(value = "/jg")
		 * 
		 * @ApiOperation(value = "展示籍贯所有省市区", httpMethod = "POST", notes = "接口发布说明")
		 * 
		 * @ApiOperationSupport(order = 60) public Result<List<YgjgDto>>
		 * selectjgs(@CurrentUser UserBean userBean, @RequestBody YgjgDto ygjgDto) {
		 * Integer type = ygjgDto.getType(); Integer upId = ygjgDto.getJgid();
		 * List<YgjgDto> maps = new ArrayList<YgjgDto>(); if (type == 1) { // 省份
		 * List<YgProDto> list = new LambdaQueryChainWrapper<YgProDto>(ygProDtoMapper)
		 * .select(YgProDto::getId, YgProDto::getProvince,
		 * YgProDto::getName).orderByAsc(YgProDto::getProvince) .list(); for (YgProDto
		 * pro : list) { maps.add(new YgjgDto(pro.getId(), pro.getProvince(),
		 * pro.getName(), null)); } } if (type == 2) { // 城市 List<YgCityDto> list = new
		 * LambdaQueryChainWrapper<YgCityDto>(ygCityDtoMapper) .select(YgCityDto::getId,
		 * YgCityDto::getCity, YgCityDto::getName).eq(YgCityDto::getProvince, upId)
		 * .orderByAsc(YgCityDto::getProvince).orderByAsc(YgCityDto::getCity).list();
		 * for (YgCityDto city : list) { maps.add(new YgjgDto(city.getId(),
		 * city.getCity(), city.getName(), null)); } } if (type == 3) { // 地区
		 * List<YgAreaDto> list = new
		 * LambdaQueryChainWrapper<YgAreaDto>(ygAreaDtoMapper) .select(YgAreaDto::getId,
		 * YgAreaDto::getName).eq(YgAreaDto::getCity, upId)
		 * .orderByAsc(YgAreaDto::getProvince).orderByAsc(YgAreaDto::getCity).list();
		 * for (YgAreaDto area : list) { maps.add(new YgjgDto(area.getId(),
		 * area.getId(), area.getName(), null)); } } // IYgjgDto iYgjgDto =
		 * PunishFactory.getPunish(type); // List<String> strings =
		 * iYgjgDto.exePunish(); // System.out.println(strings); if (!maps.isEmpty())
		 * return ResultUtil.data(maps, "展示籍贯成功"); return ResultUtil.success(null); }
		 */

	/**
	 * 展示籍贯/展示所有籍贯(威力增强版)
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/jgshow")
	@ApiOperation(value = "展示籍贯所有省市区威力增强版", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 388)
	public Result<Map<String, String>> selectjgs1(@CurrentUser UserBean userBean, @RequestBody String jgid) {
		// public Result<List<YgjgDto>> selectjgs1(@CurrentUser UserBean userBean,
		// @RequestBody YgjgDto ygjgDto) {
		Integer upId = Integer.valueOf(jgid);
		// List<YgjgDto> maps = new ArrayList<YgjgDto>();
		Map<String, String> maps = new HashMap<String, String>();
		if (upId == null || upId % 100 != 0) { // 省份
			List<YgProDto> list = new LambdaQueryChainWrapper<YgProDto>(ygProDtoMapper)
					.select(YgProDto::getId, YgProDto::getProvince, YgProDto::getName).orderByAsc(YgProDto::getProvince)
					.list();
			list.forEach((item) -> maps.put((item.getId()).toString(), item.getName()));
		} else if (upId % 10000 == 0) {
			List<YgCityDto> list = new LambdaQueryChainWrapper<YgCityDto>(ygCityDtoMapper)
					.select(YgCityDto::getId, YgCityDto::getProvince, YgCityDto::getCity, YgCityDto::getName)
					.eq(YgCityDto::getProvince, upId).orderByAsc(YgCityDto::getProvince).orderByAsc(YgCityDto::getCity)
					.list();
			list.forEach((item) -> maps.put((item.getId()).toString(), item.getName()));

		} else if (upId % 100 == 0) {
			List<YgAreaDto> list = new LambdaQueryChainWrapper<YgAreaDto>(ygAreaDtoMapper)
					.select(YgAreaDto::getId, YgAreaDto::getName).eq(YgAreaDto::getCity, upId)
					.orderByAsc(YgAreaDto::getProvince).orderByAsc(YgAreaDto::getCity).list();
			list.forEach((item) -> maps.put((item.getId()).toString(), item.getName()));
		}
		return ResultUtil.data(maps, "展示籍贯成功");
	}

	/**
	 * 根据籍贯id显示籍贯名
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/jgprint")
	@ApiOperation(value = "根据籍贯id显示籍贯城市名", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 61)
	public Result<YgjgDto> selectjg(@CurrentUser UserBean userBean, @RequestBody YgjgDto jgcity) {
		Integer jgid = jgcity.getJgid();
		Integer cid = jgcity.getType();
		if (jgid != null) {
			String top = jgid.toString().substring(0, 2);
			String isPro = jgid.toString().substring(2, 4);
			String isCity = jgid.toString().substring(4, 6);
			if ("00".equals(isPro)) {
				YgProDto pro = new LambdaQueryChainWrapper<YgProDto>(ygProDtoMapper)
						.select(YgProDto::getId, YgProDto::getName).eq(YgProDto::getId, jgid).one();
				if (pro != null)
					jgcity.setJgname(pro.getName());
			} else if ("00".equals(isCity)) {
				YgProDto pro = new LambdaQueryChainWrapper<YgProDto>(ygProDtoMapper)
						.select(YgProDto::getId, YgProDto::getName).eq(YgProDto::getProvince, top).one();
				YgCityDto city = new LambdaQueryChainWrapper<YgCityDto>(ygCityDtoMapper)
						.select(YgCityDto::getId, YgCityDto::getName).eq(YgCityDto::getCity, jgid).one();
				if (city != null)
					jgcity.setJgname(pro.getName() + city.getName());
			}
			YgProDto pro = new LambdaQueryChainWrapper<YgProDto>(ygProDtoMapper)
					.select(YgProDto::getId, YgProDto::getName).eq(YgProDto::getProvince, top).one();
			YgCityDto city = new LambdaQueryChainWrapper<YgCityDto>(ygCityDtoMapper)
					.select(YgCityDto::getId, YgCityDto::getName).eq(YgCityDto::getCity, Integer.parseInt(top + isPro))
					.one();
			YgAreaDto area = new LambdaQueryChainWrapper<YgAreaDto>(ygAreaDtoMapper)
					.select(YgAreaDto::getId, YgAreaDto::getName).eq(YgAreaDto::getId, jgid).one();
			if (area != null)
				jgcity.setJgname(pro.getName() + city.getName() + area.getName());
		}
		if (cid != null) {
			String top = cid.toString().substring(0, 2);
			String isPro = cid.toString().substring(2, 4);
			String isCity = cid.toString().substring(4, 6);
			if ("00".equals(isPro)) {
				YgProDto pro = new LambdaQueryChainWrapper<YgProDto>(ygProDtoMapper)
						.select(YgProDto::getId, YgProDto::getName).eq(YgProDto::getId, cid).one();
				if (pro != null)
					jgcity.setCityname(pro.getName());
			} else if ("00".equals(isCity)) {
				YgProDto pro = new LambdaQueryChainWrapper<YgProDto>(ygProDtoMapper)
						.select(YgProDto::getId, YgProDto::getName).eq(YgProDto::getProvince, top).one();
				YgCityDto city = new LambdaQueryChainWrapper<YgCityDto>(ygCityDtoMapper)
						.select(YgCityDto::getId, YgCityDto::getName).eq(YgCityDto::getCity, cid).one();
				if (city != null)
					jgcity.setCityname(pro.getName() + city.getName());
			}
			YgProDto pro = new LambdaQueryChainWrapper<YgProDto>(ygProDtoMapper)
					.select(YgProDto::getId, YgProDto::getName).eq(YgProDto::getProvince, top).one();
			YgCityDto city = new LambdaQueryChainWrapper<YgCityDto>(ygCityDtoMapper)
					.select(YgCityDto::getId, YgCityDto::getName).eq(YgCityDto::getCity, Integer.parseInt(top + isPro))
					.one();
			YgAreaDto area = new LambdaQueryChainWrapper<YgAreaDto>(ygAreaDtoMapper)
					.select(YgAreaDto::getId, YgAreaDto::getName).eq(YgAreaDto::getId, cid).one();
			if (area != null)
				jgcity.setCityname(pro.getName() + city.getName() + area.getName());
		}
		return ResultUtil.data(jgcity);
	}

	/**
	 * 查询员工列表
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/queryemp")
	@ApiOperation(value = "查询员工列表", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 62)
	public Result<List<YgQueryDto>> queryEmpMessage(@CurrentUser UserBean userBean) {
		List<YgQueryDto> ygQueryDto = ygglMainEmpMapper.queryEmpMessage(userBean);
		return ResultUtil.data(ygQueryDto, "查询成功");
	}

	/*************** 统计图 ***************/
	/**
	 * 查询统计图
	 * 
	 * @return 成功信息
	 */
	@GetMapping("/yggl")
	@ApiOperation(value = "获取员工管理统计图信息", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 63)
	public Result<Map<String, Object>> queryYgglCartogram(@CurrentUser UserBean userBean) {

		Map<String, Object> map = new HashMap<String, Object>();
		YgglCartogramDto ygglCartogramDto1 = ygglMainEmpMapper.queryPositive(userBean);
		YgglCartogramDto ygglCartogramDto2 = ygglMainEmpMapper.queryAvgAge(userBean);
		YgglCartogramDto ygglCartogramDto3 = ygglMainEmpMapper.queryInduction(userBean);
		YgglCartogramDto ygglCartogramDto4 = ygglMainEmpMapper.queryInservice(userBean);
		YgglCartogramDto ygglCartogramDto5 = ygglMainLzbMapper.queryDeparture(userBean);

		List<YgglCartogramDto> ygglCartogramDto6 = ygglMainEmpMapper.queryDepartmentNum(userBean);
		List<YgglCartogramDto> ygglCartogramDto7 = ygglMainEmpMapper.queryEducation(userBean);
		List<YgglCartogramDto> ygglCartogramDto8 = ygglMainEmpMapper.queryJobsNum(userBean);
		List<YgglCartogramDto> ygglCartogramDto9 = ygglMainEmpMapper.queryEmpAge(userBean);
		List<YgglCartogramDto> ygglCartogramDto10 = ygglMainEmpMapper.queryNativeplace(userBean);
		List<YgglCartogramDto> ygglCartogramDto11 = ygglMainEmpMapper.queryWorkingAge(userBean);

		map.put("positive", ygglCartogramDto1.getPositive());
		map.put("avgAge", ygglCartogramDto2.getAvgAge());
		map.put("induction", ygglCartogramDto3.getInduction());
		map.put("probation", ygglCartogramDto4.getProbation());
		map.put("regular", ygglCartogramDto4.getRegular());
		map.put("departure", ygglCartogramDto5.getDepartureNum());

		map.put("department", ygglCartogramDto6);
		map.put("education", ygglCartogramDto7);
		map.put("jobs", ygglCartogramDto8);
		map.put("empAge", ygglCartogramDto9);
		map.put("nativeplace", ygglCartogramDto10);
		map.put("workingAge", ygglCartogramDto11);

		return ResultUtil.data(map, "查询成功");
	}

	/**
	 * 员工信息统计图
	 * 
	 * @return 成功信息(weng)
	 */
	@GetMapping("/Cartogram")
	@ApiOperation(value = "获取员工管理统计图信息", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 99)
	public Result<YgCartogramDto> ygCartogram(@CurrentUser UserBean userBean) {
		Integer orgCode = userBean.getOrgCode();
		List<YgbintuDto> bintu = ygglMainEmpMapper.rsybp(orgCode);
		/*
		 * bintu.stream().filter(bean ->{ if (bean.getAge() == null) { bean.setAge(0); }
		 * if (bean.getBm() == null) { bean.setBm("未分配"); } if (bean.getGw() == null) {
		 * bean.setGw("未分配"); } if (bean.getProname() == null) { bean.setProname("未分配");
		 * } if (bean.getEduname() == null) { bean.setEduname("未分配"); } if
		 * (bean.getJobStatus() == null) { bean.setJobStatus(-1); } if
		 * (bean.getWorkage() == null) { bean.setWorkage(-1); } return true;
		 * }).collect(Collectors.toList());
		 */
		Map<String, Long> gw = bintu.stream().collect(Collectors.groupingBy(YgbintuDto::getGw, Collectors.counting()));
		List<YgKVDto> gwList = new ArrayList<YgKVDto>();
		for (Map.Entry<String, Long> entry : gw.entrySet()) {
			gwList.add(new YgKVDto(entry.getKey(), entry.getValue().toString()));
		}
		Map<String, Long> bm = bintu.stream().collect(Collectors.groupingBy(YgbintuDto::getBm, Collectors.counting()));
		List<YgKVDto> bmList = new ArrayList<YgKVDto>();
		for (Map.Entry<String, Long> entry : bm.entrySet()) {
			bmList.add(new YgKVDto(entry.getKey(), entry.getValue().toString()));
		}
		// Map<String, Map<String, Long>> bmgw =
		// bintu.stream().collect(Collectors.groupingBy(YgbintuDto::getBm,Collectors.groupingBy(YgbintuDto::getGw,Collectors.counting())));
		Map<String, Long> edu = bintu.stream()
				.collect(Collectors.groupingBy(YgbintuDto::getEduname, Collectors.counting()));
		List<YgKVDto> eduList = new ArrayList<YgKVDto>();
		for (Map.Entry<String, Long> entry : edu.entrySet()) {
			eduList.add(new YgKVDto(entry.getKey(), entry.getValue().toString()));
		}
		Map<Integer, Long> jobStatus = bintu.stream()
				.collect(Collectors.groupingBy(YgbintuDto::getJobStatus, Collectors.counting()));
		List<YgKVDto> jobStatusList = new ArrayList<YgKVDto>();
		for (Entry<Integer, Long> entry : jobStatus.entrySet()) {
			jobStatusList.add(new YgKVDto(entry.getKey().toString(), entry.getValue().toString()));
		}
		Map<String, Long> proname = bintu.stream()
				.collect(Collectors.groupingBy(YgbintuDto::getProname, Collectors.counting()));
		List<YgKVDto> pronameList = new ArrayList<YgKVDto>();
		for (Entry<String, Long> entry : proname.entrySet()) {
			pronameList.add(new YgKVDto(entry.getKey().toString(), entry.getValue().toString()));
		}
		Map<String, Integer> workage = YgEnumInterface.workage.choose(bintu);
		List<YgKVDto> workageList = new ArrayList<YgKVDto>();
		for (Entry<String, Integer> entry : workage.entrySet()) {
			workageList.add(new YgKVDto(entry.getKey().toString(), entry.getValue().toString()));
		}
		Map<String, Integer> age = YgEnumInterface.age.choose(bintu);
		List<YgKVDto> ageList = new ArrayList<YgKVDto>();
		for (Entry<String, Integer> entry : age.entrySet()) {
			ageList.add(new YgKVDto(entry.getKey().toString(), entry.getValue().toString()));
		}
		// 在职
		Integer zaizhi = jobStatus.get(YgEnumInterface.jobStatus.ZHENSHI.getType()).intValue() + jobStatus.get(YgEnumInterface.jobStatus.SHIYONG.getType()).intValue();
		// 本月新入职
		Integer xinruzhi = workage.get("本月新入职").intValue();
		// 本月离职
		Integer lizhi = ygglMainEmpMapper.benyueLz(orgCode);
		// 本月转正
		Integer zhuanzhen = ygglMainEmpMapper.benyueZz(orgCode);
		// 平均年龄
		Integer nianlin = age.get("平均年龄").intValue();
		YgCartogramDto ybp = new YgCartogramDto();
		ybp.setOnTheJob(zaizhi);
		ybp.setNewRecruits(xinruzhi);
		ybp.setDimission(lizhi);
		ybp.setRegularization(zhuanzhen);
		ybp.setAverageAge(nianlin);

		ybp.setDepartment(bmList);
		ybp.setPosition(gwList);
		ybp.setEdu(eduList);
		ybp.setJobStatus(jobStatusList);
		ybp.setProname(pronameList);
		ybp.setWorkage(workageList);
		ybp.setAge(ageList);
		return ResultUtil.data(ybp, "获取员工管理统计图信息成功！");
	}

	/**
	 * 获取员工社保公积金
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/ygsbgjj")
	@ApiOperation(value = "获取员工社保公积金", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 64)
	public Result<List<YgglAttaSbgjj>> selectygsbgjj(@CurrentUser UserBean userBean) {
		List<YgglAttaSbgjj> ygglAttaSbgjj = YgglAttaSbgjj.builder().build().selectList(new QueryWrapper<YgglAttaSbgjj>()
				.eq("org_code", userBean.getOrgCode()).eq("emp_num", userBean.getEmpNum()));
		return ResultUtil.data(ygglAttaSbgjj, "获取员工社保公积金成功");
	}

	/**
	 * 获取员工社保公积金
	 * 
	 * @param
	 * @return
	 */
	@GetMapping(value = "/ygsbgjj/{empNum}")
	@ApiOperation(value = "获取员工社保公积金", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 65)
	public Result<YgglAttaSbgjj> selectygsbgjj(@CurrentUser UserBean userBean, @PathVariable Integer empNum) {

		YgglAttaSbgjj ygglAttaSbgjj = YgglAttaSbgjj.builder().build()
				.selectOne(new QueryWrapper<YgglAttaSbgjj>().eq("emp_num", empNum));

		return ResultUtil.data(ygglAttaSbgjj, "获取员工社保公积金成功");
	}

	/**
	 * 添加/修改员工社保公积金
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/ygsbgjj")
	@ApiOperation(value = "添加/修改员工社保公积金", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 66)
	public Result<YgglAttaSbgjj> addygsbgjj(@CurrentUser UserBean userBean, @RequestBody YgglAttaSbgjj ygglAttaSbgjj) {
		Integer empNum = ygglAttaSbgjj.getEmpNum();
		if (empNum == null) {
			return ResultUtil.error();
		}
		YgglAttaSbgjj AttaSbgjj = YgglAttaSbgjj.builder().build()
				.selectOne(new QueryWrapper<YgglAttaSbgjj>().eq("emp_num", empNum));
		if (AttaSbgjj != null) {
			ygglAttaSbgjj.update(new UpdateWrapper<YgglAttaSbgjj>().eq("emp_num", empNum));
		} else {
			ygglAttaSbgjj.insert();
		}

		return ResultUtil.data(ygglAttaSbgjj, "添加/修改员工社保公积金成功");
	}

	/**
	 * 删除员工社保公积金
	 * 
	 * @param
	 * @return
	 */
	@DeleteMapping(value = "/ygsbgjj/{id}")
	@ApiOperation(value = "删除员工社保公积金", httpMethod = "DELETE", notes = "接口发布说明")
	@ApiOperationSupport(order = 67)
	public Result<Boolean> delygsbgjj(@CurrentUser UserBean userBean, @PathVariable Integer id) {
		Integer orgCode = userBean.getOrgCode();
		return ResultUtil.data(YgglAttaSbgjj.builder().build()
				.delete(new QueryWrapper<YgglAttaSbgjj>().eq("org_code", orgCode).eq("id", id)), "删除员工社保公积金成功");
	}

}