package cn.com.lzt.personnelbasearchivesmanage.controller;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.net.URI;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.validation.ConstraintViolation;
import javax.validation.Validator;

import cn.afterturn.easypoi.excel.entity.ImportParams;
import cn.com.lzt.car.schedule.entity.TBCarDrivingRecord;
import cn.com.lzt.common.util.ExcelUtils;
import cn.com.lzt.cost.pettycashaccount.service.TBCostPettyCashAccountServiceI;
import cn.com.lzt.duties.service.DutiesServiceI;
import cn.com.lzt.personnelbasearchivesmanage.dto.*;
import cn.com.lzt.projectpostdetail.entity.ProjectPostDetailEntity;
import cn.com.lzt.projectpostdetail.entity.ZTreePostEntity;
import cn.hutool.core.io.IoUtil;
import cn.hutool.poi.excel.ExcelUtil;
import cn.hutool.poi.excel.ExcelWriter;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.daju.mix.dao.entity.TBArchivesRoadSection;
import com.daju.mix.dao.entity.TSBaseUser;
//import com.daju.mix.dao.entity.TSUser;
import com.daju.mix.dao.service.impl.TSBaseUserServiceImpl;
import com.daju.mix.dao.service.impl.TSUserServiceImpl;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.jeecgframework.core.beanvalidator.BeanValidators;
import org.jeecgframework.core.common.controller.BaseController;
import org.jeecgframework.core.common.exception.BusinessException;
import org.jeecgframework.core.common.hibernate.qbc.CriteriaQuery;
import org.jeecgframework.core.common.model.json.AjaxJson;
import org.jeecgframework.core.common.model.json.DataGrid;
import org.jeecgframework.core.constant.Globals;
import org.jeecgframework.core.util.*;
import org.jeecgframework.minidao.pojo.MiniDaoPage;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.vo.NormalExcelConstants;
import org.jeecgframework.tag.core.easyui.TagUtil;
import org.jeecgframework.web.system.pojo.base.*;
import org.jeecgframework.web.system.service.DepartServiceI;
import org.jeecgframework.web.system.service.SystemService;
import org.jeecgframework.web.system.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.util.UriComponentsBuilder;

import com.alibaba.fastjson.JSONObject;
import com.dingtalk.open.client.api.model.corp.CorpUserDetail;
import com.xcgl.utils.XcglDateUtils;

import cn.com.lzt.arrangedutyoperate.entity.ArrangeDutyOperateEntity;
import cn.com.lzt.common.entity.WebUploadEntity;
import cn.com.lzt.dingding.service.DingdingService;
import cn.com.lzt.duties.entity.DutiesEntity;
import cn.com.lzt.goodsinfo.entity.TBGoodsInfoEntity;
import cn.com.lzt.leave.service.ModifyServiceI;
import cn.com.lzt.personnelbasearchivesmanage.dao.PersonnelBaseArchivesManageDao;
import cn.com.lzt.personnelbasearchivesmanage.dto.exportandimportdto.PersonnelBaseArchivesManageExportAndImportDto;
import cn.com.lzt.personnelbasearchivesmanage.dto.exportandimportdto.TSysFileDto;
import cn.com.lzt.personnelbasearchivesmanage.entity.PersonnelBaseArchivesManageEntity;
import cn.com.lzt.personnelbasearchivesmanage.service.PersonnelBaseArchivesManageExportAndImportServiceI;
import cn.com.lzt.personnelbasearchivesmanage.service.PersonnelBaseArchivesManageServiceI;
import cn.com.lzt.post.entity.PostEntity;
import cn.com.lzt.projarrangedetail.entity.ProjarrangeDetailEntity;
import cn.com.lzt.socialsecuritystrategy.entity.SocialSecurityStrategyEntity;
import cn.com.lzt.socialsecuritystrategy.service.SocialSecurityStrategyServiceI;
import cn.com.lzt.userarrangedetail.entity.UserArrangeDetailEntity;
import cn.com.lzt.userchangeslog.entity.UserChangesLogEntity;
import cn.com.lzt.userchangeslog.service.UserChangesLogServiceI;
import cn.com.lzt.userwagestrategy.entity.UserWagestrategyEntity;
import cn.com.lzt.userwagestrategy.service.UserWagestrategyServiceI;

import static cn.com.lzt.common.util.DepartUtil.getMaxLocalCode;

/**
 * @author onlineGenerator
 * @version V1.0
 * @Title: Controller
 * @Description: 员工人事信息表
 * @date 2017-10-17 15:09:04
 */
@Controller
@RequestMapping("/personnelBaseArchivesManageController")
public class PersonnelBaseArchivesManageController extends BaseController {
    /**
     * Logger for this class
     */
    private static final Logger logger = Logger.getLogger(PersonnelBaseArchivesManageController.class);

    // 下载路径
    private static final String showAndDownUrl = ResourceUtil.getConfigByName("showAndDownUrl");

    @Autowired
    private PersonnelBaseArchivesManageServiceI personnelBaseArchivesManageService;
    @Autowired
    private UserService userService;
    @Autowired
    private SystemService systemService;
    @Autowired
    private Validator validator;

    @Autowired
    private PersonnelBaseArchivesManageExportAndImportServiceI personnelBaseArchivesManageExportAndImportService;
    @Autowired
    private DepartServiceI departService;
    @Autowired
    private DingdingService dingdingService;
    @Autowired
    private UserChangesLogServiceI userChangesLogService;
    @Autowired
    private UserWagestrategyServiceI userWagestrategyService;
    @Autowired
    private SocialSecurityStrategyServiceI socialSecurityStrategyService;
    @Autowired
    private ModifyServiceI modifyService;
    @Autowired
    private PersonnelBaseArchivesManageDao personnelBaseArchivesManageDao;

    @Autowired
    private TBCostPettyCashAccountServiceI tBCostPettyCashAccountService;

    @Autowired
    private DutiesServiceI dutiesService;

    @Resource
    private TSBaseUserServiceImpl tsBaseUserService;

    @Resource
    private TSUserServiceImpl tsUserService;

    /**
     * 员工人事信息表列表 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "list")
    public ModelAndView list(HttpServletRequest request) {
        String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
        if (oConvertUtils.isNotEmpty(queryParams)) {
            JSONObject jsonObject = JSONObject.parseObject(queryParams);
            request.setAttribute("queryParams", jsonObject);
        } else {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("userName", "");
            jsonObject.put("departname", "");
            jsonObject.put("orgIds", "");
            jsonObject.put("telphone", "");
            jsonObject.put("idcard", "");
            jsonObject.put("positionStatus", "");
            jsonObject.put("certificateId", "");
            //jsonObject.put("deviceId", "");
            request.setAttribute("queryParams", jsonObject);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManageList");
    }

    /**
     * 员工合同到期管理页面跳转
     *
     * @return
     * @author 刘梦祥
     * @Date 2022年1月4日16:40:41
     */
    @RequestMapping(params = "staffContractStatisticsList")
    public ModelAndView staffContractStatisticsList(HttpServletRequest request) {
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/staffContractStatisticsList");
    }

    /**
     * 员工合同到期管理页面初始化请求
     *
     * @param response
     * @param dataGrid
     * @author 刘梦祥
     * @Date 2022年1月4日16:45:40
     */
    @RequestMapping(params = "staffContractStatisticsListDatagrid")
    public void staffContractStatisticsListDatagrid(HttpServletResponse response, DataGrid dataGrid) {
        String sqlStr = "SELECT\n" +
                "\ttsu.id id,\n" +
                "\ttsd.parentdepartid,\n" +
                "\tCOUNT(tsu.id) countNumber,\n" +
                "\n" +
                "IF (\n" +
                "\ttsuo.org_id IS NULL,\n" +
                "\t'未知',\n" +
                "\ttsuo.org_id\n" +
                ") departId,\n" +
                "\n" +
                "IF (\n" +
                "\ttsd.departname IS NULL,\n" +
                "\t'未知',\n" +
                "\ttsd.departname\n" +
                ") departName,\n" +
                "\n" +
                "IF (\n" +
                "\ttsu.nature IS NULL,\n" +
                "\t'未知',\n" +
                "\n" +
                "IF (\n" +
                "\ttsu.nature = \"\",\n" +
                "\t'未知',\n" +
                "\ttsu.nature\n" +
                ")\n" +
                ") natureId,\n" +
                "\n" +
                "IF (\n" +
                "\ttst.typename IS NULL,\n" +
                "\t'未知',\n" +
                "\n" +
                "IF (\n" +
                "\ttst.typename = \"\",\n" +
                "\t'未知',\n" +
                "\ttst.typename\n" +
                ")\n" +
                ") natureName,\n" +
                "\n" +
                "IF (\n" +
                "\ttsu.gender = '0',\n" +
                "\t'男',\n" +
                "\n" +
                "IF (\n" +
                "\ttsu.gender = '1',\n" +
                "\t'女',\n" +
                "\t'未知'\n" +
                ")\n" +
                ") gender\n" +
                "FROM\n" +
                "\tt_s_user tsu\n" +
                "LEFT JOIN t_s_base_user tsbu ON tsbu.id = tsu.id\n" +
                "LEFT JOIN t_s_user_org tsuo ON tsuo.user_id = tsu.id\n" +
                "LEFT JOIN t_s_depart tsd ON tsuo.org_id = tsd.id\n" +
                "LEFT JOIN (\n" +
                "\tSELECT\n" +
                "\t\t*\n" +
                "\tFROM\n" +
                "\t\tt_s_type\n" +
                "\tWHERE\n" +
                "\t\ttypegroupid = (\n" +
                "\t\t\tSELECT\n" +
                "\t\t\t\tid\n" +
                "\t\t\tFROM\n" +
                "\t\t\t\tt_s_typegroup\n" +
                "\t\t\tWHERE\n" +
                "\t\t\t\ttypegroupcode = \"nature\"\n" +
                "\t\t)\n" +
                ") tst ON tst.typecode = tsu.nature\n" +
                "WHERE\n" +
                "\ttsbu.realname IS NOT NULL and tsbu.delete_flag = \"0\"\n" +
                "GROUP BY\n" +
                "\ttsuo.org_id,\n" +
                "\ttsu.nature,\n" +
                "\ttsu.gender\n" +
                "ORDER BY\n" +
                "\ttsuo.org_id,\n" +
                "\ttsu.nature;";
        String sqlStr2 = "SELECT\n" +
                "\ttsd.parentdepartid,\n" +
                "IF (\n" +
                "\ttsuo.org_id IS NULL,\n" +
                "\t'未知',\n" +
                "\ttsuo.org_id\n" +
                ") departId,\n" +
                "\n" +
                "IF (\n" +
                "\ttsd.departname IS NULL,\n" +
                "\t'未知',\n" +
                "\ttsd.departname\n" +
                ") departName\n" +
                "FROM\n" +
                "\tt_s_user tsu\n" +
                "LEFT JOIN t_s_base_user tsbu ON tsbu.id = tsu.id\n" +
                "LEFT JOIN t_s_user_org tsuo ON tsuo.user_id = tsu.id\n" +
                "LEFT JOIN t_s_depart tsd ON tsuo.org_id = tsd.id\n" +
                "WHERE\n" +
                "\ttsbu.realname IS NOT NULL and tsbu.delete_flag = \"0\"\n" +
                "GROUP BY\n" +
                "\tdepartId\n" +
                "ORDER BY\n" +
                "\tdepartId;";
        String sqlStr3 = "SELECT\n" +
                "IF (\n" +
                "\ttst.typename IS NULL,\n" +
                "\t'未知',\n" +
                "IF (\n" +
                "\ttst.typename = \"\",\n" +
                "\t'未知',\n" +
                "\ttst.typename\n" +
                ")\n" +
                ") natureName\n" +
                "FROM\n" +
                "\tt_s_user tsu\n" +
                "LEFT JOIN t_s_base_user tsbu ON tsbu.id = tsu.id\n" +
                "LEFT JOIN (\n" +
                "\tSELECT\n" +
                "\t\t*\n" +
                "\tFROM\n" +
                "\t\tt_s_type\n" +
                "\tWHERE\n" +
                "\t\ttypegroupid = (\n" +
                "\t\t\tSELECT\n" +
                "\t\t\t\tid\n" +
                "\t\t\tFROM\n" +
                "\t\t\t\tt_s_typegroup\n" +
                "\t\t\tWHERE\n" +
                "\t\t\t\ttypegroupcode = \"nature\"\n" +
                "\t\t)\n" +
                ") tst ON tst.typecode = tsu.nature\n" +
                "WHERE\n" +
                "\ttsbu.realname IS NOT NULL and tsbu.delete_flag = \"0\"\n" +
                "GROUP BY\n" +
                "\tnatureName\n" +
                "ORDER BY\n" +
                "\ttsu.nature DESC;";
        String sqlStr4 = "SELECT\n" +
                "IF (\n" +
                "\ttsu.gender = '0',\n" +
                "\t'男',\n" +
                "IF (tsu.gender = '1', '女', '未知')\n" +
                ") gender\n" +
                "FROM\n" +
                "\tt_s_user tsu\n" +
                "LEFT JOIN t_s_base_user tsbu ON tsbu.id = tsu.id\n" +
                "WHERE\n" +
                "\ttsbu.realname IS NOT NULL and tsbu.delete_flag = \"0\"\n" +
                "GROUP BY\n" +
                "\tgender ORDER BY \n" +
                "tsu.gender;";

        List<Map<String, Object>> DataList = systemService.findForJdbc(sqlStr);
        //员工部门列表查询
        List<Map<String, Object>> DataInfo2 = systemService.findForJdbc(sqlStr2);
        //员工性质列表查询
        List<Map<String, Object>> DataInfo3 = systemService.findForJdbc(sqlStr3);
        //性别列表查询
        List<Map<String, Object>> DataInfo4 = systemService.findForJdbc(sqlStr4);
        //清洗数据返回实体<部门，员工性质，性别>
        List<Map<String, Object>> returnData = new ArrayList<>();
        //<部门+员工性质+性别,人数>
        Map<String, Integer> sumData = new HashMap<>();
        //部门集合
        List<String> departNameList = new ArrayList<>();
        //员工性质集合
        List<String> natureNameList = new ArrayList<>();
        //员工性别集合
        List<String> genderList = new ArrayList<>();
        //遍历总集合
        for (Map<String, Object> item : DataList) {
            String key = item.get("departName").toString() + item.get("natureName").toString() + item.get("gender").toString();
            Integer sumInfo = Integer.parseInt(item.get("countNumber").toString());
            if (sumData.containsKey(key)) {
                //存在的话累加值
                sumData.put(key, sumData.get(key) + sumInfo);
            } else {
                //不存在的话就添加对象
                sumData.put(key, sumInfo);
            }
        }
        for (Map<String, Object> item : DataInfo2){
            if(!departNameList.contains(item.get("departName").toString())){
                departNameList.add(item.get("departName").toString());
            }
        }
        for (Map<String, Object> item : DataInfo3){
            if(!natureNameList.contains(item.get("natureName").toString())){
                natureNameList.add(item.get("natureName").toString());
            }
        }
        for (Map<String, Object> item : DataInfo4){
            if(!genderList.contains(item.get("gender").toString())){
                genderList.add(item.get("gender").toString());
            }
        }
        Map<String,Object> returnDataMap = new HashMap<>();
        returnDataMap.put("sumData",sumData);
        returnDataMap.put("departNameList",departNameList);
        returnDataMap.put("natureNameList",natureNameList);
        returnDataMap.put("genderList",genderList);
        returnData.add(returnDataMap);
        //遍历部门集合
        dataGrid.setTotal(returnData.size());
        dataGrid.setResults(returnData);
        TagUtil.datagrid(response, dataGrid);
    }

