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.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import javax.transaction.Transactional;

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.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.additional.update.impl.LambdaUpdateChainWrapper;
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.yggl.YgtitleDtoMapper;
import cn.timer.api.dao.zzgl.ZzglBmgwMMapper;
import cn.timer.api.dto.yggl.AddygdaDto;
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.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.YgtitleDto;
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;

	//weng(人事仪表盘)
	@Autowired
	private YgtitleDtoMapper ygtitleDtoMapper;

	/**
	 * 获取员工档案
	 * 
	 * @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(2).build().insert();// 2普通员工
			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();
			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).build().insert();// 2普通员工
				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();
				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", 4).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普通员工
				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).build()
							.insert();// 2普通员工
					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(3).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(4).build().update(updateWrapper);
		YgglMainLzb.builder().empNum(lzygQueryDto.getEmpNum()).jobStatus(4).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(2).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);
	}

	/**
	 * 根据籍贯id显示籍贯名
	 * 
	 * @param
	 * @return
	 */
	@PostMapping(value = "/jgp")
	@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, "查询成功");
	}

	/**
<<<<<<< HEAD
	 * 员工信息统计图
	 * @return 成功信息(weng)
	 */
	@GetMapping("/Cartogram")
	@ApiOperation(value = "获取员工管理统计图信息", httpMethod = "GET", notes = "接口发布说明")
	@ApiOperationSupport(order = 63)
	public Result<Map<String, Object>> ygCartogram(@CurrentUser UserBean userBean) {
		List<YgbintuDto> bintu = ygglMainEmpMapper.rsybp();
		bintu.stream().filter(bean ->{
		if (bean.getAge() == null) {
			bean.setAge(-1);
		}
		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);
		}
		return true;
		}).collect(Collectors.toList());
		YgtitleDto title = new LambdaQueryChainWrapper<YgtitleDto>(ygtitleDtoMapper).eq(YgtitleDto::getOrgCode, userBean.getOrgCode()).one();
		//Map<String, List<YgbintuDto>> map = bintu.stream().collect(Collectors.groupingBy(YgbintuDto::getGw));岗位
		//Map<String, List<YgbintuDto>> map = bintu.stream().collect(Collectors.groupingBy(YgbintuDto::getBm));部门
		Map<String, Map<String, Long>> bmgw = bintu.stream().collect(Collectors.groupingBy(YgbintuDto::getBm,Collectors.groupingBy(YgbintuDto::getGw,Collectors.counting())));
		Map<String, List<YgbintuDto>> edu = bintu.stream().collect(Collectors.groupingBy(YgbintuDto::getEduname));
		Map<Integer, List<YgbintuDto>> jobStatus = bintu.stream().collect(Collectors.groupingBy(YgbintuDto::getJobStatus));
		Map<String, List<YgbintuDto>> proname = bintu.stream().collect(Collectors.groupingBy(YgbintuDto::getProname));
		Map<String, Integer> workage = YgEnumInterface.workage.choose(bintu);

		System.out.println(bmgw);
		System.out.println(edu);
		System.out.println(jobStatus);
		System.out.println(proname);
		System.out.println(workage);
		return ResultUtil.success();
	}
	/**
	 * 获取员工社保公积金
=======
	 * 获取成长记录表
	 * 
>>>>>>> bea51ce9ef8860bb31a1d14ffce121313636951a
	 * @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)), "删除员工社保公积金成功");
	}

}