    /**
     * 员工人事信息表列表 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "viewList")
    public ModelAndView viewList(HttpServletRequest request) {
        String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
        if (oConvertUtils.isNotEmpty(queryParams)) {
            JSONObject jsonObject = JSONObject.parseObject(queryParams);
            request.setAttribute("queryParams", jsonObject);
        } else {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("userName", "");
            jsonObject.put("departname", "");
            jsonObject.put("orgIds", "");
            jsonObject.put("telphone", "");
            jsonObject.put("idcard", "");
            jsonObject.put("positionStatus", "");
            jsonObject.put("certificateId", "");
            request.setAttribute("queryParams", jsonObject);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManageList-view");
    }

    /**
     * 新入职员工人事信息表列表 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "list_newman")
    public ModelAndView list_newman(HttpServletRequest request) {
        String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));

        Calendar calendar = DataUtils.getCalendar();
//		calendar.add(Calendar.MONTH, -1);
        String yearmonth = DataUtils.formatDate(calendar, "yyyy-MM-dd");
        request.setAttribute("maxdate", yearmonth);
        if (oConvertUtils.isNotEmpty(queryParams)) {
            JSONObject jsonObject = JSONObject.parseObject(queryParams);
            request.setAttribute("queryParams", jsonObject);
        } else {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("userName", "");
            jsonObject.put("departname", "");
            jsonObject.put("orgIds", "");
            jsonObject.put("telphone", "");
            jsonObject.put("idcard", "");
            jsonObject.put("positionStatus", "");
            jsonObject.put("certificateId", "");
            request.setAttribute("queryParams", jsonObject);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManageList_newman");
    }


    // datagrid1
    @RequestMapping(params = "export_newman_tax")
    public String export_newman_tax(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request,
                                    HttpServletResponse response, DataGrid dataGrid, ModelMap modelMap) {
        String departIds = "";
        if (null != inDto.getOrgIds() && StringUtil.isNotEmpty(inDto.getOrgIds())) {
            departIds = inDto.getOrgIds();
        }

        // 页面的单位ID
        List<String> departIdByPageList = Arrays.asList(departIds.split(","));
        // 用于检索的单位ID
        List<String> departIdBySearchList = new ArrayList<String>();
        for (String str : departIdByPageList) {
            if (StringUtil.isNotEmpty(str)) {
                departIdBySearchList.add(str);
                List<DepartDto> departDtoList = personnelBaseArchivesManageService.getAllChildrenList(str, null, null);
                for (DepartDto departDto : departDtoList) {
                    departIdBySearchList.add(departDto.getId());
                }
            }
        }

        // List去重复
        HashSet<String> h = new HashSet<String>(departIdBySearchList);
        departIdBySearchList.clear();
        departIdBySearchList.addAll(h);

        // 重新封装检索用的单位字符串
        departIds = "";
        for (String str : departIdBySearchList) {
            departIds += "'" + str + "',";
        }
        if (StringUtil.isNotEmpty(departIds)) {
            departIds = departIds.substring(0, departIds.length() - 1);
        }
        inDto.setOrgIds(departIds);

        // 获取请求对应的数据权限
        String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        // 從SESSION中獲取用戶信息
        String sortorder = "";
        String sort = dataGrid.getSort(); // 排序对象
        String order = dataGrid.getOrder(); // 排序方式


        MiniDaoPage<NewPersonTaxExcelExportDto> list = personnelBaseArchivesManageService.getNewmanTaxExport(inDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);
        modelMap.put(NormalExcelConstants.FILE_NAME, "新进人员信息_" + inDto.getInMonth());
        modelMap.put(NormalExcelConstants.CLASS, NewPersonTaxExcelExportDto.class);
        modelMap.put(NormalExcelConstants.PARAMS, new ExportParams("新进人员信息", "统计月份:" + inDto.getInMonth(),
                "导出信息"));
        modelMap.put(NormalExcelConstants.DATA_LIST, list.getResults());
        return NormalExcelConstants.JEECG_EXCEL_VIEW;
    }

    @RequestMapping(params = "export_current_newman_tax")
    public String export_current_newman_tax(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request,
                                            HttpServletResponse response, DataGrid dataGrid, ModelMap modelMap) {
        String departIds = "";
        if (null != inDto.getOrgIds() && StringUtil.isNotEmpty(inDto.getOrgIds())) {
            departIds = inDto.getOrgIds();
        }

        // 页面的单位ID
        List<String> departIdByPageList = Arrays.asList(departIds.split(","));
        // 用于检索的单位ID
        List<String> departIdBySearchList = new ArrayList<String>();
        for (String str : departIdByPageList) {
            if (StringUtil.isNotEmpty(str)) {
                departIdBySearchList.add(str);
                List<DepartDto> departDtoList = personnelBaseArchivesManageService.getAllChildrenList(str, null, null);
                for (DepartDto departDto : departDtoList) {
                    departIdBySearchList.add(departDto.getId());
                }
            }
        }

        // List去重复
        HashSet<String> h = new HashSet<String>(departIdBySearchList);
        departIdBySearchList.clear();
        departIdBySearchList.addAll(h);

        // 重新封装检索用的单位字符串
        departIds = "";
        for (String str : departIdBySearchList) {
            departIds += "'" + str + "',";
        }
        if (StringUtil.isNotEmpty(departIds)) {
            departIds = departIds.substring(0, departIds.length() - 1);
        }
        inDto.setOrgIds(departIds);

        // 获取请求对应的数据权限
        String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        // 從SESSION中獲取用戶信息
        String sortorder = "";
        String sort = dataGrid.getSort(); // 排序对象
        String order = dataGrid.getOrder(); // 排序方式


        MiniDaoPage<NewPersonTaxExcelExportDto> list = personnelBaseArchivesManageService.getNewmanTaxExport(inDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);
        List<CurrentNewPersonTaxExcelExportDto> list1 = new ArrayList<CurrentNewPersonTaxExcelExportDto>();
        for (int i = 0; i < list.getResults().size(); i++) {
            CurrentNewPersonTaxExcelExportDto example = new CurrentNewPersonTaxExcelExportDto();
            example.setUserNum(list.getResults().get(i).getUserNum());
            example.setUserName(list.getResults().get(i).getUserName());
            example.setCertNum(list.getResults().get(i).getCertNum());
            example.setGender(list.getResults().get(i).getGender());
            example.setBirth(list.getResults().get(i).getBirth());
            example.setMobile(list.getResults().get(i).getMobile());
            example.setDepartName(list.getResults().get(i).getDepartName());
            example.setDutiesName(list.getResults().get(i).getDutiesName());
            example.setEntryTime(list.getResults().get(i).getEntryTime());
            list1.add(example);
        }


        modelMap.put(NormalExcelConstants.FILE_NAME, "新进人员信息_" + inDto.getInMonth());
        modelMap.put(NormalExcelConstants.CLASS, CurrentNewPersonTaxExcelExportDto.class);
        modelMap.put(NormalExcelConstants.PARAMS, new ExportParams("新进人员信息", "统计月份:" + inDto.getInMonth(),
                "导出信息"));
        modelMap.put(NormalExcelConstants.DATA_LIST, list1);
        return NormalExcelConstants.JEECG_EXCEL_VIEW;
    }

    @RequestMapping(params = "export_leaveman_tax")
    public String export_leaveman_tax(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request,
                                      HttpServletResponse response, DataGrid dataGrid, ModelMap modelMap) {
        String departIds = "";
        if (null != inDto.getOrgIds() && StringUtil.isNotEmpty(inDto.getOrgIds())) {
            departIds = inDto.getOrgIds();
        }

        // 页面的单位ID
        List<String> departIdByPageList = Arrays.asList(departIds.split(","));
        // 用于检索的单位ID
        List<String> departIdBySearchList = new ArrayList<String>();
        for (String str : departIdByPageList) {
            if (StringUtil.isNotEmpty(str)) {
                departIdBySearchList.add(str);
                List<DepartDto> departDtoList = personnelBaseArchivesManageService.getAllChildrenList(str, null, null);
                for (DepartDto departDto : departDtoList) {
                    departIdBySearchList.add(departDto.getId());
                }
            }
        }

        // List去重复
        HashSet<String> h = new HashSet<String>(departIdBySearchList);
        departIdBySearchList.clear();
        departIdBySearchList.addAll(h);

        // 重新封装检索用的单位字符串
        departIds = "";
        for (String str : departIdBySearchList) {
            departIds += "'" + str + "',";
        }
        if (StringUtil.isNotEmpty(departIds)) {
            departIds = departIds.substring(0, departIds.length() - 1);
        }
        inDto.setOrgIds(departIds);

        // 获取请求对应的数据权限
        String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        // 從SESSION中獲取用戶信息
        String sortorder = "";
        String sort = dataGrid.getSort(); // 排序对象
        String order = dataGrid.getOrder(); // 排序方式

        MiniDaoPage<LeavePersonTaxExcelExportDto> list = personnelBaseArchivesManageService.getLeavemanTaxExport(inDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);
        modelMap.put(NormalExcelConstants.FILE_NAME, "离职人员信息_" + inDto.getLeaveMonth());
        modelMap.put(NormalExcelConstants.CLASS, LeavePersonTaxExcelExportDto.class);
        modelMap.put(NormalExcelConstants.PARAMS, new ExportParams("离职人员信息", "统计月份:" + inDto.getLeaveMonth(),
                "导出信息"));
        modelMap.put(NormalExcelConstants.DATA_LIST, list.getResults());
        return NormalExcelConstants.JEECG_EXCEL_VIEW;
    }

    /**
     * 新入职人员名单
     *
     * @param request
     * @param response
     * @param dataGrid
     */

    @RequestMapping(params = "datagrid_newman")
    public void datagrid_newman(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {

        String departIds = "";
        if (null != inDto.getOrgIds() && StringUtil.isNotEmpty(inDto.getOrgIds())) {
            departIds = inDto.getOrgIds();
        }

        if (StringUtil.isEmpty(inDto.getInMonth())) {
            dataGrid.setResults(new ArrayList<PersonnelBaseArchivesManageOutDto>());
            TagUtil.datagrid(response, dataGrid);
            return;
        }

        // 页面的单位ID
        List<String> departIdByPageList = Arrays.asList(departIds.split(","));
        // 用于检索的单位ID
        List<String> departIdBySearchList = new ArrayList<String>();
        for (String str : departIdByPageList) {
            if (StringUtil.isNotEmpty(str)) {
                departIdBySearchList.add(str);
                List<DepartDto> departDtoList = personnelBaseArchivesManageService.getAllChildrenList(str, null, null);
                for (DepartDto departDto : departDtoList) {
                    departIdBySearchList.add(departDto.getId());
                }
            }
        }

        // List去重复
        HashSet<String> h = new HashSet<String>(departIdBySearchList);
        departIdBySearchList.clear();
        departIdBySearchList.addAll(h);

        // 重新封装检索用的单位字符串
        departIds = "";
        for (String str : departIdBySearchList) {
            departIds += "'" + str + "',";
        }
        if (StringUtil.isNotEmpty(departIds)) {
            departIds = departIds.substring(0, departIds.length() - 1);
        }
        inDto.setOrgIds(departIds);

        // 获取请求对应的数据权限
        String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        // 從SESSION中獲取用戶信息
        String sortorder = "";

        MiniDaoPage<NewPersonTaxExcelExportDto> list = personnelBaseArchivesManageService.getNewmanTaxExport(inDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);

        dataGrid.setTotal(list.getTotal());
        dataGrid.setResults(list.getResults());
        TagUtil.datagrid(response, dataGrid);
    }


    /**
     * 员工人事信息表列表 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "list_leave")
    public ModelAndView list_leave(HttpServletRequest request) {
        String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));

        Calendar calendar = DataUtils.getCalendar();
//		calendar.add(Calendar.MONTH, -1);
        String yearmonth = DataUtils.formatDate(calendar, "yyyy-MM-dd");
        request.setAttribute("maxdate", yearmonth);
        if (oConvertUtils.isNotEmpty(queryParams)) {
            JSONObject jsonObject = JSONObject.parseObject(queryParams);
            request.setAttribute("queryParams", jsonObject);
        } else {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("userName", "");
            jsonObject.put("departname", "");
            jsonObject.put("orgIds", "");
            jsonObject.put("telphone", "");
            jsonObject.put("idcard", "");
            jsonObject.put("positionStatus", "");
            jsonObject.put("certificateId", "");
            request.setAttribute("queryParams", jsonObject);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManageList_leave");
    }

    /**
     * 员工人事信息表列表 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "list_tired")
    public ModelAndView list_tired(HttpServletRequest request) {
        String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));

        Calendar calendar = DataUtils.getCalendar();
//		calendar.add(Calendar.MONTH, -1);
        String yearmonth = DataUtils.formatDate(calendar, "yyyy-MM-dd");
        request.setAttribute("maxdate", yearmonth);
        if (oConvertUtils.isNotEmpty(queryParams)) {
            JSONObject jsonObject = JSONObject.parseObject(queryParams);
            request.setAttribute("queryParams", jsonObject);
        } else {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("userName", "");
            jsonObject.put("departname", "");
            jsonObject.put("orgIds", "");
            jsonObject.put("telphone", "");
            jsonObject.put("idcard", "");
            jsonObject.put("positionStatus", "");
            jsonObject.put("certificateId", "");
            request.setAttribute("queryParams", jsonObject);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManageList_tired");
    }


    /**
     * 离职人员名单
     *
     * @param request
     * @param response
     * @param dataGrid
     */

    @RequestMapping(params = "datagrid_leave")
    public void datagrid_leave(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
        String departIds = "";
        if (null != inDto.getOrgIds() && StringUtil.isNotEmpty(inDto.getOrgIds())) {
            departIds = inDto.getOrgIds();
        }

//		if(StringUtil.isEmpty(inDto.getLeaveMonth())) {
//			dataGrid.setResults(new ArrayList<LeavePersonTaxExcelExportDto>());
//			TagUtil.datagrid(response, dataGrid);
//			return;
//		}
//		
        // 页面的单位ID
        List<String> departIdByPageList = Arrays.asList(departIds.split(","));
        // 用于检索的单位ID
        List<String> departIdBySearchList = new ArrayList<String>();
        for (String str : departIdByPageList) {
            if (StringUtil.isNotEmpty(str)) {
                departIdBySearchList.add(str);
                List<DepartDto> departDtoList = personnelBaseArchivesManageService.getAllChildrenList(str, null, null);
                for (DepartDto departDto : departDtoList) {
                    departIdBySearchList.add(departDto.getId());
                }
            }
        }

        // List去重复
        HashSet<String> h = new HashSet<String>(departIdBySearchList);
        departIdBySearchList.clear();
        departIdBySearchList.addAll(h);

        // 重新封装检索用的单位字符串
        departIds = "";
        for (String str : departIdBySearchList) {
            departIds += "'" + str + "',";
        }
        if (StringUtil.isNotEmpty(departIds)) {
            departIds = departIds.substring(0, departIds.length() - 1);
        }
        inDto.setOrgIds(departIds);

        // 获取请求对应的数据权限
        String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        // 從SESSION中獲取用戶信息
        String sortorder = "";

        MiniDaoPage<LeavePersonTaxExcelExportDto> list = personnelBaseArchivesManageService.getLeavemanTaxExport(inDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);

        dataGrid.setTotal(list.getTotal());
        dataGrid.setResults(list.getResults());
        TagUtil.datagrid(response, dataGrid);
    }


    /**
     * easyui AJAX请求数据
     *
     * @param request
     * @param response
     * @param dataGrid
     */

    @RequestMapping(params = "datagrid")
    public void datagrid(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
//		CriteriaQuery cq = new CriteriaQuery(PersonnelBaseArchivesManageEntity.class, dataGrid);
//		//查询条件组装器
//		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, personnelBaseArchivesManage, request.getParameterMap());
//		try{
//		//自定义追加查询条件
//		}catch (Exception e) {
//			throw new BusinessException(e.getMessage());
//		}
//		cq.add();
//		this.personnelBaseArchivesManageService.getDataGridReturn(cq, true);

        String employmentDateStart = request.getParameter("employmentDateStart");
        String employmentDateEnd = request.getParameter("employmentDateEnd");
        String departIds = "";
        String age_begin = request.getParameter("age_begin");
        String age_end = request.getParameter("age_end");
        String nature = request.getParameter("nature");
        String areaRegion = request.getParameter("belongRegion");
//		HttpSession session = ContextHolderUtils.getSession();
//		TSUser tuser = (TSUser)session.getAttribute("LOCAL_CLINET_USER");
//		departIds = tuser.getDepartid();
        String MENU_DATA_AUTHOR_RULE_SQL = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        if(org.apache.commons.lang3.StringUtils.isNotEmpty(MENU_DATA_AUTHOR_RULE_SQL)){
            if(MENU_DATA_AUTHOR_RULE_SQL.contains("departid")) {
                if(MENU_DATA_AUTHOR_RULE_SQL.contains("('") && MENU_DATA_AUTHOR_RULE_SQL.contains("')")){
                    departIds = MENU_DATA_AUTHOR_RULE_SQL.substring(MENU_DATA_AUTHOR_RULE_SQL.indexOf("('")+2,MENU_DATA_AUTHOR_RULE_SQL.indexOf("')"));
                }else{
                    departIds = MENU_DATA_AUTHOR_RULE_SQL.substring(16,MENU_DATA_AUTHOR_RULE_SQL.length()-1);
                }
            }
        }
        // 页面的单位ID
        List<String> departIdByPageList = Arrays.asList(departIds.split(","));
        if (null != inDto.getOrgIds() && StringUtil.isNotEmpty(inDto.getOrgIds())) {
            departIdByPageList.add(inDto.getOrgIds());
        }
        // 用于检索的单位ID
        List<String> departIdBySearchList = new ArrayList<String>();
        for (String str : departIdByPageList) {
            if (StringUtil.isNotEmpty(str)) {
                departIdBySearchList.add(str);
                List<DepartDto> departDtoList = personnelBaseArchivesManageService.getAllChildrenList(str, null, null);
                for (DepartDto departDto : departDtoList) {
                    departIdBySearchList.add(departDto.getId());
                }
            }
        }

        // List去重复
        HashSet<String> h = new HashSet<String>(departIdBySearchList);
        departIdBySearchList.clear();
        departIdBySearchList.addAll(h);

        // 重新封装检索用的单位字符串
        departIds = "";
        for (String str : departIdBySearchList) {
            departIds += "'" + str + "',";
        }
        if(departIds.length() > 1){
            departIds = departIds.substring(0, departIds.length() - 1);
        }
        inDto.setOrgIds(departIds);
        //计算年龄条件，转换成出生日期条件
        if (StringUtils.isNotEmpty(age_begin)) {
            int age = Integer.parseInt(age_begin);
            String date = XcglDateUtils.addDateMonth(new Date(), (0 - age + 1) * 12, new SimpleDateFormat("yyyyMMdd"));
            inDto.setBirthdate_begin(date);
        }else{
            inDto.setBirthdate_begin(null);
        }
        if (StringUtils.isNotEmpty(age_end)) {
            int age = Integer.parseInt(age_end);
            String date = XcglDateUtils.addDateMonth(new Date(), (0 - age - 1) * 12, new SimpleDateFormat("yyyyMMdd"));
            inDto.setBirthdate_end(date);
        }else{
            inDto.setBirthdate_end(null);
        }

        // 入职时间
        if (StringUtils.isNotEmpty(employmentDateStart)) {
            inDto.setEmploymentDateStart(employmentDateStart);
        }else{
            inDto.setEmploymentDateStart(null);
        }

        // 所属网格化区域
        if(StringUtils.isNotEmpty(areaRegion)){
            inDto.setAreaRegion(areaRegion);
        }else{
            inDto.setAreaRegion(null);
        }

        if (StringUtils.isNotEmpty(employmentDateEnd)) {
            inDto.setEmploymentDateEnd(employmentDateEnd);
        }else{
            inDto.setEmploymentDateEnd(null);
        }
        if(StringUtils.isNotEmpty(nature)){
            inDto.setNation(nature);
        }else{
            inDto.setNation(null);
        }

        // 获取请求对应的数据权限
        String authSql = "";
        // 從SESSION中獲取用戶信息
        String sortorder = "";
        String sort = dataGrid.getSort(); // 排序对象
        String order = dataGrid.getOrder(); // 排序方式
        if (StringUtil.isEmpty(sort)) {
            sortorder = " userId "; //默认userName,userId降序
        } else {
            sortorder = humpToLine(sort) + " " + order; // 处理下划线，拼接排序
        }
        MiniDaoPage<PersonnelBaseArchivesManageOutDto> list = personnelBaseArchivesManageService.getPersonnelBaseArchivesManageList(inDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);

        // list中去除null的废数据
        for (int i = list.getResults().size() - 1; i >= 0; i--) {
            PersonnelBaseArchivesManageOutDto personnelBaseArchivesManageOutDto = list.getResults().get(i);
            if (personnelBaseArchivesManageOutDto.getAttendType() != null) {
                personnelBaseArchivesManageOutDto.setAttendType("默认全勤");
            } else {
                personnelBaseArchivesManageOutDto.setAttendType("刷脸考勤");
            }
            // 滤除重复的兼职机构
            Map<String, String> jzMap = new HashMap<String, String>();
            String jzorgIds = personnelBaseArchivesManageOutDto.getJzorgId();
            if (jzorgIds != null && !"".equals(jzorgIds)) {
                String[] jzorgIdArr = jzorgIds.split(",");
                for (String jzorgId : jzorgIdArr) {
                    jzMap.put(jzorgId, jzorgId);
                }
                String ids_processed = "";
                for (String jzorgId : jzMap.values()) {
                    if ("".equals(ids_processed)) {
                        ids_processed = modifyService.getByorgId(jzorgId);
                    } else {
                        ids_processed = ids_processed + "," + modifyService.getByorgId(jzorgId);
                    }
                }
                list.getResults().get(i).setJzorgId(ids_processed);
            }

            // 滤除重复的证书
            Map<String, String> certMap = new HashMap<String, String>();
            String certificateNames = personnelBaseArchivesManageOutDto.getCertificateName();
            if (certificateNames != null && !"".equals(certificateNames)) {
                String[] certificateNameArr = certificateNames.split(",");
                for (String certName : certificateNameArr) {
                    certMap.put(certName, certName);
                }
                String certName_processed = "";
                for (String certName : certMap.values()) {
                    if ("".equals(certName_processed)) {
                        certName_processed = certName;
                    } else {
                        certName_processed = certName_processed + "," + certName;
                    }
                }
                list.getResults().get(i).setCertificateName(certName_processed);
            }
            // 设置组织机构
            String orgId = list.getResults().get(i).getOrgId();
//            orgId = modifyService.getByorgId(orgId);
            list.getResults().get(i).setOrgId(orgId);

            if (StringUtil.isEmpty(personnelBaseArchivesManageOutDto.getId())) {
                list.getResults().remove(i);
            }
            // 根据userid查询t_s_user表中的关联用户信息
            if (personnelBaseArchivesManageOutDto.getId() != null) {
                TSUser tsUser = systemService.getEntity(TSUser.class, personnelBaseArchivesManageOutDto.getId());
//				add-刘梦祥-2021年12月8日15:57:01（添加判断条件优化逻辑，防止接口异常）
                if (tsUser != null) {
                    // 手动写入未获取数据
                    list.getResults().get(i).setContacts(tsUser.getContacts());
                    list.getResults().get(i).setContactsPhone(tsUser.getContactsPhone());
                    list.getResults().get(i).setDeviceId(tsUser.getDeviceId());
                    list.getResults().get(i).setOutlook(tsUser.getOutlook());
                    if(tsUser.getNature() != null && StringUtils.isNotEmpty(tsUser.getNature())){
                        list.getResults().get(i).setNature(tsUser.getNature());
                    }else{
                        list.getResults().get(i).setNature("未知");
                    }
                    if (tsUser.getAge() != null && !"".equals(tsUser.getAge())) {
                        list.getResults().get(i).setAge(Integer.parseInt(tsUser.getAge()));
                    } else {
                        list.getResults().get(i).setAge(0);
                    }
                }
            }
        }

        dataGrid.setTotal(list.getTotal());
        dataGrid.setResults(list.getResults());
        TagUtil.datagrid(response, dataGrid);
    }

    @RequestMapping(params = "datagrid_tired")
    public void datagrid_tired(PersonnelBaseArchivesManageInDto inDto, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
        String departIds = "";
        if (null != inDto.getOrgIds() && StringUtil.isNotEmpty(inDto.getOrgIds())) {
            departIds = inDto.getOrgIds();
        }

//		if(StringUtil.isEmpty(inDto.getLeaveMonth())) {
//			dataGrid.setResults(new ArrayList<LeavePersonTaxExcelExportDto>());
//			TagUtil.datagrid(response, dataGrid);
//			return;
//		}
        String toDateStr = inDto.getLeaveMonth();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date toDate = new Date();
        if (StringUtil.isNotEmpty(toDateStr)) {
            toDateStr = toDateStr + "-15";
            try {
                toDate = sdf.parse(toDateStr);
            } catch (ParseException e) {
                System.out.println(e.getMessage());
            }
        }

        Calendar last_month = Calendar.getInstance();
        last_month.setTime(toDate);
        last_month.add(Calendar.MONTH, -1);
        // 设置上月最后一天
        last_month.set(Calendar.DAY_OF_MONTH, last_month.getActualMaximum(Calendar.DAY_OF_MONTH));
        // 页面的单位ID
        List<String> departIdByPageList = Arrays.asList(departIds.split(","));
        // 用于检索的单位ID
        List<String> departIdBySearchList = new ArrayList<String>();
        for (String str : departIdByPageList) {
            if (StringUtil.isNotEmpty(str)) {
                departIdBySearchList.add(str);
                List<DepartDto> departDtoList = personnelBaseArchivesManageService.getAllChildrenList(str, null, null);
                for (DepartDto departDto : departDtoList) {
                    departIdBySearchList.add(departDto.getId());
                }
            }
        }

        // List去重复
        HashSet<String> h = new HashSet<String>(departIdBySearchList);
        departIdBySearchList.clear();
        departIdBySearchList.addAll(h);

        // 重新封装检索用的单位字符串
        departIds = "";
        for (String str : departIdBySearchList) {
            departIds += "'" + str + "',";
        }
        if (StringUtil.isNotEmpty(departIds)) {
            departIds = departIds.substring(0, departIds.length() - 1);
        }
        inDto.setOrgIds(departIds);

        // 获取请求对应的数据权限
        String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        // 從SESSION中獲取用戶信息
        String sortorder = "";

        MiniDaoPage<LeavePersonTaxExcelExportDto> list = personnelBaseArchivesManageDao.getTiredperson(inDto
                , dataGrid.getPage(), dataGrid.getRows(), authSql, sdf.format(last_month.getTime()));

        dataGrid.setTotal(list.getTotal());
        dataGrid.setResults(list.getResults());
        TagUtil.datagrid(response, dataGrid);
    }

    /**
     * @param personnelBaseArchivesManageOutDto
     * @param stop_date
     * @return
     */
    private boolean isTiredLastMonth(PersonnelBaseArchivesManageOutDto personnelBaseArchivesManageOutDto, Date stop_date) {
        Date birth = getBirth(personnelBaseArchivesManageOutDto);
        Calendar birth_cal = Calendar.getInstance();
        birth_cal.setTime(birth);

        Calendar last_month = Calendar.getInstance();
        last_month.setTime(stop_date);
        last_month.add(Calendar.MONTH, -1);
        // 设置上月最后一天
        last_month.set(Calendar.DAY_OF_MONTH, last_month.getLeastMaximum(Calendar.DAY_OF_MONTH));
        // 男性60
        if ("0".equals(personnelBaseArchivesManageOutDto.getGender())) {
            birth_cal.add(Calendar.YEAR, 60);
            if (birth_cal.before(last_month)) {
                return true;
            }
        }
        //女性55
        if ("1".equals(personnelBaseArchivesManageOutDto.getGender())) {
            birth_cal.add(Calendar.YEAR, 55);
            if (birth_cal.before(last_month)) {
                return true;
            }
        }
        return false;
    }

    private Date getBirth(PersonnelBaseArchivesManageOutDto personnelBaseArchivesManageOutDto) {
        String Id = personnelBaseArchivesManageOutDto.getIdcard();
        String year = Id.substring(6, 10);//调用substring方法返回相关字段，注意索引从0开始
        String month = Id.substring(10, 12);
        String day = Id.substring(12, 14);
        String birthday = year + "-" + month + "-" + day;
        DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");//定义一个时间转换格式“年-月-日”
        Date date = null;
        try {     //捕获类型转换（解析）异常
            date = fmt.parse(birthday);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }


    /**
     * 驼峰转下划线
     *
     * @param str 需要转换的字符串
     * @return
     */
    private String humpToLine(String str) {
        Pattern humpPattern = Pattern.compile("[A-Z]");
        Matcher matcher = humpPattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
        }
        matcher.appendTail(sb);
        return sb.toString();
    }

    /**
     * 编辑TAB 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goUpdateTab")
    public ModelAndView goUpdateTab(String id, HttpServletRequest request) {
        request.setAttribute("id", id);
        String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
        if (oConvertUtils.isNotEmpty(queryParams)) {
            request.setAttribute("queryParams", queryParams);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchives-tab");
    }

    /**
     * 编辑TAB 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goUpdateTabLeave")
    public ModelAndView goUpdateTabLeave(String id, HttpServletRequest request) {
        request.setAttribute("id", id);
        String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
        if (oConvertUtils.isNotEmpty(queryParams)) {
            request.setAttribute("queryParams", queryParams);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchives-tab-Leave");
    }

    /**
     * 查看TAB 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goViewTab")
    public ModelAndView goViewTab(String id, HttpServletRequest request) {
        request.setAttribute("id", id);
        String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
        if (oConvertUtils.isNotEmpty(queryParams)) {
            request.setAttribute("queryParams", queryParams);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchives-view-tab");
    }

    /**
     * 编辑基本信息 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goUpdateBase")
    public ModelAndView goUpdateBase(String id, HttpServletRequest request) {
        if (StringUtil.isNotEmpty(id)) {
            TSUser userInfo = userService.get(TSUser.class, id);
            request.setAttribute("userInfo", userInfo);
            this.idandname(request, userInfo);
            this.getOrgInfos(request, userInfo);
//			this.getJzOrgInfos(request, userInfo);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/userInfo-update");
    }

    /**
     * 查看基本信息 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goViewBase")
    public ModelAndView goViewBase(String id, HttpServletRequest request) {
        if (StringUtil.isNotEmpty(id)) {
            TSUser userInfo = userService.get(TSUser.class, id);
            request.setAttribute("userInfo", userInfo);
            this.idandname(request, userInfo);
            this.getOrgInfos(request, userInfo);
//			this.getJzOrgInfos(request, userInfo);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/userInfo-view");
    }


    /**
     * 编辑证书信息 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goUpdateCertificate")
    public ModelAndView goUpdateCertificate(String id, HttpServletRequest request) {
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManage-add");
    }

    /**
     * 编辑人事信息 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goUpdatePersonnel")
    public ModelAndView goUpdatePersonnel(String id, HttpServletRequest request) {
        String personnelHql = "from PersonnelBaseArchivesManageEntity where userid=? ";
        // 职务名
        String dutiesName = "";
        // 岗位名
        String postName = "";
        List<PersonnelBaseArchivesManageEntity> personnelBaseArchivesManageEntityList = personnelBaseArchivesManageService.findHql(personnelHql, id);
        PersonnelBaseArchivesManageEntity personnelBaseArchivesManageEntity = new PersonnelBaseArchivesManageEntity();
        if (personnelBaseArchivesManageEntityList.size() > 0) {
            personnelBaseArchivesManageEntity = personnelBaseArchivesManageEntityList.get(0);
            if (StringUtil.isNotEmpty(personnelBaseArchivesManageEntity.getBelongDutiesid())) {
                DutiesEntity dutiesEntity = systemService.getEntity(DutiesEntity.class, personnelBaseArchivesManageEntity.getBelongDutiesid());
                dutiesName = dutiesEntity.getDutiesName();
            }
            if (StringUtil.isNotEmpty(personnelBaseArchivesManageEntity.getInPostid())) {
                PostEntity postEntity = systemService.getEntity(PostEntity.class, personnelBaseArchivesManageEntity.getInPostid());
                postName = postEntity.getPostName();
            }
        } else {
            personnelBaseArchivesManageEntity.setUserid(id);
        }

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

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

        // 单位名称
        String mainOrg = "";
        // 兼职单位名
        String parttimeOrg = "";

        if (mainOrgMapList.size() > 0) {
            mainOrg = (String) mainOrgMapList.get(0).get("departname");
        }

        if (parttimeOrgMapList.size() > 0) {
            for (Map<String, Object> orgStr : parttimeOrgMapList) {
                parttimeOrg += (String) orgStr.get("departname") + ",";
            }
            parttimeOrg = parttimeOrg.substring(0, parttimeOrg.length() - 1);
        }

        request.setAttribute("personnelInfo", personnelBaseArchivesManageEntity);
        request.setAttribute("mainOrg", mainOrg);
        request.setAttribute("parttimeOrg", parttimeOrg);
        request.setAttribute("dutiesName", dutiesName);
        request.setAttribute("postName", postName);

        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManage-update");
    }

    /**
     * 查看人事信息 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goViewPersonnel")
    public ModelAndView goViewPersonnel(String id, HttpServletRequest request) {
        String personnelHql = "from PersonnelBaseArchivesManageEntity where userid=? ";
        // 职务名
        String dutiesName = "";
        // 岗位名
        String postName = "";
        List<PersonnelBaseArchivesManageEntity> personnelBaseArchivesManageEntityList = personnelBaseArchivesManageService.findHql(personnelHql, id);
        PersonnelBaseArchivesManageEntity personnelBaseArchivesManageEntity = new PersonnelBaseArchivesManageEntity();
        if (personnelBaseArchivesManageEntityList.size() > 0) {
            personnelBaseArchivesManageEntity = personnelBaseArchivesManageEntityList.get(0);
            if (StringUtil.isNotEmpty(personnelBaseArchivesManageEntity.getBelongDutiesid())) {
                DutiesEntity dutiesEntity = systemService.getEntity(DutiesEntity.class, personnelBaseArchivesManageEntity.getBelongDutiesid());
                dutiesName = dutiesEntity.getDutiesName();
            }
            if (StringUtil.isNotEmpty(personnelBaseArchivesManageEntity.getInPostid())) {
                PostEntity postEntity = systemService.getEntity(PostEntity.class, personnelBaseArchivesManageEntity.getInPostid());
                postName = postEntity.getPostName();
            }
        } else {
            personnelBaseArchivesManageEntity.setUserid(id);
        }

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

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

        // 单位名称
        String mainOrg = "";
        // 兼职单位名
        String parttimeOrg = "";

        if (mainOrgMapList.size() > 0) {
            mainOrg = (String) mainOrgMapList.get(0).get("departname");
        }

        if (parttimeOrgMapList.size() > 0) {
            for (Map<String, Object> orgStr : parttimeOrgMapList) {
                parttimeOrg += (String) orgStr.get("departname") + ",";
            }
            parttimeOrg = parttimeOrg.substring(0, parttimeOrg.length() - 1);
        }

        request.setAttribute("personnelInfo", personnelBaseArchivesManageEntity);
        request.setAttribute("mainOrg", mainOrg);
        request.setAttribute("parttimeOrg", parttimeOrg);
        request.setAttribute("dutiesName", dutiesName);
        request.setAttribute("postName", postName);

        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManage-view");
    }

    /**
     * 编辑人员照片 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goUpdatePhoto")
    public ModelAndView goUpdatePhoto(String userId, HttpServletRequest request) {

        // 用户照片有无Flg
        String photoFlg = "0";
        String photoUrl = "";

        StringBuilder mainOrgSql = new StringBuilder();
        mainOrgSql.append(" SELECT ");
        mainOrgSql.append(" file_url ");
        mainOrgSql.append(" FROM t_sys_file ");
        mainOrgSql.append(" WHERE ");
        mainOrgSql.append(" busi_table = 't_s_base_user' ");
        mainOrgSql.append(" AND taget_type = 'userPhoto' ");
        mainOrgSql.append(" AND busi_id = '" + userId + "' ");
        List<Map<String, Object>> userPhotoMapList = systemService.findForJdbc(mainOrgSql.toString());

        if (userPhotoMapList.size() > 0) {
            photoFlg = "1";
            photoUrl = (String) userPhotoMapList.get(0).get("file_url");
        }
        request.setAttribute("userId", userId);
        request.setAttribute("photoFlg", photoFlg);
        request.setAttribute("photoUrl", photoUrl);

        request.setAttribute("showAndDownUrl", showAndDownUrl);
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/userPhoto");
    }

    /**
     * 编辑附件 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goAccessory")
    public ModelAndView goAccessory(String userId, HttpServletRequest request) {

        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/userAccessory");
    }


    /**
     * 保存新增/更新人事数据
     *
     * @return
     */
    @RequestMapping(params = "savePersonnelData")
    @ResponseBody
    public AjaxJson savePersonnelData(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request) {
        String message = "";
        AjaxJson j = new AjaxJson();
        // 根据userId判断用户是否已经维护了员工人事信息表
        String personnelBaseArchivesManageByUserIdHql = "from PersonnelBaseArchivesManageEntity where userid = ?";
        List<PersonnelBaseArchivesManageEntity> personnelBaseArchivesManageEntityList = personnelBaseArchivesManageService.findHql(personnelBaseArchivesManageByUserIdHql, personnelBaseArchivesManage.getUserid());
        if (personnelBaseArchivesManageEntityList.size() > 0) {
            personnelBaseArchivesManage.setId(personnelBaseArchivesManageEntityList.get(0).getId());
        }

        if (StringUtil.isNotEmpty(personnelBaseArchivesManage.getId())) {
            PersonnelBaseArchivesManageEntity t = personnelBaseArchivesManageService.get(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
            try {
                // 维护员工人事变动表数据
                if (Globals.JOBSTATUS_1.equals(personnelBaseArchivesManage.getPositionStatus()) && !Globals.JOBSTATUS_1.equals(t.getPositionStatus())
                        || Globals.JOBSTATUS_2.equals(personnelBaseArchivesManage.getPositionStatus()) && !Globals.JOBSTATUS_2.equals(t.getPositionStatus())) {
                    this.saveUserChangesLog(personnelBaseArchivesManage.getUserid(), personnelBaseArchivesManage.getIfpayment(), personnelBaseArchivesManage.getPositionStatus());
                }
                // 试用期为【无】时，转正日期=合同开始日期
                if (Globals.SHIYONGQI_0.equals(personnelBaseArchivesManage.getTrialPeriod().toString())) {
                    t.setCorrectionDate(personnelBaseArchivesManage.getContractStime());
                }
                if (personnelBaseArchivesManage.getBelongDutiesid() != null && !personnelBaseArchivesManage.getBelongDutiesid().equals(t.getBelongDutiesid())) {
                    resetDutyAndPost(personnelBaseArchivesManage);
                }
                MyBeanUtils.copyBeanNotNull2Bean(personnelBaseArchivesManage, t);
                personnelBaseArchivesManageService.saveOrUpdate(t);
                message = "员工人事信息更新成功";
                j.setSuccess(true);
                systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
            } catch (Exception e) {
                e.printStackTrace();
                message = "员工人事信息更新失败";
                j.setSuccess(false);
                throw new BusinessException(e.getMessage());
            }
        } else {
            try {
                // 维护员工人事变动表数据
                if (Globals.JOBSTATUS_1.equals(personnelBaseArchivesManage.getPositionStatus())
                        || Globals.JOBSTATUS_2.equals(personnelBaseArchivesManage.getPositionStatus())) {
                    this.saveUserChangesLog(personnelBaseArchivesManage.getUserid(), personnelBaseArchivesManage.getIfpayment(), personnelBaseArchivesManage.getPositionStatus());
                }
                // 试用期为【无】时，转正日期=合同开始日期
                if (Globals.SHIYONGQI_0.equals(personnelBaseArchivesManage.getTrialPeriod().toString())) {
                    personnelBaseArchivesManage.setCorrectionDate(personnelBaseArchivesManage.getContractStime());
                }
                if (personnelBaseArchivesManage.getBelongDutiesid() != null) {
                    resetDutyAndPost(personnelBaseArchivesManage);
                }
                personnelBaseArchivesManageService.save(personnelBaseArchivesManage);
                message = "员工人事信息添加成功";
                j.setSuccess(true);
                systemService.addLog(message, Globals.Log_Type_INSERT, Globals.Log_Leavel_INFO);
            } catch (Exception e) {
                e.printStackTrace();
                message = "员工人事信息添加失败";
                j.setSuccess(false);
                throw new BusinessException(e.getMessage());
            }
        }
        j.setMsg(message);
        return j;
    }

    /**
     * @param personnelBaseArchivesManage
     */
    private void resetDutyAndPost(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage) {
        String duty_id = personnelBaseArchivesManage.getBelongDutiesid();
        if (duty_id == null) {
            return;
        }

        DutiesEntity dutiesEntity = systemService.getEntity(DutiesEntity.class, duty_id);
        if (dutiesEntity != null) {
            personnelBaseArchivesManage.setInPostid(dutiesEntity.getPost());
            personnelBaseArchivesManage.setManagerType(dutiesEntity.getManageType());
        }
    }


    /**
     * 保存员工基本信息数据
     *
     * @return
     */
/*	@RequestMapping(params = "saveUserData")
	@ResponseBody
	public AjaxJson saveUserData(TSUser userInfo, HttpServletRequest request){
		String message = "";
		AjaxJson j = new AjaxJson();
		TSUser t = userService.get(TSUser.class, userInfo.getId());
		try {
			MyBeanUtils.copyBeanNotNull2Bean(userInfo, t);
			userService.saveOrUpdate(t);
			message = "员工基本信息更新成功";
			systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
		} catch (Exception e) {
			e.printStackTrace();
			message = "员工基本信息更新失败";
			throw new BusinessException(e.getMessage());
		}
		j.setMsg(message);
		return j;
	}*/


    /**
     * 逻辑删除用户
     *
     * @param request
     * @return
     * @author zhijia.wang
     * 2017-12-27 pm
     */
    @RequestMapping(params = "logicDel")
    @ResponseBody
    public AjaxJson logicDel(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request) {
        String message = null;
        AjaxJson j = new AjaxJson();
        if ("admin".equals(personnelBaseArchivesManage.getUserid())) {
            message = "超级管理员[admin]不可删除";
            j.setSuccess(false);
            j.setMsg(message);
            return j;
        }
        TSUser user = systemService.getEntity(TSUser.class, personnelBaseArchivesManage.getId());
        try {
            if (!Globals.User_ADMIN.equals(user.getStatus())) {
                user.setDeleteFlag(Globals.Delete_Forbidden);
                // 逻辑删除用户，并把删除状态设置到Redis
                userService.logicDelAndPutRedis(user);
                message = "用户：" + user.getUserName() + "删除成功";
                systemService.addLog(message, Globals.Log_Type_DEL, Globals.Log_Leavel_INFO);
                logger.info("[" + IpUtil.getIpAddr(request) + "][逻辑删除用户]" + message);
                j.setSuccess(true);
            } else {
                message = "超级管理员不可删除";
                j.setSuccess(false);
            }
        } catch (Exception e) {
            e.printStackTrace();
            message = "参数异常,用户删除失败,请重试.";
            j.setSuccess(false);
            throw new BusinessException(e.getMessage());
        }
        j.setMsg(message);
        return j;
    }


    /**
     * 删除员工人事信息表
     *
     * @return
     */
    @RequestMapping(params = "doDel")
    @ResponseBody
    public AjaxJson doDel(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request) {
        String message = null;
        AjaxJson j = new AjaxJson();
        personnelBaseArchivesManage = systemService.getEntity(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
        message = "员工人事信息表删除成功";
        try {
            personnelBaseArchivesManageService.delete(personnelBaseArchivesManage);
            systemService.addLog(message, Globals.Log_Type_DEL, Globals.Log_Leavel_INFO);
        } catch (Exception e) {
            e.printStackTrace();
            message = "员工人事信息表删除失败";
            throw new BusinessException(e.getMessage());
        }
        j.setMsg(message);
        return j;
    }

    /**
     * 批量删除员工人事信息表
     *
     * @return
     */
    @RequestMapping(params = "doBatchDel")
    @ResponseBody
    public AjaxJson doBatchDel(String ids, HttpServletRequest request) {
        String message = null;
        AjaxJson j = new AjaxJson();
        message = "员工人事信息表删除成功";
        try {
            for (String id : ids.split(",")) {
                PersonnelBaseArchivesManageEntity personnelBaseArchivesManage = systemService.getEntity(PersonnelBaseArchivesManageEntity.class,
                        id
                );
                personnelBaseArchivesManageService.delete(personnelBaseArchivesManage);
                systemService.addLog(message, Globals.Log_Type_DEL, Globals.Log_Leavel_INFO);
            }
        } catch (Exception e) {
            e.printStackTrace();
            message = "员工人事信息表删除失败";
            throw new BusinessException(e.getMessage());
        }
        j.setMsg(message);
        return j;
    }


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

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

    /**
     * 离职登记
     *
     * @return
     */
    @RequestMapping(params = "doLeave")
    @ResponseBody
    public AjaxJson doLeave(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request) {
        String message = null;
        AjaxJson j = new AjaxJson();
        message = "员工离职登记成功";
        String id = request.getParameter("ids");
        String leavedate = request.getParameter("leavedate");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
        PersonnelBaseArchivesManageEntity t = personnelBaseArchivesManageService.get(PersonnelBaseArchivesManageEntity.class, id);
        try {
            t.setLeaveDate(sdf2.parse(leavedate));
            t.setPositionStatus("3");
            personnelBaseArchivesManageService.saveOrUpdate(t);
            systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
        } catch (Exception e) {
            e.printStackTrace();
            message = "员工离职登记失败";
            throw new BusinessException(e.getMessage());
        }
        j.setMsg(message);
        return j;
    }

    /**
     * 停缴社保
     *
     * @return
     */
    @RequestMapping(params = "stopShebao")
    @ResponseBody
    public AjaxJson stopShebao(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest request) {
        String message = null;
        AjaxJson j = new AjaxJson();
        message = "社保停缴成功";
        String userid = request.getParameter("userid");
        StringBuffer hql = new StringBuffer("from UserWagestrategyEntity where userid = :userid and deleteFlag <> '1'");
        List<UserWagestrategyEntity> tsList = systemService.getSession().createQuery(hql.toString()).setParameter("userid", userid).list();
        try {
            if (tsList.size() > 0) {
                tsList.get(0).setSocialSecurityStrategyid(null);
                systemService.saveOrUpdate(tsList.get(0));
            }
            systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
        } catch (Exception e) {
            e.printStackTrace();
            message = "社保停缴失败";
            throw new BusinessException(e.getMessage());
        }
        j.setMsg(message);
        return j;
    }

    /**
     * 重新入职
     *
     * @return
     */
    @RequestMapping(params = "reruzhi")
    @ResponseBody
    public AjaxJson reruzhi(HttpServletRequest request) {
        String message = null;
        AjaxJson j = new AjaxJson();
        message = "员工重新入职成功";
        String id = request.getParameter("ids");
        String start = request.getParameter("start");
        String end = request.getParameter("end");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
        PersonnelBaseArchivesManageEntity t = personnelBaseArchivesManageService.get(PersonnelBaseArchivesManageEntity.class, id);
        try {
            t.setContractStime(sdf2.parse(start));
            t.setContractEtime(sdf2.parse(end));
            t.setLeaveDate(null);
            t.setPositionStatus("1");
            personnelBaseArchivesManageService.saveOrUpdate(t);
            systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
        } catch (Exception e) {
            e.printStackTrace();
            message = "员工重新入职失败";
            throw new BusinessException(e.getMessage());
        }
        j.setMsg(message);
        return j;
    }

    /**
     * 员工人事信息表新增页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goAdd")
    public ModelAndView goAdd(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest req) {
        if (StringUtil.isNotEmpty(personnelBaseArchivesManage.getId())) {
            personnelBaseArchivesManage = personnelBaseArchivesManageService.getEntity(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
            req.setAttribute("personnelBaseArchivesManagePage", personnelBaseArchivesManage);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManage-add");
    }

    /**
     * 员工人事信息表编辑页面跳转
     *
     * @return
     */
    @RequestMapping(params = "goUpdate")
    public ModelAndView goUpdate(PersonnelBaseArchivesManageEntity personnelBaseArchivesManage, HttpServletRequest req) {
        if (StringUtil.isNotEmpty(personnelBaseArchivesManage.getId())) {
            personnelBaseArchivesManage = personnelBaseArchivesManageService.getEntity(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
            req.setAttribute("personnelBaseArchivesManagePage", personnelBaseArchivesManage);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManage-update");
    }

    /**
     * 导入功能跳转
     *
     * @return
     */
	/*@RequestMapping(params = "upload")
	public ModelAndView upload(HttpServletRequest req) {
		req.setAttribute("controller_name","personnelBaseArchivesManageController");
		return new ModelAndView("common/upload/pub_excel_upload");
	}*/

    /**
     * 导入功能跳转
     *
     * @return
     */
    @RequestMapping(params = "upload")
    public ModelAndView uploadTest(HttpServletRequest req) {
//		req.setAttribute("controller_name","personnelBaseArchivesManageController");
//		return new ModelAndView("common/upload/uploadzbw/excel_upload");
        req.setAttribute("controller_name", "personnelBaseArchivesManageController");
        return new ModelAndView("common/upload/common_excel_upload");
    }

    /**
     * 导出excel
     *
     * @param request
     * @param response datagrid1
     */
    @RequestMapping(params = "exportXls")
    @ResponseBody
    public void exportXls(PersonnelBaseArchivesManageInDto personnelBaseArchivesManageInDto, HttpServletRequest request, HttpServletResponse response
            , DataGrid dataGrid, ModelMap modelMap) throws Exception {
        // 获取请求对应的数据权限
        String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        // 從SESSION中獲取用戶信息
        String sortorder = "";
        String sort = dataGrid.getSort(); // 排序对象
        String order = dataGrid.getOrder(); // 排序方式
        if (StringUtil.isEmpty(sort)) {
            sortorder = " 'orgId' "; //默认userName,userId降序
        } else {
            sortorder = humpToLine(sort) + " " + order; // 处理下划线，拼接排序
        }
        if(personnelBaseArchivesManageInDto.getId() != null){
            if(personnelBaseArchivesManageInDto.getId().contains(",")){
                personnelBaseArchivesManageInDto.setId(personnelBaseArchivesManageInDto.getId().replace(",",""));
            }
        }
        MiniDaoPage<PersonnelBaseArchivesManageOutDto> list = personnelBaseArchivesManageService.getPersonnelBaseArchivesManageList(personnelBaseArchivesManageInDto, dataGrid.getPage(), dataGrid.getRows(), authSql, sortorder);
        for (int i = list.getResults().size() - 1; i >= 0; i--) {
            PersonnelBaseArchivesManageOutDto personnelBaseArchivesManageOutDto = list.getResults().get(i);
            // 根据userid查询t_s_user表中的关联用户信息
            if (personnelBaseArchivesManageOutDto.getId() != null) {
                TSUser tsUser = systemService.getEntity(TSUser.class, personnelBaseArchivesManageOutDto.getId());
                // 手动写入未获取数据
                list.getResults().get(i).setContacts(tsUser.getContacts());
                list.getResults().get(i).setContactsPhone(tsUser.getContactsPhone());
                list.getResults().get(i).setDeviceId(tsUser.getDeviceId());
                list.getResults().get(i).setOutlook(tsUser.getOutlook());
                if(StringUtil.isNotEmpty(tsUser.getAge())){
                    list.getResults().get(i).setAge(Integer.parseInt(tsUser.getAge()));
                }else{
                    list.getResults().get(i).setAge(null);
                }
            }
        }

        List<PersonnelBaseArchivesManageOutDto> lp = new ArrayList<>();
        for (PersonnelBaseArchivesManageOutDto li : list.getResults()) {
            PersonnelBaseArchivesManageOutDto pdm = JSONObject.parseObject(JSONObject.toJSONString(li), PersonnelBaseArchivesManageOutDto.class);
            lp.add(pdm);
        }

        ExcelWriter writer = ExcelUtil.getWriter();
        writer.addHeaderAlias("userNum", "员工工号");
        writer.addHeaderAlias("userName", "员工姓名");
        writer.addHeaderAlias("gender", "性别");
        writer.addHeaderAlias("nation", "民族");
        writer.addHeaderAlias("mobilePhone", "手机号码");
        writer.addHeaderAlias("officePhone", "座机号码");
        writer.addHeaderAlias("contacts", "紧急联系人");
        writer.addHeaderAlias("contactsPhone", "紧急联系人电");
        writer.addHeaderAlias("idcard", "身份证号码");
        writer.addHeaderAlias("birthday", "出生日期");
        writer.addHeaderAlias("age", "年龄");
        writer.addHeaderAlias("hkaddress", "户籍地址");
        writer.addHeaderAlias("hktype", "户籍类别");
        writer.addHeaderAlias("address", "居住地址");
        writer.addHeaderAlias("departname", "所属部门");
        writer.addHeaderAlias("dutiesId", "职务");
        writer.addHeaderAlias("inPostid", "岗位");
        writer.addHeaderAlias("deviceId", "设备编号");
        writer.addHeaderAlias("outLook", "政治面貌");
        writer.addHeaderAlias("education", "学历");
        writer.addHeaderAlias("nature", "员工性质");
        writer.addHeaderAlias("email", "邮箱");
        writer.addHeaderAlias("employmentDate", "入职日期");
        writer.addHeaderAlias("userType", "是否登录系统");

        writer.merge(22, "人员档案");
        writer.setOnlyAlias(true);
        writer.write(lp, true);
        response.setContentType("application/vnd.ms-excel;charset=utf-8");
        String fileName = new String("美都员工档案".getBytes("UTF-8"), "ISO8859-1");;
        response.setHeader("Content-Disposition", "attachment;filename=" + fileName + ".xls");

        ServletOutputStream out = null;

        try {
            out = response.getOutputStream();
            writer.flush(out, true);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            writer.close();
        }
        IoUtil.close(out);

    }

    public static Map<?, ?> objectToMap(Object obj) {
        if (obj == null)
            return null;

        return new org.apache.commons.beanutils.BeanMap(obj);
    }

    /**
     * 导出excel 使模板
     *
     * @param request
     * @param response
     */
    @RequestMapping(params = "exportXlsByT")
    public String exportXlsByT(PersonnelBaseArchivesManageExportAndImportDto personnelBaseArchivesManageExportAndImportDto, HttpServletRequest request, HttpServletResponse response
            , DataGrid dataGrid, ModelMap modelMap) {

        modelMap.put(cn.afterturn.easypoi.entity.vo.NormalExcelConstants.FILE_NAME, "员工人事信息表");
        modelMap.put(cn.afterturn.easypoi.entity.vo.NormalExcelConstants.CLASS, PersonnelBaseArchivesManageExportAndImportDto.class);
        modelMap.put(cn.afterturn.easypoi.entity.vo.NormalExcelConstants.PARAMS, new cn.afterturn.easypoi.excel.entity.ExportParams("员工人事信息列表", "导出人:" + ResourceUtil.getSessionUser().getRealName(),
                "导出信息"));
        modelMap.put(cn.afterturn.easypoi.entity.vo.NormalExcelConstants.DATA_LIST, new ArrayList<>());
        return cn.afterturn.easypoi.entity.vo.NormalExcelConstants.EASYPOI_EXCEL_VIEW;

    }

    /**
     * 导入功能
     *
     * @param request
     * @param response
     * @return
     * @author zbw
     * 2017-12-13
     */
    @SuppressWarnings("unchecked")
//	@RequestMapping(params = "importExcel", method = RequestMethod.POST)
//	@ResponseBody
//	public AjaxJson importExcel(HttpServletRequest request, HttpServletResponse response) {
//		AjaxJson j = new AjaxJson();
//		try {
//			long start = System.currentTimeMillis();
//			j=personnelBaseArchivesManageExportAndImportService.importExcelPersonnelBaseArchivesManage(request, response);
//			if(j.getAttributes()!=null){
//				Map<String, Object> deleteMap=j.getAttributes();
//				List<String> userNameList=new ArrayList<String>();
//				for(java.util.Map.Entry<String, Object> entry  :deleteMap.entrySet()){
////		            System.out.println("键:"+ entry.getKey()+" 值:"+ entry.getValue());
//					userNameList.add(entry.getKey());
//		        }
//				if(userNameList.size()>0){
//					personnelBaseArchivesManageExportAndImportService.deleteUserByUserName(userNameList);
//				}
//
//			}
//			long end = System.currentTimeMillis();
//			System.out.println(end-start);
//		} catch (Exception e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//			j.setMsg("导入失败");
//			j.setSuccess(false);
//		}
//		return j;
//	}

    /**
     * 导入功能
     * @author zbw
     * 2017-12-13
     * @param request
     * @param response
     * @return
     */
    //@SuppressWarnings("unchecked")
    @RequestMapping(params = "importExcel", method = RequestMethod.POST)
    @ResponseBody
    public AjaxJson importExcel(HttpServletRequest request, HttpServletResponse response) {
        AjaxJson j = new AjaxJson();
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            cn.afterturn.easypoi.excel.entity.ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            Map<String,List<String>> errorInfoMap = new HashMap<>();
            try {
                List<PersonnelBaseArchivesManageExportAndImportDto> tsUserList = cn.afterturn.easypoi.excel.ExcelImportUtil.importExcel(file.getInputStream(), PersonnelBaseArchivesManageExportAndImportDto.class, params);
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                TSTypegroup typegroup1 = systemService.getTypeGroup("outLook","政治面貌");
                TSTypegroup typegroup2 = systemService.getTypeGroup("education","学历");
                TSTypegroup typegroup3 = systemService.getTypeGroup("nature", "员工性质");
                TSTypegroup typegroup4 = systemService.getTypeGroup("areaRegion", "所属网格区域");
                List<TSType> typeList1 = new ArrayList<>();
                List<TSType> typeList2 = new ArrayList<>();
                List<TSType> typeList3 = new ArrayList<>();
                List<TSType> typeList4 = new ArrayList<>();
                if(typegroup1 != null){
                    typeList1 = typegroup1.getTSTypes();
                    if(typeList1 == null || typeList1.size() < 0){
                        errorInfo(errorInfoMap,"字典表查询失败","outLook");
                    }
                }else{
                    errorInfo(errorInfoMap,"字典表查询失败","outLook");
                }
                if(typegroup2 != null){
                    typeList2 = typegroup2.getTSTypes();
                    if(typeList2 == null || typeList2.size() < 0){
                        errorInfo(errorInfoMap,"字典表查询失败","education");
                    }
                }else{
                    errorInfo(errorInfoMap,"字典表查询失败","education");
                }
                if(typegroup3 != null){
                    typeList3 = typegroup3.getTSTypes();
                    if(typeList3 == null || typeList3.size() < 0){
                        errorInfo(errorInfoMap,"字典表查询失败","nature");
                    }
                }else{
                    errorInfo(errorInfoMap,"字典表查询失败","nature");
                }
                if(typegroup4 != null){
                    typeList4 = typegroup4.getTSTypes();
                    if(typeList4 == null || typeList4.size() < 0){
                        errorInfo(errorInfoMap,"字典表查询失败","areaRegion");
                    }
                }else{
                    errorInfo(errorInfoMap,"字典表查询失败","areaRegion");
                }
                for (PersonnelBaseArchivesManageExportAndImportDto dao : tsUserList) {
                    TSUser tsUser1 = new TSUser();
                    tsUser1.setUserNum(dao.getUserNum());
                    tsUser1.setUserName(dao.getRealName());
                    tsUser1.setRealName(dao.getRealName());
                    if (StringUtil.isEmpty(dao.getGender()) || dao.getGender().contains("男") || "0".equals(dao.getGender())) {
                        tsUser1.setGender("0");
                    } else {
                        tsUser1.setGender("1");
                    }
                    tsUser1.setNation(dao.getNation());
                    tsUser1.setIdcard(dao.getIdcard());
                    if(dao.getIdcard().length() > 14){
                        Date toDate = new Date();
                        String toDateStr = dao.getIdcard().substring(6,10) + "-" + dao.getIdcard().substring(10,12) + "-" + dao.getIdcard().substring(12,14);
                        try {
                            toDate = sdf.parse(toDateStr);
                            tsUser1.setBirthday(toDate);
                            Calendar c1 = Calendar.getInstance();
                            Calendar c2 = Calendar.getInstance();
                            c1.setTime(toDate);
                            c2.setTime(new Date());
                            tsUser1.setAge(String.valueOf(c2.get(Calendar.YEAR) - c1.get(Calendar.YEAR)));
                        } catch (ParseException e) {
                            System.out.println(e.getMessage());
                        }
                    }
                    tsUser1.setMobilePhone(dao.getMobilePhone());
                    tsUser1.setOfficePhone(dao.getOfficePhone());
                    tsUser1.setAddress(dao.getAddress());
                    tsUser1.setEmail(dao.getEmail());
                    tsUser1.setDeviceId(dao.getDeviceId());
                    tsUser1.setHkaddress(dao.getHkaddress());
                    tsUser1.setHktype(dao.getHktype());
                    tsUser1.setEmploymentDate(dao.getEmploymentDate());
                    tsUser1.setDevFlag("0");
                    tsUser1.setDingIsSynchronization("0");
                    if(StringUtil.isNotEmpty(dao.getUserType()) && (dao.getUserType().contains("是") || "0".equals(dao.getUserType()))){
                        tsUser1.setUserType("0");
                    }else{
                        tsUser1.setUserType("1");
                    }

                    // 获取民族信息
                    StringBuilder nationSql = new StringBuilder();

                    nationSql.append(" SELECT ");
                    nationSql.append(" tp.id id,tp.typecode code,tp.typename name ");
                    nationSql.append(" FROM t_s_type tp ");
                    nationSql.append(" LEFT JOIN t_s_typegroup tpg ON tp.typegroupid = tpg.id ");
                    nationSql.append(" WHERE ");
                    nationSql.append(" tpg.typegroupcode  = 'nation' ");
                    nationSql.append("   and  tp.typename = '" + dao.getNation() + "' ");
                    List<Map<String, Object>> nationMapList = systemService.findForJdbc(nationSql.toString());

                    if (nationMapList != null && nationMapList.size() == 1) {
                        tsUser1.setNation(nationMapList.get(0).get("code").toString());
                    }

                    //部门  orgIds
                    try {
                        TSDepart depart = systemService.findUniqueByProperty(TSDepart.class, "departname", dao.getSysOrgCode());
                        if(depart == null || depart.getId() == null){
                            errorInfo(errorInfoMap,"部门查询失败",dao.getSysOrgCode());
                        }else{
                            tsUser1.setOrgIds(depart.getId());
                        }
                    } catch (Exception e) {
                        errorInfo(errorInfoMap,"部门查询失败",dao.getSysOrgCode());
                        log.error("部门查询失败！"+dao.getSysOrgCode());
                    }
                    //职务
                    try {
                        DutiesEntity dutiesEntity = systemService.findUniqueByProperty(DutiesEntity.class, "dutiesName", dao.getBelongDutiesName());
                        if(dutiesEntity == null || dutiesEntity.getId() == null){
                            errorInfo(errorInfoMap,"职务未找到",dao.getBelongDutiesName());
                        }else{
                            tsUser1.setDutiesId(dutiesEntity.getId());
                        }
                    } catch (Exception e) {
                        errorInfo(errorInfoMap,"职务未找到",dao.getBelongDutiesName());
                        log.error("职务未找到！"+dao.getBelongDutiesName());
                    }
                    //岗位
                    try {
                        PostEntity postEntity = systemService.findUniqueByProperty(PostEntity.class, "postName", dao.getInPostName());
                        if(postEntity == null || postEntity.getId() == null){
                            errorInfo(errorInfoMap,"岗位未找到",dao.getInPostName());
                        }else{
                            tsUser1.setPostId(postEntity.getId());
                        }
                    } catch (Exception e) {
                        errorInfo(errorInfoMap,"岗位未找到",dao.getInPostName());
                        log.error("岗位未找到！"+dao.getInPostName());
                    }
                    //政治面貌
                    try {
                        if(StringUtil.isNotEmpty(dao.getOutlook()) && typeList1.size() > 0){
                            for (TSType tsType:typeList1){
                                if(tsType.getTypename().equals(dao.getOutlook())){
                                    tsUser1.setOutlook(tsType.getTypecode());
                                }
                            }
                            if(tsUser1.getOutlook() == null){
                                errorInfo(errorInfoMap,"政治面貌未找到",dao.getOutlook());
                            }
                        }
                    } catch (Exception e) {
                        errorInfo(errorInfoMap,"政治面貌未找到",dao.getOutlook());
                        log.error("政治面貌未找到！"+dao.getOutlook());
                    }
                    //学历
                    try {
                        if(StringUtil.isNotEmpty(dao.getEducation()) && typeList2.size() > 0){
                            for (TSType tsType:typeList2){
                                if(tsType.getTypename().equals(dao.getEducation())){
                                    tsUser1.setEducation(tsType.getTypecode());
                                }
                            }
                            if(tsUser1.getEducation() == null){
                                errorInfo(errorInfoMap,"学历未找到",dao.getEducation());
                            }
                        }
                    } catch (Exception e) {
                        errorInfo(errorInfoMap,"学历未找到",dao.getEducation());
                        log.error("学历未找到！"+dao.getEducation());
                    }
                    //员工性质
                    try {
                        if(StringUtil.isNotEmpty(dao.getNature()) && typeList3.size() > 0){
                            for (TSType tsType:typeList3){
                                if(tsType.getTypename().equals(dao.getNature())){
                                    tsUser1.setNature(tsType.getTypecode());
                                }
                            }
                            if(tsUser1.getNature() == null){
                                errorInfo(errorInfoMap,"员工性质未找到",dao.getNature());
                            }
                        }
                    } catch (Exception e) {
                        errorInfo(errorInfoMap,"员工性质未找到",dao.getNature());
                        log.error("员工性质未找到！"+dao.getNature());
                    }
                    // 所属网格区域
                    try {
                        if(StringUtil.isNotEmpty(dao.getBelongRegion()) && typeList4.size() > 0){
                            for (TSType tsType:typeList4){
                                if(tsType.getTypename().equals(dao.getBelongRegion())){
                                    tsUser1.setAreaRegion(tsType.getTypecode());
                                }
                            }
                            if(tsUser1.getAreaRegion() == null){
                                errorInfo(errorInfoMap,"所属网格区域未找到",dao.getBelongRegion());
                            }
                        }
                    } catch (Exception e) {
                        errorInfo(errorInfoMap,"所属网格区域未找到",dao.getBelongRegion());
                        log.error("所属网格区域未找到！"+dao.getBelongRegion());
                    }
                    AjaxJson ajaxJson = saveUser(request, tsUser1);
                    if (!ajaxJson.isSuccess()) {
                        return ajaxJson;
                    }
                }
                if(errorInfoMap.size() > 0){
                    j.setMsg("文件导入成功！部分数据对照失败:"+errorInfoMap+"，请手动修改！");
                }else{
                    j.setMsg("文件导入成功！");
                }
            } catch (Exception e) {
                j.setMsg("文件导入成功！部分数据对照失败:"+errorInfoMap+"，请手动修改！");
                logger.error(ExceptionUtil.getExceptionMessage(e));
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return j;
    }

    private void errorInfo(Map<String,List<String>> errorMap,String MKey,String EValue){
        if(errorMap.containsKey(MKey)){
            errorMap.get(MKey).add(EValue);
        }else{
            List<String> errorInfoList = new ArrayList<>();
            errorInfoList.add(EValue);
            errorMap.put(MKey,errorInfoList);
        }
    }

    @RequestMapping(method = RequestMethod.GET)
    @ResponseBody
    public List<PersonnelBaseArchivesManageEntity> list() {
        List<PersonnelBaseArchivesManageEntity> listPersonnelBaseArchivesManages = personnelBaseArchivesManageService.getList(PersonnelBaseArchivesManageEntity.class);
        return listPersonnelBaseArchivesManages;
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<?> get(@PathVariable("id") String id) {
        PersonnelBaseArchivesManageEntity task = personnelBaseArchivesManageService.get(PersonnelBaseArchivesManageEntity.class, id);
        if (task == null) {
            return new ResponseEntity(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity(task, HttpStatus.OK);
    }

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

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

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

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

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

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

    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void delete(@PathVariable("id") String id) {
        personnelBaseArchivesManageService.deleteEntityById(PersonnelBaseArchivesManageEntity.class, id);
    }


    /**
     * 处理消息到期提醒逻辑
     *
     * @return
     */
//	http://192.168.100.117:8080/hgl/personnelBaseArchivesManageController/dealMessageExpirationAlert.do
    @RequestMapping(params = "dealMessageExpirationAlert")
    @ResponseBody
    public String dealMessageExpirationAlert() {
        try {
            personnelBaseArchivesManageService.dealMessageExpirationAlert();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return "操作成功";
    }


    /**
     * 员工照片批量上传
     * 证书批量上传
     * 附件追加批量上传
     * 文件管理表列表 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "batchUploadFile")
    public ModelAndView batchUploadFile(TSysFileDto tSysFileDto, HttpServletRequest request, HttpServletRequest req, WebUploadEntity webUpload) {
        if (null == webUpload) {
            webUpload = new WebUploadEntity();
        }

        if (tSysFileDto.getTagetType() != null && tSysFileDto.getTagetType().length() != 0) {
            if (tSysFileDto.getTagetType().equals(Globals.taget_type_0)) {
                webUpload.setBusiTable("t_s_base_user");
                webUpload.setBizType(Globals.taget_type_0);
                webUpload.setRemark("员工照片批量上传");
                webUpload.setExtensions("jpg,png");
                webUpload.setBusiId(Globals.busi_id_batch);
            } else if (tSysFileDto.getTagetType().equals(Globals.taget_type_1)) {
                webUpload.setBusiTable("t_bus_user_certificate");
                webUpload.setBizType(Globals.taget_type_1);
                webUpload.setRemark("员工证书批量上传");
                webUpload.setExtensions("jpg,png,pdf,doc,docx,xls,xlsx");
                webUpload.setBusiId(Globals.busi_id_batch);
            } else if (tSysFileDto.getTagetType().equals(Globals.taget_type_2)) {
                webUpload.setBusiTable("t_bus_accessory");
                webUpload.setBizType(Globals.taget_type_2);
                webUpload.setRemark("员工附件追加批量上传");
                webUpload.setExtensions("jpg,png,pdf,doc,docx,xls,xlsx");
                webUpload.setBusiId(Globals.busi_id_batch);
            }
            req.setAttribute("tagetType", tSysFileDto.getTagetType());
        } else {
            webUpload.setBusiTable("t_s_base_user");
            webUpload.setBizType(Globals.taget_type_0);
            webUpload.setRemark("员工照片批量上传");
            webUpload.setExtensions("jpg,png");
            webUpload.setBusiId(Globals.busi_id_batch);
            req.setAttribute("tagetType", Globals.taget_type_0);
        }

        String curUserName = ResourceUtil.getSessionUser().getUserName();
        req.setAttribute("curUserName", curUserName);
        req.setAttribute("webUpload", webUpload);
        req.setAttribute("showAndDownUrl", showAndDownUrl);

        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/batchUploadFile/tSysUploadFileList");
    }

    /**
     * 证书批量上传
     * 文件管理表列表 页面跳转
     *
     * @return
     */
	/*@RequestMapping(params = "batchUploadFileCertificate")
	public ModelAndView batchUploadFileCertificate(HttpServletRequest request, HttpServletRequest req,WebUploadEntity webUpload) {
		if (null == webUpload) {
			webUpload = new WebUploadEntity();
		}
		String curUserName = ResourceUtil.getSessionUser().getUserName();
		req.setAttribute("curUserName", curUserName);
		req.setAttribute("webUpload", webUpload);
		return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/batchUploadFile/tSysFileCertificateList");
	}*/


    /**
     * 附件追加批量上传
     * 文件管理表列表 页面跳转
     *
     * @return
     */
	/*@RequestMapping(params = "batchUploadFileAccessory")
	public ModelAndView batchUploadFileAccessory(HttpServletRequest request, HttpServletRequest req,WebUploadEntity webUpload) {
		if (null == webUpload) {
			webUpload = new WebUploadEntity();
		}
		String curUserName = ResourceUtil.getSessionUser().getUserName();
		req.setAttribute("curUserName", curUserName);
		req.setAttribute("webUpload", webUpload);
		return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/batchUploadFile/tSysFileAccessoryList");
	}*/


    /**
     * 员工照片查询
     * 证书查询
     * 附件追加查询
     * easyui AJAX请求数据
     *
     * @param request
     * @param response
     * @param dataGrid
     */

    @RequestMapping(params = "batchUploadFileList")
    public void batchUploadFileList(TSysFileDto tSysFileDto, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
		/*CriteriaQuery cq = new CriteriaQuery(TSysFileEntity.class, dataGrid);
		//查询条件组装器
		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, tSysFile, request.getParameterMap());
		try{
			//自定义追加查询条件
			//查询文件名称
			cq.like("fileName", tSysFile.getFileName());
			
			if(tSysFile.getTagetType()!=null){
				cq.eq("tagetType", tSysFile.getTagetType());
			}else{
				cq.eq("tagetType", "userPhoto");
			}
			
			
			//排序
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("createDate", "desc");
			cq.setOrder(map);
		}catch (Exception e) {
			throw new BusinessException(e.getMessage());
		}
		cq.add();
		this.personnelBaseArchivesManageService.getDataGridReturn(cq, true);
		TagUtil.datagrid(response, dataGrid);*/
        if (tSysFileDto.getTagetType() == null) {
            tSysFileDto.setTagetType("userPhoto");
        }
        MiniDaoPage<TSysFileDto> tSysFileDtoList = null;
        String authSql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        try {
            tSysFileDtoList = personnelBaseArchivesManageExportAndImportService.getTSysFileDtoPage(tSysFileDto, dataGrid.getPage(), dataGrid.getRows(), authSql);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (int i = 0; i < tSysFileDtoList.getResults().size(); i++) {
//			TSysFileEntity tSysFileEntity = (TSysFileEntity) tSysFileDtoList.getResults();
            String fileName = tSysFileDtoList.getResults().get(i).getFileName();
            String fileType = fileName.substring(fileName.lastIndexOf(".") + 1);
            if ("jpg".equals(fileType) || "png".equals(fileType) || "pdf".equals(fileType)) {
//				tSysFileEntity.setIsPreviewFlg("1");
                tSysFileDtoList.getResults().get(i).setIsPreviewFlg("1");
            } else {
//				tSysFileEntity.setIsPreviewFlg("0");
                tSysFileDtoList.getResults().get(i).setIsPreviewFlg("0");
            }

        }

        dataGrid.setTotal(tSysFileDtoList.getTotal());
        dataGrid.setResults(tSysFileDtoList.getResults());
        TagUtil.datagrid(response, dataGrid);


    }

    /**
     * 证书查询
     * easyui AJAX请求数据
     *
     * @param request
     * @param response
     * @param dataGrid
     * @param user
     */

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

    /**
     * 附件追加查询
     * easyui AJAX请求数据
     *
     * @param request
     * @param response
     * @param dataGrid
     * @param user
     */

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


//-----------------------------------------------------------------------------------------------------------

    /**
     * 弹出新建员工页面
     *
     * @param req
     * @return
     */
    @RequestMapping(params = "addorupdate")
    public ModelAndView addorupdate(TSUser userInfo, HttpServletRequest req) {
        if (StringUtil.isNotEmpty(userInfo.getId())) {
            userInfo = systemService.getEntity(TSUser.class, userInfo.getId());

            this.idandname(req, userInfo);
            this.getOrgInfos(req, userInfo);

            this.getDutiesInfos(req, userInfo);
            req.setAttribute("userInfo", userInfo);
//			this.getJzOrgInfos(req, userInfo);
            if (req.getParameter("isCheck") != null) {
                return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/userInfo-check");
            }
            return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/userInfo-update");
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/userInfo-add");
    }

    /**
     * 查看 页面跳转
     *
     * @return
     */
    @RequestMapping(params = "checkMan")
    public ModelAndView checkMan(String id, HttpServletRequest request) {
        request.setAttribute("id", id);
        String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
        if (oConvertUtils.isNotEmpty(queryParams)) {
            request.setAttribute("queryParams", queryParams);
        }
        return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/userInfo-check");
    }

    public void idandname(HttpServletRequest req, TSUser user) {
        List<TSRoleUser> roleUsers = systemService.findByProperty(TSRoleUser.class, "TSUser.id", user.getId());
        String roleId = "";
        String roleName = "";
        if (roleUsers.size() > 0) {
            for (TSRoleUser tRoleUser : roleUsers) {
                roleId += tRoleUser.getTSRole().getId() + ",";
                roleName += tRoleUser.getTSRole().getRoleName() + ",";
            }
        }
        req.setAttribute("id", roleId);
        req.setAttribute("roleName", roleName);
    }


    public void getOrgInfos(HttpServletRequest req, TSUser user) {
//			List<TSUserOrg> tSUserOrgs = systemService.findByProperty(TSUserOrg.class, "tsUser.id", user.getId());
        // 查询项目经理的所属机构 by zhijia.wang
        List<TSUserOrg> tSUserOrgs = new ArrayList<TSUserOrg>();
        List<TSUserOrg> normalList = systemService.findHql(
                "from TSUserOrg where tsUser=? and ifpluralism=? and status=? order by intime desc", user, Globals.PLURALISM_NO.toString(), Globals.BELONG_STATUS_NORMAL.toString());
        if (normalList != null && normalList.size() > 0) {
            tSUserOrgs.addAll(normalList);
        } else {
            List<TSUserOrg> moveList = systemService.findHql("from TSUserOrg where tsUser=? and ifpluralism=? order by intime desc", user, Globals.PLURALISM_NO.toString());
            if (moveList != null && moveList.size() > 0) {
                tSUserOrgs.add(moveList.get(0));
            }
        }

        String orgIds = "";
        String departname = "";
        if (tSUserOrgs.size() > 0) {
            for (TSUserOrg tSUserOrg : tSUserOrgs) {
                orgIds += tSUserOrg.getTsDepart().getId() + ",";
                if (tSUserOrg.getTsDepart().getDepartname().equals(tSUserOrg.getTsDepart().getGlcName())) {
                    departname += tSUserOrg.getTsDepart().getDepartname() + ",";
                } else {
                    departname += tSUserOrg.getTsDepart().getGlcName() + "-" + tSUserOrg.getTsDepart().getDepartname() + ",";
                }

            }
        }
        req.setAttribute("orgIds", orgIds);
        if (StringUtil.isNotEmpty(departname)) {
            departname = departname.substring(0, departname.length() - 1);
        }
        req.setAttribute("departname", departname);
    }

    public void getDutiesInfos(HttpServletRequest req, TSUser user) {
//			List<TSUserOrg> tSUserOrgs = systemService.findByProperty(TSUserOrg.class, "tsUser.id", user.getId());
        // 查询项目经理的兼容机构 by zhijia.wang
        List<PersonnelBaseArchivesManageEntity> pamList = systemService.findHql(
                "from PersonnelBaseArchivesManageEntity where userid=? ", user.getId());

        if (pamList.size() > 0) {
            try {

                user.setDutiesId(pamList.get(0).getBelongDutiesid());
                user.setPostId(pamList.get(0).getInPostid());

                DutiesEntity dutiesEntity = systemService.get(DutiesEntity.class, user.getDutiesId());

                req.setAttribute("dutiesName", dutiesEntity.getDutiesName());
                ZTreePostEntity zTreePostEntity = systemService.get(ZTreePostEntity.class, user.getPostId());

                req.setAttribute("postName", zTreePostEntity.getPostName());

            } catch (Exception e) {

            }
        }
    }


    public void getJzOrgInfos(HttpServletRequest req, TSUser user) {
//			List<TSUserOrg> tSUserOrgs = systemService.findByProperty(TSUserOrg.class, "tsUser.id", user.getId());
        // 查询项目经理的兼容机构 by zhijia.wang
        List<TSUserOrg> tSUserOrgs = systemService.findHql(
                "from TSUserOrg where tsUser=? and ifpluralism=? and status=? ", user, Globals.PLURALISM_YES.toString(), Globals.BELONG_STATUS_NORMAL.toString());
        String jzorgIds = "";
        String jzdepartname = "";
        if (tSUserOrgs.size() > 0) {
            for (TSUserOrg tSUserOrg : tSUserOrgs) {
                jzorgIds += tSUserOrg.getTsDepart().getId() + ",";
                if (tSUserOrg.getTsDepart().getDepartname().equals(tSUserOrg.getTsDepart().getGlcName())) {
                    jzdepartname += tSUserOrg.getTsDepart().getDepartname() + ",";
                } else {
                    jzdepartname += tSUserOrg.getTsDepart().getGlcName() + "-" + tSUserOrg.getTsDepart().getDepartname() + ",";
                }
            }
        }
        req.setAttribute("jzorgIds", jzorgIds);
        if (StringUtil.isNotEmpty(jzdepartname)) {
            jzdepartname = jzdepartname.substring(0, jzdepartname.length() - 1);
        }
        req.setAttribute("jzdepartname", jzdepartname);
    }


    /**
     * 新建员工基本信息
     *
     * @param user
     * @param req
     * @return
     */
    @RequestMapping(params = "saveUser")
    @ResponseBody
    public AjaxJson saveUser(HttpServletRequest req, TSUser user) {
        String message = null;
        String orgIds = oConvertUtils.getString(req.getParameter("orgIds"));//兼职机构ID数组
        if (StringUtil.isEmpty(orgIds)) {
            orgIds = user.getOrgIds();
        }
        AjaxJson j = new AjaxJson();
//		if(true) return null;
//		String roleid = oConvertUtils.getString(req.getParameter("roleid"));

//		String yxyg_roleid = null;// 一线员工的角色ID
//		List<TSRole> yxyg_roleList = systemService.findByProperty(TSRole.class, "roleCode", Globals.roleCode_yxyg);
//		if(yxyg_roleList != null && yxyg_roleList.size() > 0){
//			yxyg_roleid = yxyg_roleList.get(0).getId();// 一线员工的角色ID
//		}
//
//		String roleid = null;
//		if(Globals.userType_1.equals(user.getUserType())){
//			roleid = yxyg_roleid;
//		}

        // 得到默认密码
        String password = ResourceUtil.getConfigByName("defaultPassword");

        TSUser users = null;
        try {
            users = systemService.findUniqueByProperty(TSUser.class, "userNum", user.getUserNum());

        } catch (Exception e) {
            message = "员工号: " + user.getUserNum() + "已经存在";
            j.setMsg(message);
            j.setSuccess(false);
            return j;

        }
        if (users != null) {
            message = "员工号: " + user.getUserNum() + "已经存在";
            j.setMsg(message);
            j.setSuccess(false);
            return j;
        }
        // 获取用户信息
        StringBuilder suserSql = new StringBuilder();

        suserSql.append(" SELECT ");
        suserSql.append(" id ");
        suserSql.append(" FROM t_s_base_user ");
        suserSql.append(" WHERE ");
        suserSql.append(" username = '" + user.getMobilePhone() + "' ");
        suserSql.append(" AND delete_flag <> '1'");
        List<Map<String, Object>> suserMapList = systemService.findForJdbc(suserSql.toString());

        StringBuilder suserSqlidcard = new StringBuilder();

        suserSqlidcard.append(" SELECT ");
        suserSqlidcard.append(" suser.id ");
        suserSqlidcard.append(" FROM t_s_user suser ");
        suserSqlidcard.append(" LEFT JOIN t_s_base_user sbaseuser ON suser.id = sbaseuser.id ");
        suserSqlidcard.append(" WHERE ");
        suserSqlidcard.append(" suser.idcard = '" + user.getIdcard() + "' ");
        suserSqlidcard.append(" AND sbaseuser.delete_flag <> '1' ");
        List<Map<String, Object>> suserMapListidcard = systemService.findForJdbc(suserSqlidcard.toString());

        if (suserMapListidcard.size() > 0) {
            message = "身份证号已经存在，请核对后输入。";
            j.setSuccess(false);
            j.setMsg(message);
            return j;
        }

        if (suserMapList.size() > 0) {
            message = "员工手机号: " + user.getMobilePhone() + "已经存在.";//，无法同步考勤机。请尝试其它手机号码，或寻求信息部支持。
            j.setSuccess(false);
        } else {
            // 加盐
            //user.setPassword(PasswordUtil.encrypt(user.getUserName(), password, PasswordUtil.getStaticSalt()));
            // 去掉空格
            if (user.getRealName() != null) {
                String trim = user.getRealName().replaceAll(" ", "");
                user.setRealName(trim);
            }
            if (user.getIdcard() != null) {
                String up = user.getIdcard().toUpperCase();
                user.setIdcard(up);
            }
            user.setUserName(user.getMobilePhone());
            user.setPassword(PasswordEncodeUtil.getMD5(password));
            user.setStatus(Globals.User_Normal);
            user.setDeleteFlag(Globals.Delete_Normal);
            user.setDingIsSynchronization(Globals.DingIsSynchronization_NO.toString());//是否同步到钉钉：0不同步
            //systemService.save(user);
            String[] departId = orgIds.split(",");
            user.setDepartid(departId[0]);
            userService.saveOrUpdateUser(user);

            // 保存1个组织机构
            String msg = saveUserOrgList(req, user);
            if (msg != null && !"".equals(msg.trim())) {
                j.setMsg(msg);
                j.setSuccess(false);
                return j;
            }
            message = "员工: " + user.getUserName() + "基本信息添加成功";
            j.setSuccess(true);
            //保存岗位 职责
            doAddDutiesAndPostName(user, req);
//			if (StringUtil.isNotEmpty(roleid)) {
//				saveRoleUser(user, roleid);
//			}

            List<String> orgIdList = extractIdListByComma(orgIds);
            TSDepart depart = departService.getEntity(TSDepart.class, orgIdList.get(0));

            if (StringUtil.isNotEmpty(depart.getDingdepartid())) {
                List<Long> departIdList = new ArrayList<Long>();
                departIdList.add(Long.valueOf(depart.getDingdepartid()));

//				CorpUserDetail corpUserDetail = dingdingService.getUser(user.getId());
//				boolean dingFlg = false;
//				if(StringUtil.isNotEmpty(corpUserDetail.getUserid())) {
//					dingFlg = dingdingService.updateUser(user.getId(), user.getRealName(), departIdList,user.getMobilePhone(), user.getUserName());
//				} else {
//					dingFlg = dingdingService.createUser(user.getId(), user.getRealName(), departIdList,user.getMobilePhone(), user.getUserName());
//				}
//				if(dingFlg) {
//					message = "数据保存成功，钉钉同步成功！";
//					user.setDingIsSynchronization(Globals.DingIsSynchronization_YES.toString());
//				}else{
//					message = "数据保存成功，钉钉同步失败！";
//					user.setDingIsSynchronization(Globals.DingIsSynchronization_NO.toString());
//				}
            } else {
                message = "数据保存成功，所属部门没有同步到钉钉，同步失败！";
            }
            systemService.saveOrUpdate(user);

//			try {
//				//处理附件追加用户默认固定附件类型
//				personnelBaseArchivesManageService.dealAccessoryIsFixedDefault(user.getId());
//			} catch (Exception e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}

            systemService.addLog(message, Globals.Log_Type_INSERT, Globals.Log_Leavel_INFO);
            // 保存职务和岗位


        }

        j.setMsg(message);
        logger.info("[" + IpUtil.getIpAddr(req) + "][添加编辑员工]" + message);
        return j;
    }


    /**
     * 编辑员工基本信息
     *
     * @return
     */
    @RequestMapping(params = "updateUserData")
    @ResponseBody
    public AjaxJson updateUserData(TSUser userInfo, HttpServletRequest req) {
        String message = "编辑成功";
        AjaxJson j = new AjaxJson();

        if (StringUtil.isNotEmpty(userInfo.getId())) {

            // 判断身份证号是否重复
            StringBuilder suserSql = new StringBuilder();

            suserSql.append(" SELECT ");
            suserSql.append(" suser.id ");
            suserSql.append(" FROM t_s_user suser ");
            suserSql.append(" LEFT JOIN t_s_base_user sbaseuser ON suser.id = sbaseuser.id ");
            suserSql.append(" WHERE ");
            suserSql.append(" suser.idcard = '" + userInfo.getIdcard() + "' ");
            suserSql.append(" And suser.id != '" + userInfo.getId() + "' ");
            suserSql.append(" AND sbaseuser.delete_flag <> '1' ");
            List<Map<String, Object>> suserMapList = systemService.findForJdbc(suserSql.toString());

            if (suserMapList.size() > 0) {
                message = "身份证号已经存在，更新失败！";
                j.setSuccess(false);
                j.setMsg(message);
                return j;
            }

            TSUser users = systemService.getEntity(TSUser.class, userInfo.getId());
            // 设置用户角色相关信息start
            List<TSRoleUser> ru = systemService.findByProperty(TSRoleUser.class, "TSUser.id", userInfo.getId());
            if (users.getUserType() != null && !"".equals(users.getUserType())) {
                if (Globals.userType_0.equals(users.getUserType()) && Globals.userType_1.equals(userInfo.getUserType())) {// 由管理员工改为普通员工
                    systemService.deleteAllEntitie(ru);
                    String yxyg_roleid = null;// 一线员工的角色ID
                    List<TSRole> yxyg_roleList = systemService.findByProperty(TSRole.class, "roleCode", Globals.roleCode_yxyg);
                    if (yxyg_roleList != null && yxyg_roleList.size() > 0) {
                        yxyg_roleid = yxyg_roleList.get(0).getId();// 一线员工的角色ID
                    }
                    message = "员工: " + users.getUserName() + "基本信息更新成功";
                    j.setSuccess(true);
                    if (StringUtil.isNotEmpty(yxyg_roleid)) {
                        this.saveRoleUser(users, yxyg_roleid);
                    }
                } else if (Globals.userType_1.equals(users.getUserType()) && Globals.userType_0.equals(userInfo.getUserType())) {// 由普通员工改为管理员工
                    systemService.deleteAllEntitie(ru);
                }
            } else {
                if (Globals.userType_1.equals(userInfo.getUserType())) {// 修改为普通员工
                    systemService.deleteAllEntitie(ru);
                    String yxyg_roleid = null;// 一线员工的角色ID
                    List<TSRole> yxyg_roleList = systemService.findByProperty(TSRole.class, "roleCode", Globals.roleCode_yxyg);
                    if (yxyg_roleList != null && yxyg_roleList.size() > 0) {
                        yxyg_roleid = yxyg_roleList.get(0).getId();// 一线员工的角色ID
                    }
                    message = "员工: " + users.getUserName() + "基本信息更新成功";
                    j.setSuccess(true);
                    if (StringUtil.isNotEmpty(yxyg_roleid)) {
                        this.saveRoleUser(users, yxyg_roleid);
                    }
                } else {
                    systemService.deleteAllEntitie(ru);
                }
            }
            // 设置用户角色相关信息end

            if (userInfo.getRealName() != null) {
                String trim = userInfo.getRealName().replaceAll(" ", "");
                userInfo.setRealName(trim);
            }
            if (userInfo.getIdcard() != null) {
                String up = userInfo.getIdcard().toUpperCase();
                userInfo.setIdcard(up);
            }
            users.setUserType(userInfo.getUserType());// 设置员工类型
            users.setUserNum(userInfo.getUserNum());
            users.setOfficePhone(userInfo.getOfficePhone());
            users.setEmail(userInfo.getEmail());
            users.setDevFlag(userInfo.getDevFlag());// 开发权限标志
            users.setGender(userInfo.getGender());
            users.setNation(userInfo.getNation());
            users.setIdcard(userInfo.getIdcard());
            users.setAddress(userInfo.getAddress());
            users.setHkaddress(userInfo.getHkaddress());
            users.setRealName(userInfo.getRealName());
            users.setMobilePhone(userInfo.getMobilePhone());
            users.setHktype(userInfo.getHktype());
            users.setEducation(userInfo.getEducation());

            users.setBirthday(userInfo.getBirthday());
            users.setPostId(userInfo.getPostId());
            users.setEmploymentDate(userInfo.getEmploymentDate());
            users.setDutiesId(userInfo.getDutiesId());
            users.setDeviceId(userInfo.getDeviceId());
            users.setImage(userInfo.getImage());
            users.setContacts(userInfo.getContacts());
            users.setContactsPhone(userInfo.getContactsPhone());
            users.setNature(userInfo.getNature());
            users.setAge(userInfo.getAge());
            users.setOutlook(userInfo.getOutlook());
            users.setAreaRegion(userInfo.getAreaRegion());
            users.setStatus(Globals.User_Normal);
            // 修改base表username
            TSBaseUser tu = tsBaseUserService.getById(userInfo.getId());
            tu.setUsername(userInfo.getMobilePhone());
            tsBaseUserService.updateById(tu);

//	          systemService.executeSql("delete from t_s_user_org where user_id=? ", user.getId());
            // 保存1个组织机构
            String msg = saveUserOrgList(req, userInfo);
            if (msg != null && !"".equals(msg.trim())) {
                j.setMsg(msg);
                j.setSuccess(false);
                return j;
            }

//	          users.setTSDepart(user.getTSDepart());
//			users.setActivitiSync(userInfo.getActivitiSync());// 是否同步工作流引擎
//			users.setDingIsSynchronization(userInfo.getDingIsSynchronization());// 是否同步到钉钉
            //systemService.updateEntitie(users);

//			String orgIds = oConvertUtils.getString(req.getParameter("orgIds"));// 兼职机构ID数组
//	        List<String> orgIdList = extractIdListByComma(orgIds);
//			TSDepart depart = departService.getEntity(TSDepart.class, orgIdList.get(0));

//			if(StringUtil.isNotEmpty(depart.getDingdepartid())) {
//				List<Long> departIdList = new ArrayList<Long>();
//				departIdList.add(Long.valueOf(depart.getDingdepartid()));
//
//				CorpUserDetail corpUserDetail = dingdingService.getUser(userInfo.getId());
//				boolean dingFlg = false;
//				if(StringUtil.isNotEmpty(corpUserDetail.getUserid())) {
//					dingFlg = dingdingService.updateUser(userInfo.getId(), userInfo.getRealName(), departIdList,userInfo.getMobilePhone(), userInfo.getUserName());
//				} else {
//					dingFlg = dingdingService.createUser(userInfo.getId(), userInfo.getRealName(), departIdList,userInfo.getMobilePhone(), userInfo.getUserName());
//				}
//				if(dingFlg) {
//					message = "数据保存成功，钉钉数据同步成功！";
//					users.setDingIsSynchronization(Globals.DingIsSynchronization_YES.toString());
//				}else{
//					message = "数据保存成功，钉钉数据同步失败！";
//					users.setDingIsSynchronization(Globals.DingIsSynchronization_NO.toString());
//				}
//			} else {
//				message = "数据保存成功，所属部门没有同步到钉钉，同步失败！";
//			}
//			systemService.updateEntitie(users);
            userService.saveOrUpdateUser(users);////将该员工同步至工作流内
            systemService.addLog(message, Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
            // 保存职务和岗位
            doAddDutiesAndPostName(users, req);

        } else {
            message = "数据异常！";
            j.setSuccess(false);
        }
        j.setMsg(message);
        logger.info("[" + IpUtil.getIpAddr(req) + "][编辑员工]" + message);
        return j;
    }

    /**
     * 添加职务岗位
     */
    public boolean doAddDutiesAndPostName(TSUser users, HttpServletRequest request) {

        PersonnelBaseArchivesManageEntity personnelBaseArchivesManage = new PersonnelBaseArchivesManageEntity();
        personnelBaseArchivesManage.setUserid(users.getId());
        personnelBaseArchivesManage.setInPostid(users.getPostId());
        personnelBaseArchivesManage.setBelongDutiesid(users.getDutiesId());
        // 根据userId判断用户是否已经维护了员工人事信息表
        String personnelBaseArchivesManageByUserIdHql = "from PersonnelBaseArchivesManageEntity where userid = ?";
        List<PersonnelBaseArchivesManageEntity> personnelBaseArchivesManageEntityList = personnelBaseArchivesManageService.findHql(personnelBaseArchivesManageByUserIdHql, personnelBaseArchivesManage.getUserid());
        if (personnelBaseArchivesManageEntityList.size() > 0) {
            personnelBaseArchivesManage.setId(personnelBaseArchivesManageEntityList.get(0).getId());
        }

        if (StringUtil.isNotEmpty(personnelBaseArchivesManage.getId())) {
            PersonnelBaseArchivesManageEntity t = personnelBaseArchivesManageService.get(PersonnelBaseArchivesManageEntity.class, personnelBaseArchivesManage.getId());
            try {
                // 维护员工人事变动表数据
                if (Globals.JOBSTATUS_1.equals(personnelBaseArchivesManage.getPositionStatus()) && !Globals.JOBSTATUS_1.equals(t.getPositionStatus())
                        || Globals.JOBSTATUS_2.equals(personnelBaseArchivesManage.getPositionStatus()) && !Globals.JOBSTATUS_2.equals(t.getPositionStatus())) {
                    this.saveUserChangesLog(personnelBaseArchivesManage.getUserid(), personnelBaseArchivesManage.getIfpayment(), personnelBaseArchivesManage.getPositionStatus());
                }
                // 试用期为【无】时，转正日期=合同开始日期
//				if(Globals.SHIYONGQI_0.equals(personnelBaseArchivesManage.getTrialPeriod().toString())) {
//					t.setCorrectionDate(personnelBaseArchivesManage.getContractStime());
//				}
//				if(personnelBaseArchivesManage.getBelongDutiesid() != null && !personnelBaseArchivesManage.getBelongDutiesid().equals(t.getBelongDutiesid())) {
//					resetDutyAndPost(personnelBaseArchivesManage);
//				}
                MyBeanUtils.copyBeanNotNull2Bean(personnelBaseArchivesManage, t);
                personnelBaseArchivesManageService.saveOrUpdate(t);

                systemService.addLog("员工人事信息更新成功", Globals.Log_Type_UPDATE, Globals.Log_Leavel_INFO);
            } catch (Exception e) {
                e.printStackTrace();

                throw new BusinessException(e.getMessage());
            }
        } else {
            try {
                // 维护员工人事变动表数据
                if (Globals.JOBSTATUS_1.equals(personnelBaseArchivesManage.getPositionStatus())
                        || Globals.JOBSTATUS_2.equals(personnelBaseArchivesManage.getPositionStatus())) {
                    this.saveUserChangesLog(personnelBaseArchivesManage.getUserid(), personnelBaseArchivesManage.getIfpayment(), personnelBaseArchivesManage.getPositionStatus());
                }
                // 试用期为【无】时，转正日期=合同开始日期
                if (personnelBaseArchivesManage.getTrialPeriod() != null && Globals.SHIYONGQI_0.equals(personnelBaseArchivesManage.getTrialPeriod().toString())) {
                    personnelBaseArchivesManage.setCorrectionDate(personnelBaseArchivesManage.getContractStime());
                }
//				if(personnelBaseArchivesManage.getBelongDutiesid() != null) {
//					resetDutyAndPost(personnelBaseArchivesManage);
//				}
                personnelBaseArchivesManageService.save(personnelBaseArchivesManage);

                systemService.addLog("员工人事信息添加成功", Globals.Log_Type_INSERT, Globals.Log_Leavel_INFO);
            } catch (Exception e) {
                e.printStackTrace();

                throw new BusinessException(e.getMessage());
            }
        }
        return true;
    }

    /**
     * 保存 用户-组织机构 关系信息
     *
     * @param request request
     * @param user    user
     */
    private String saveUserOrgList(HttpServletRequest request, TSUser user) {
        String orgIds = oConvertUtils.getString(request.getParameter("orgIds"));//组织机构ID数组
        if (StringUtil.isEmpty(orgIds)) {//导入部门信息
            orgIds = user.getOrgIds();
        }
        String jzorgIds = oConvertUtils.getString(request.getParameter("jzorgIds"));//兼职机构ID数组
        String msg = null;
//-------------------------设置该用户的组织机构关系-------------------------
        List<String> orgIdList = extractIdListByComma(orgIds);
        String orgId = orgIdList.get(0);//目前规定一个人只能有一个组织机构
        List<String> removedOrgList = new ArrayList<>();//移除的组织机构 包括兼职和非兼职
        //查询该用户所有的组织机构
        List<TSUserOrg> userOrgList = systemService.findHql(
                "from TSUserOrg where tsUser.id=? and ifpluralism=? order by intime desc", user.getId(), Globals.PLURALISM_NO.toString());
        if (userOrgList != null && userOrgList.size() > 0) {
            TSUserOrg uo = userOrgList.get(0);//取出该用户最新的一条组织机构关系记录

            if (!uo.getTsDepart().getId().equals(orgId)) {//如果数据库中最新的一条数据的组织机构ID 和页面传过来的ID不一样
                removedOrgList.add(uo.getTsDepart().getId());
                boolean delFlag = false;
                if (uo.getStatus().equals(Globals.BELONG_STATUS_NORMAL.toString())) {
                    delFlag = true;
                }
                if (getProjectStatus(orgId)) {
                    if (delFlag) {
                        // 删除在原有组织机构的组织关系、排班、工资策略等
                        dealOldOrgInfos(user, uo, orgId);
                    }
                    TSDepart depart = new TSDepart();
                    depart.setId(orgId);
                    TSUserOrg userOrg = new TSUserOrg();
                    userOrg.setTsUser(user);
                    userOrg.setTsDepart(depart);
                    userOrg.setIfpluralism(Globals.PLURALISM_NO.toString());
                    userOrg.setStatus(Globals.BELONG_STATUS_NORMAL.toString());
                    userOrg.setIntime(new Date());
                    systemService.save(userOrg);
                } else {
                    msg = "该组织机构已停用，不可选！";
                }
            }
        } else {//该用户还没有组织机构，说明是新建的用户，所以直接插入一条组织机构关系即可
            if (getProjectStatus(orgId)) {
                TSDepart depart = new TSDepart();
                depart.setId(orgId);
                TSUserOrg userOrg = new TSUserOrg();
                userOrg.setTsUser(user);
                userOrg.setTsDepart(depart);
                userOrg.setIfpluralism(Globals.PLURALISM_NO.toString());
                userOrg.setStatus(Globals.BELONG_STATUS_NORMAL.toString());
                userOrg.setIntime(new Date());
                systemService.save(userOrg);
            } else {
                msg = "该组织机构已停用，不可选！";
            }
        }


//-------------------------设置该用户的兼职机构-------------------------
	/*	List<String> orgIdList_jz = extractIdListByComma(jzorgIds);
		List<TSUserOrg> jzuserOrg4AddList = new ArrayList<TSUserOrg>();
		List<TSUserOrg> jzuserOrg4DelList = new ArrayList<TSUserOrg>();

		Map<String, String> jzOrgMap = new HashMap<String, String>();
		if(orgIdList_jz!=null && orgIdList_jz.size()>0){
			for(String jzorgId : orgIdList_jz){
				jzOrgMap.put(jzorgId, null);
			}
		}

		//查询该用户所有的兼职机构关系
		List<TSUserOrg> jzList = systemService.findHql("from TSUserOrg where tsUser.id=? and ifpluralism=? order by intime desc", user.getId(), Globals.PLURALISM_YES.toString());
		if(jzList!=null && jzList.size()>0){
			Map<String, TSUserOrg> myJzOrgMap = new HashMap<String, TSUserOrg>();
			for(TSUserOrg jz : jzList){
				myJzOrgMap.put(jz.getTsDepart().getId(), jz);
			}

			for(int i=0; i<jzList.size(); i++){
				TSUserOrg jz = jzList.get(i);//用户原兼职机构关系
				if(orgIdList_jz!=null && orgIdList_jz.size()>0){
					for(String jzorgId : orgIdList_jz){
						if(jz.getTsDepart().getId().equals(jzorgId)){//如果数据库中最新的一条数据的组织机构ID 和页面传过来的ID一样
							jzOrgMap.remove(jzorgId);
							myJzOrgMap.remove(jzorgId);
						}
					}
				}else{
					if(jz.getStatus().equals(Globals.BELONG_STATUS_NORMAL.toString())){
						jzuserOrg4DelList.add(jz);
					}
				}
			}

			if(!jzOrgMap.isEmpty()){
				for(String key : jzOrgMap.keySet()){
					if(!getProjectStatus(key)){
						TSDepart depart = departService.getEntity(TSDepart.class, key);
						msg = depart.getDepartname()+"  已停用，请选择其他兼职机构";
						return msg;
					}
					TSDepart depart = new TSDepart();
					depart.setId(key);
					TSUserOrg userOrg_jz = new TSUserOrg();
					userOrg_jz.setTsUser(user);
					userOrg_jz.setTsDepart(depart);
					userOrg_jz.setIfpluralism(Globals.PLURALISM_YES.toString());//1是兼职机构
					userOrg_jz.setStatus(Globals.BELONG_STATUS_NORMAL.toString());//0正常
					userOrg_jz.setIntime(new Date());
					jzuserOrg4AddList.add(userOrg_jz);
				}
			}
			if(!myJzOrgMap.isEmpty()){
				for(String key : myJzOrgMap.keySet()){
					TSUserOrg ts = myJzOrgMap.get(key);
					if(ts.getStatus().equals(Globals.BELONG_STATUS_NORMAL.toString())){
						jzuserOrg4DelList.add(ts);
					}
				}
			}

			if(!jzuserOrg4DelList.isEmpty()){
				for(TSUserOrg userOrg :jzuserOrg4DelList){
					removedOrgList.add(userOrg.getTsDepart().getId());
				}
	            systemService.deleteAllEntitie(jzuserOrg4DelList);
	        }
			if(!jzuserOrg4AddList.isEmpty()){
	            systemService.batchSave(jzuserOrg4AddList);
	        }

		}else{
			if(orgIdList_jz!=null && orgIdList_jz.size()>0){
				for(String jzorgId : orgIdList_jz){
					if(!getProjectStatus(jzorgId)){
						TSDepart depart = departService.getEntity(TSDepart.class, jzorgId);
						msg = depart.getDepartname()+"  已停用，请选择其他兼职机构";
						return msg;
					}
					TSDepart depart = new TSDepart();
					depart.setId(jzorgId);
					TSUserOrg userOrg_jz = new TSUserOrg();
					userOrg_jz.setTsUser(user);
					userOrg_jz.setTsDepart(depart);
					userOrg_jz.setIfpluralism(Globals.PLURALISM_YES.toString());//1是兼职机构
					userOrg_jz.setStatus(Globals.BELONG_STATUS_NORMAL.toString());//0正常
					userOrg_jz.setIntime(new Date());
					jzuserOrg4AddList.add(userOrg_jz);
				}
			}
			if(!jzuserOrg4AddList.isEmpty()){
	            systemService.batchSave(jzuserOrg4AddList);
	        }
		}*/
        if (removedOrgList.size() > 0) {
            tBCostPettyCashAccountService.onChangeDepart(user.getId(), removedOrgList.toArray(new String[removedOrgList.size()]));
        }
        return msg;
    }


    /**
     * @param user  用户
     * @param uo    组织关系
     * @param orgId 新组织机构
     */
    private void dealOldOrgInfos(TSUser user, TSUserOrg uo, String orgId) {
        TSDepart oldDepart = uo.getTsDepart();

        List<ArrangeDutyOperateEntity> list = systemService.findHql("from ArrangeDutyOperateEntity where userid like ? ", "%" + user.getId() + "%");
        List<ProjarrangeDetailEntity> projarrangeDetailEntityList = systemService.findByProperty(ProjarrangeDetailEntity.class, "userid", user.getId());
        List<UserWagestrategyEntity> uwlist = systemService.findByProperty(UserWagestrategyEntity.class, "userid", user.getId());

        for (ArrangeDutyOperateEntity operateEntity : list) {
            String operateUserIds = operateEntity.getUserid();
            String[] operateUserIdArr = operateUserIds.split(",");
            if (operateUserIdArr.length == 1 && operateUserIdArr[0].equals(user.getId())) {
                systemService.delete(operateEntity);
                continue;
            }
            List<String> idList = new ArrayList<String>(operateUserIdArr.length);
            for (String id : operateUserIdArr) {
                if (id.equals(user.getId())) continue;
                idList.add(id);
            }
            operateEntity.setUserid(org.apache.commons.lang.StringUtil.join(idList.toArray(new Object[idList.size()]), ","));
            systemService.updateEntitie(operateEntity);
        }
        //更新t_bus_user_arrange_detail  t_bus_projarrange_detail

        if (projarrangeDetailEntityList != null && !projarrangeDetailEntityList.isEmpty()) {
            for (ProjarrangeDetailEntity projarrangeDetailEntity : projarrangeDetailEntityList) {
                List<UserArrangeDetailEntity> tempList = systemService.findByProperty(UserArrangeDetailEntity.class, "projarrangeDetailid", projarrangeDetailEntity.getId());
                systemService.deleteAllEntitie(tempList);
            }
            systemService.deleteAllEntitie(projarrangeDetailEntityList);
        }
        //更新t_bus_user_wagestrategy 换成新的组织机构

        if (uwlist != null && !uwlist.isEmpty()) {
            for (UserWagestrategyEntity sw : uwlist) {
                sw.setBelongUnitid(orgId);
                sw.setPjtId(getBybelongId(orgId));
                systemService.saveOrUpdate(sw);
            }
        }

        //删除组织关系
        systemService.delete(uo);
    }

    public String getBybelongId(String orgid) {
        String temp = "";
        StringBuffer hql = new StringBuffer("from TSDepart where id = :oid");
        List<TSDepart> tsList = systemService.getSession().createQuery(hql.toString()).setParameter("oid", orgid).list();
        if (!tsList.isEmpty()) {
            TSDepart tsDepart = tsList.get(0);
            temp = tsDepart.getGlcid();
        }
        return temp;
    }

    /**
     * 查询项目停用、启用情况
     *
     * @param id
     * @return
     */
    private boolean getProjectStatus(String id) {
        TSDepart t = systemService.get(TSDepart.class, id);
        if (t.getStatus().equals(Globals.Enabled_Status.toString())) {
            return true;//启用
        } else {
            return false;//停用
        }
    }

    /**
     * 保存用户与角色的关系列表
     *
     * @param user //     * @param roleidstr
     */
/*    protected void saveRoleUser(TSUser user, String roleidStr) {
		String[] roleids = roleidStr.split(",");
		List<TSRoleUser> rUserList = new ArrayList<TSRoleUser>();
		for (int i = 0; i < roleids.length; i++) {
			TSRoleUser rUser = new TSRoleUser();
			TSRole role = systemService.getEntity(TSRole.class, roleids[i]);
			rUser.setTSRole(role);
			rUser.setTSUser(user);
			rUserList.add(rUser);
		}
		if(rUserList != null && rUserList.size() > 0){
			systemService.batchSave(rUserList);
		}
	}*/
    protected void saveRoleUser(TSUser user, String roleidStr) {
        String[] roleids = roleidStr.split(",");
        for (int i = 0; i < roleids.length; i++) {
            TSRoleUser rUser = new TSRoleUser();
            TSRole role = systemService.getEntity(TSRole.class, roleids[i]);
            rUser.setTSRole(role);
            rUser.setTSUser(user);
            systemService.save(rUser);
        }
    }


    /**
     * 钉钉同步用户
     *
     * @author id 用户ID
     */
    @RequestMapping(params = "synchronization")
    @ResponseBody
    public AjaxJson synchronization(String id, HttpServletRequest req) {
        AjaxJson j = new AjaxJson();
        String message = null;
        TSUser user = systemService.getEntity(TSUser.class, id);

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

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

        userService.updateEntitie(user);
        j.setMsg(message);
        return j;
    }

    /**
     * 保存员工人事变动信息
     *
     * @param userId         用户ID
     * @param ifpayment      是否缴金人员
     * @param positionStatus 在职状态
     * @throws Exception
     */
    private void saveUserChangesLog(String userId, String ifpayment, String positionStatus) throws Exception {
        // 查询用户信息
        //TSBaseUser userInfo = userService.get(TSBaseUser.class, userId);
        TSBaseUser userInfo = userService.get(TSBaseUser.class, userId);
        // 查询主组织
        StringBuilder mainOrgSql = new StringBuilder();
        mainOrgSql.append(" SELECT ");
        mainOrgSql.append(" org_id orgId");
        mainOrgSql.append(" FROM t_s_user_org ");
        mainOrgSql.append(" WHERE ");
        mainOrgSql.append(" user_id = '" + userId + "'");
        mainOrgSql.append(" AND status = '0' ");
        mainOrgSql.append(" AND ifpluralism <> '1' ");
        List<Map<String, Object>> mainOrgMapList = systemService.findForJdbc(mainOrgSql.toString());
        String mainOrgId = "";
        if (mainOrgMapList.size() > 0) {
            mainOrgId = (String) mainOrgMapList.get(0).get("orgId");
        }

        // 缴金人员，入职，显示人员变动信息，缴金状态"待缴金"
        // 协议人员，入职，显示人员变动信息，缴金状态为空，状态栏为空
        // 缴金单位，关联到员工工资策略中的社保单位
        // 查询登录人名字
        String loginUserName = ResourceUtil.getSessionUser().getRealName();

        UserChangesLogEntity userChangesLogEntity = new UserChangesLogEntity();
        userChangesLogEntity.setChangeTime(new Date());
        userChangesLogEntity.setUserCode(userInfo.getUsername());
        userChangesLogEntity.setUserName(userInfo.getRealname());
        userChangesLogEntity.setBelongUnitid(mainOrgId);
        userChangesLogEntity.setInUnitid("");
        if (Globals.JOBSTATUS_1.equals(positionStatus)) {
            userChangesLogEntity.setChangeType(Globals.CHANGE_TYPE_RUZHI);
        }
        if (Globals.JOBSTATUS_2.equals(positionStatus)) {
            userChangesLogEntity.setChangeType(Globals.CHANGE_TYPE_ZHUANZHENG);
        }
        userChangesLogEntity.setApplicant(loginUserName);
        if (Globals.SHIFOU_01_1.equals(ifpayment)) {
            String payUnit = "";
            String userWagestrategyHql = "from UserWagestrategyEntity where userid = ?";
            List<UserWagestrategyEntity> UserWagestrategyEntityList = userWagestrategyService.findHql(userWagestrategyHql, userId);
            if (UserWagestrategyEntityList.size() > 0) {
                String socialSecurityStrategyid = UserWagestrategyEntityList.get(0).getSocialSecurityStrategyid();
                // 查询用户信息
                SocialSecurityStrategyEntity socialSecurityStrategyEntity = socialSecurityStrategyService.get(SocialSecurityStrategyEntity.class, socialSecurityStrategyid);
                if (null != socialSecurityStrategyEntity) {
                    payUnit = socialSecurityStrategyEntity.getSocialSecurityUnit();
                }
            }
            userChangesLogEntity.setPayUnit(payUnit);
            userChangesLogEntity.setPayRemindStatus(Globals.PAY_REMIND_STATUS_0);
        } else {
            userChangesLogEntity.setPayUnit("");
            userChangesLogEntity.setPayRemindStatus("");
        }
        userChangesLogService.save(userChangesLogEntity);
    }

    @RequestMapping(params = "export_leaveman_hr")
    public void export_leaveman_hr(PersonnelBaseArchivesManageInDto personnelBaseArchivesManageInDto, HttpServletRequest request, HttpServletResponse response
            , DataGrid dataGrid, ModelMap modelMap) {
        String codedFileName = "离职人员列表";
        String orgid = personnelBaseArchivesManageInDto.getOrgIds();
        if (orgid != null) {
            TSDepart depart = systemService.get(TSDepart.class, orgid);
            if (depart != null) {
                codedFileName = depart.getDepartname() + "员工";
            }
        }
        List<Map<String, Object>> modelMapList = null;
        try {
            modelMapList = personnelBaseArchivesManageExportAndImportService.exportXlsLeave(personnelBaseArchivesManageInDto);
        } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        Workbook workbook = personnelBaseArchivesManageExportAndImportService.getWorkBook(modelMapList);
        Sheet sh = workbook.getSheetAt(0);
        if (sh != null) {
            sh.createFreezePane(3, 0, 3, 0);
        }

        if (workbook instanceof HSSFWorkbook) {
            codedFileName += ".xls";
        } else {
            codedFileName += ".xlsx";
        }
        try {
            if (personnelBaseArchivesManageExportAndImportService.isIE(request)) {
                codedFileName = java.net.URLEncoder.encode(codedFileName, "UTF8");
            } else {
                codedFileName = new String(codedFileName.getBytes("UTF-8"), "ISO-8859-1");
            }
            response.setHeader("content-disposition", "attachment;filename=" + codedFileName);
            ServletOutputStream out = response.getOutputStream();
            workbook.write(out);
            out.flush();
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    //	@RequestMapping(params = "viewlist")
//	public ModelAndView viewlist(HttpServletRequest request) {
//		String queryParams = oConvertUtils.getString(request.getParameter("queryParams"));
//		if (oConvertUtils.isNotEmpty(queryParams)) {
//			JSONObject jsonObject =JSONObject.parseObject(queryParams);
//			request.setAttribute("queryParams",jsonObject);
//		}else {
//			JSONObject jsonObject = new JSONObject();
//			jsonObject.put("userName", "");
//			jsonObject.put("departname", "");
//			jsonObject.put("orgIds", "");
//			jsonObject.put("telphone", "");
//			jsonObject.put("idcard", "");
//			jsonObject.put("positionStatus", "");
//			jsonObject.put("certificateId", "");
//			request.setAttribute("queryParams",jsonObject);
//		}
//		return new ModelAndView("cn/com/lzt/personnelbasearchivesmanage/personnelBaseArchivesManageViewList");
//	}
    @SuppressWarnings({"unchecked", "rawtypes"})
    @RequestMapping(params = "searchUserCard", method = RequestMethod.POST)
    @ResponseBody
    public Object searchUserCard(String userid) {
        Map reJson = new HashMap<String, Object>();
        List<Map<String, Object>> resList = new ArrayList<Map<String, Object>>();
        String msg = "";
        if (StringUtils.isNotBlank(userid)) {
            try {
                String sql = "select su.idcard as idcard,bu.realname as realname,uf.belong_bank as bankname,uf.card_number as cardnumber from t_s_user su\n" +
                        "left join t_s_base_user bu on bu.id = su.id \n" +
                        "left join t_bus_user_financial uf on uf.userid = su.id and uf.delete_flag = '0' and uf.isdefault = '1'\n" +
                        "where su.id =? ";
                resList = systemService.findForJdbc(sql, userid);
                if (resList.size() == 0)
                    throw new BusinessException("查询不到员工");
                msg += "员工姓名：" + resList.get(0).get("realname") + "<br><br>";
                msg += "身份证号：" + resList.get(0).get("idcard") + "<br><br>";
                msg += "开户行名：" + resList.get(0).get("bankname") + "<br><br>";
                msg += "银行账号：" + resList.get(0).get("cardnumber");
            } catch (Exception e) {
                reJson.put("status", "fail");
                logger.info(e.getMessage());
                return reJson;
            }
            reJson.put("status", "success");
            reJson.put("msg", msg);
        } else {
            reJson.put("status", "success");
            reJson.put("msg", msg);
        }
        return reJson;
    }
}