fj-dc/.svn/pristine/1a/1a535125e23226bf9816c1426a536479ec0e69a3.svn-base

package cn.com.goldenwater.dcproj.service.impl.tac;

import cn.com.goldenwater.core.service.AbstractCrudService;
import cn.com.goldenwater.dcproj.constValue.AdCodeLabel;
import cn.com.goldenwater.dcproj.constValue.SmsCodeEnum;
import cn.com.goldenwater.dcproj.dao.BisInspAllRlationPersDao;
import cn.com.goldenwater.dcproj.dao.RoleDao;
import cn.com.goldenwater.dcproj.dao.TacInspPersAreaPrisDao;
import cn.com.goldenwater.dcproj.dao.TacInspYearBatchDao;
import cn.com.goldenwater.dcproj.dao.TacInspYearBatchGroupPersDao;
import cn.com.goldenwater.dcproj.dao.TacTacInspPersPrisLtsDao;
import cn.com.goldenwater.dcproj.dao.TacWorkerBDao;
import cn.com.goldenwater.dcproj.dao.TacWorkerTypeDao;
import cn.com.goldenwater.dcproj.dao.UserRoleDao;
import cn.com.goldenwater.dcproj.dto.TacCountDto;
import cn.com.goldenwater.dcproj.dto.TacWorkerBCountDto;
import cn.com.goldenwater.dcproj.dto.TacWorkerBDto;
import cn.com.goldenwater.dcproj.dto.TacWorkerPerDto;
import cn.com.goldenwater.dcproj.dto.TacWorkerbAuditDto;
import cn.com.goldenwater.dcproj.enums.SystemFlagEnum;
import cn.com.goldenwater.dcproj.model.BisInspAllRlationPers;
import cn.com.goldenwater.dcproj.model.BisInspPersOrg;
import cn.com.goldenwater.dcproj.model.GwComFile;
import cn.com.goldenwater.dcproj.model.OlBisInspOrg;
import cn.com.goldenwater.dcproj.model.Role;
import cn.com.goldenwater.dcproj.model.TacInspPersAreaPris;
import cn.com.goldenwater.dcproj.model.TacInspYearBatch;
import cn.com.goldenwater.dcproj.model.TacInspYearBatchArea;
import cn.com.goldenwater.dcproj.model.TacInspYearBatchGroup;
import cn.com.goldenwater.dcproj.model.TacInspYearBatchGroupPers;
import cn.com.goldenwater.dcproj.model.TacTacInspPersPrisLts;
import cn.com.goldenwater.dcproj.model.TacWorkerB;
import cn.com.goldenwater.dcproj.model.TacWorkerType;
import cn.com.goldenwater.dcproj.model.UserRole;
import cn.com.goldenwater.dcproj.param.BisInspAllRlationPersParam;
import cn.com.goldenwater.dcproj.param.GwComFileParam;
import cn.com.goldenwater.dcproj.param.RoleParam;
import cn.com.goldenwater.dcproj.param.TacInspYearBatchGroupParam;
import cn.com.goldenwater.dcproj.param.TacInspYearBatchGroupPersParam;
import cn.com.goldenwater.dcproj.param.TacTacInspPersPrisLtsParam;
import cn.com.goldenwater.dcproj.param.TacWorkerBParam;
import cn.com.goldenwater.dcproj.param.TacWorkerTypeParam;
import cn.com.goldenwater.dcproj.service.BisInspPersOrgService;
import cn.com.goldenwater.dcproj.service.GwComFileService;
import cn.com.goldenwater.dcproj.service.OlBisInspOrgService;
import cn.com.goldenwater.dcproj.service.TacInspYearBatchGroupService;
import cn.com.goldenwater.dcproj.service.TacWorkerBService;
import cn.com.goldenwater.dcproj.utils.BeanUtil;
import cn.com.goldenwater.dcproj.utils.HttpClientUtils;
import cn.com.goldenwater.dcproj.utils.InspUtils;
import cn.com.goldenwater.dcproj.utils.UserMsgSectrityUtils;
import cn.com.goldenwater.dcproj.utils.expExcel.ExportUtil;
import cn.com.goldenwater.dcproj.utils.impexcel.FileUtil;
import cn.com.goldenwater.id.util.UuidUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Base64;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.TreeMap;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;


/**
 * @author lune
 * @date 2019-9-6
 */
@Service
@Transactional
public class TacWorkerBServiceImpl extends AbstractCrudService<TacWorkerB, TacWorkerBParam> implements TacWorkerBService {

    @Autowired
    private TacWorkerBDao tacWorkerBDao;

    @Autowired
    private TacInspPersAreaPrisDao prisDao;

    @Autowired
    private TacTacInspPersPrisLtsDao ltsDao;

    @Autowired
    private BisInspAllRlationPersDao persDao;

    @Autowired
    private TacInspYearBatchGroupService groupService;

    @Autowired
    private TacInspYearBatchDao yearBatchDao;

    @Autowired
    private TacInspYearBatchGroupPersDao groupPersDao;
    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private TacWorkerTypeDao tacWorkerTypeDao;


    @Value("${export.templatePath}")
    private String templatePath;
    @Value("${impExcel.basePath}")
    private String impExcelPath;

    private static String apiKey = "1036432406699048960";

    private static String apiSecrect = "bbSsX1wvmaKdca5x2+yBDgeFtl9hj4zJmnegunWuLuHLwLo+QjxOr3//P4BJNrVADa7tN4w0DX1KS/VSec5G0x+ucDeAcSt9tWgFGyoBVtblybh+vzLbwH4sJa92hQfu\n";


    public TacWorkerBServiceImpl(TacWorkerBDao tacWorkerBDao) {
        super(tacWorkerBDao);
        this.tacWorkerBDao = tacWorkerBDao;
    }

    @Override
    public List<TacCountDto> countByAdCode(TacWorkerBParam tacWorkerBParam) {
        parseParam(tacWorkerBParam);
        return tacWorkerBDao.countByAdCode(tacWorkerBParam);
    }

    @Override
    public List<TacCountDto> countByTitles(TacWorkerBParam tacWorkerBParam) {
        parseParam(tacWorkerBParam);
        return tacWorkerBDao.countByTitles(tacWorkerBParam);
    }

    private void parseParam(TacWorkerBParam tacWorkerBParam) {
        //设置多重
        tacWorkerBParam.setGroupType(InspUtils.setOrgIds(tacWorkerBParam.getGroupType()));
        tacWorkerBParam.setRoleType(InspUtils.setOrgIds(tacWorkerBParam.getRoleType()));
        tacWorkerBParam.setWorkAd(InspUtils.setOrgIds(tacWorkerBParam.getWorkAd()));
        tacWorkerBParam.setOrgCode(InspUtils.setOrgIds(tacWorkerBParam.getOrgCode()));
        tacWorkerBParam.setEducation(InspUtils.setOrgIds(tacWorkerBParam.getEducation()));
        tacWorkerBParam.setTitles(InspUtils.setOrgIds(tacWorkerBParam.getTitles()));
        tacWorkerBParam.setUnitRanks(InspUtils.setOrgIds(tacWorkerBParam.getUnitRanks()));
        if (StringUtils.isNotBlank(tacWorkerBParam.getAgeLimits())) {
            String ageLimits = "";
            if (tacWorkerBParam.getAgeLimits().contains(",")) {
                ageLimits = "and (";
                StringBuilder age = new StringBuilder();
                for (String s : tacWorkerBParam.getAgeLimits().split(",")) {
                    if (s.contains("-")) {
                        age.insert(0, " or AGE Between " + s.split("-")[0] + " and " + s.split("-")[1]);
                    } else {
                        if (Integer.parseInt(s) > 50) {
                            age.insert(0, " or age >= " + s);
                        }
                        if (Integer.parseInt(s) < 50) {
                            age.insert(0, " or age <= " + s);
                        }
                    }
                }
                ageLimits = ageLimits + " " + age.toString().trim().substring(2) + " )";
            } else {
                if (tacWorkerBParam.getAgeLimits().contains("-")) {
                    ageLimits = "AND AGE Between " + tacWorkerBParam.getAgeLimits().split("-")[0] + " and " + tacWorkerBParam.getAgeLimits().split("-")[1];
                } else {
                    if (Integer.parseInt(tacWorkerBParam.getAgeLimits()) > 50) {
                        ageLimits = "AND age >=" + tacWorkerBParam.getAgeLimits();
                    } else {
                        ageLimits = "AND age <= " + tacWorkerBParam.getAgeLimits();
                    }
                }
            }
            tacWorkerBParam.setAgeLimits(ageLimits);
        }
        if (StringUtils.isNotBlank(tacWorkerBParam.getIsAll())) {
            String[] isAll = tacWorkerBParam.getIsAll().split("");
            StringBuilder isAllCon = new StringBuilder();
            for (String s : isAll) {
                if ("A".equalsIgnoreCase(s)) {
                    isAllCon.insert(0, " or IS_A ='1'");
                }
                if ("B".equalsIgnoreCase(s)) {
                    isAllCon.insert(0, " or IS_B ='1'");
                }
                if ("C".equalsIgnoreCase(s)) {
                    isAllCon.insert(0, " or IS_C ='1'");
                }
                if ("D".equalsIgnoreCase(s)) {
                    isAllCon.insert(0, " or IS_D = '1'");
                }
                if ("A".equalsIgnoreCase(s)) {
                    isAllCon.insert(0, " or IS_E = '1'");
                }
            }
            if (isAllCon.length() > 0) {
                isAllCon = new StringBuilder("and ( " + isAllCon.toString().trim().substring(2) + ")");
            }
            tacWorkerBParam.setIsAll(isAllCon.toString());
        }
    }

    @Override
    public List<TacCountDto> countByRole(TacWorkerBParam tacWorkerBParam) {
        parseParam(tacWorkerBParam);
        return tacWorkerBDao.countByRole(tacWorkerBParam);
    }

    @Override
    public List<TacCountDto> countByEdu(TacWorkerBParam tacWorkerBParam) {
        parseParam(tacWorkerBParam);
        return tacWorkerBDao.countByEdu(tacWorkerBParam);
    }

    @Override
    public List<TacCountDto> countByAge(TacWorkerBParam tacWorkerBParam) {
        parseParam(tacWorkerBParam);
        return tacWorkerBDao.countByAge(tacWorkerBParam);
    }

    @Override
    public List<TacCountDto> countByOffice(TacWorkerBParam tacWorkerBParam) {
        parseParam(tacWorkerBParam);
        return tacWorkerBDao.countByOffice(tacWorkerBParam);
    }

    @Override
    public List<TacWorkerB> getWorkerListById(TacWorkerBParam tacWorkerBParam) {//累加专家
        List<TacWorkerB> result = new ArrayList<>();
        //获取批次的专家人数以及规则
        TacInspPersAreaPris persAreaPris = prisDao.get(tacWorkerBParam.getPrisId());
        String isAll = "";
        String isNotAll = "";
        if ("1".equals(persAreaPris.getIsFit())) {
            if ("1".equals(persAreaPris.getIsA())) {
                isAll = "or is_A = '1'" + isAll;
            } else {
                isNotAll = "or is_A != '1'";
            }
            if ("1".equals(persAreaPris.getIsB())) {
                isAll = "or is_B = '1'" + isAll;
            } else {
                isNotAll = "or is_A != '1'";
            }
            if ("1".equals(persAreaPris.getIsC())) {
                isAll = "or is_C = '1'" + isAll;
            } else {
                isNotAll = "or is_C != '1'";
            }
            if ("1".equals(persAreaPris.getIsD())) {
                isAll = "or is_d = '1'" + isAll;
            } else {
                isNotAll = "or is_d != '1'";
            }
            if ("1".equals(persAreaPris.getIsE())) {
                isAll = "or is_e = '1'" + isAll;
            } else {
                isNotAll = "or is_e != '1'";
            }
            if (isAll.length() > 0) {//去除or
                isAll = isAll.substring(2);
            }
            if (isNotAll.length() > 0) {//去除or
                isNotAll = isNotAll.substring(2);
            }
        }
        tacWorkerBParam.setIsAll(isAll);
        if ("1".equals(persAreaPris.getIsCommon())) {//一般库
            result.addAll(getWorkerByGourpType(tacWorkerBParam, persAreaPris, "1"));
        }
        if ("1".equals(persAreaPris.getIsProbation())) {//见习专家库
            result.addAll(getWorkerByGourpType(tacWorkerBParam, persAreaPris, "7"));
        }
        //择优选择
        if ("1".equals(persAreaPris.getIsPick())) {
            result.addAll(getWorkerByGourpType(tacWorkerBParam, persAreaPris, "4"));
            result.addAll(getWorkerByGourpType(tacWorkerBParam, persAreaPris, "5"));
        }

        //拼接新人
        //新人注释掉了
        if ("1".equals(persAreaPris.getIsNew())) {
            tacWorkerBParam.setNewSize(persAreaPris.getNewSize());
            result.addAll(getNewWorker(tacWorkerBParam, persAreaPris, "8", result));
        }
        TacInspYearBatch batch = yearBatchDao.get(tacWorkerBParam.getYearBatchId());
//        TacInspYearBatchGroupParam batchGroupParam=new TacInspYearBatchGroupParam();
//        batchGroupParam.setYear(batch.getYear());
//        batchGroupParam.setBatch(batch.getBatch());
//        batchGroupParam.setYearBatchId(batch.getId());
//        TacInspYearBatchGroup yearBatchGroup=groupService.getBy(batchGroupParam);
        for (TacWorkerB workerB : result) {
            TacInspYearBatchGroupPers groupPers = new TacInspYearBatchGroupPers();
            groupPers.setId(UuidUtil.uuid());
            groupPers.setYear(batch.getYear());
            groupPers.setBatch(batch.getBatch());
            groupPers.setYearBatchId(batch.getId());
//            if(yearBatchGroup!=null) {
//                groupPers.setGroupId(yearBatchGroup.getId());
//            }
            groupPers.setRoleType(workerB.getRoleType());
            groupPers.setPersId(workerB.getId());
            groupPers.setCtPersId(tacWorkerBParam.getCurrPersId());
            groupPers.setInTm(new Date());
            groupPers.setUpTm(new Date());
            groupPers.setIsNotice("0");
            groupPers.setIsSms("0");
            groupPers.setIsJoin("0");
            groupPers.setDataStat("0");
            groupPersDao.insert(groupPers);
        }
        return result;
    }

    private List<TacWorkerB> getNewWorker(TacWorkerBParam tacWorkerBParam, TacInspPersAreaPris persAreaPris, String groupType, List<TacWorkerB> list) {
        List<TacWorkerB> result = new ArrayList<>();
        TacTacInspPersPrisLtsParam ltsParam = new TacTacInspPersPrisLtsParam();
        TacTacInspPersPrisLts lts = null;
        if (StringUtils.isBlank(tacWorkerBParam.getPrisId())) {
            lts = new TacTacInspPersPrisLts();
            setLtsContent(lts, persAreaPris, groupType);
        } else {
            ltsParam.setPersPrisId(tacWorkerBParam.getPrisId());
            ltsParam.setTenetType(groupType);
            lts = ltsDao.getBy(ltsParam);
        }
        if (lts.getTotalSize() == 0) {
            return result;
        }
        if (lts.getSpecialSize() > 0) {
            result.addAll(getResultList(lts.getSpecialSize(), "20", persAreaPris.getIsReason(), tacWorkerBParam, list));
        }
        if (lts.getAssistantSize() > 0) {
            result.addAll(getResultList(lts.getSpecialSize(), "19", persAreaPris.getIsReason(), tacWorkerBParam, list));
        }
        if (lts.getEarlyTisSize() > 0) {
            result.addAll(getResultList(lts.getSpecialSize(), "11", persAreaPris.getIsReason(), tacWorkerBParam, list));
        }
        if (lts.getDevemanageTisSize() > 0) {
            result.addAll(getResultList(lts.getSpecialSize(), "12", persAreaPris.getIsReason(), tacWorkerBParam, list));
        }
        if (lts.getPlanTisSize() > 0) {
            result.addAll(getResultList(lts.getSpecialSize(), "13", persAreaPris.getIsReason(), tacWorkerBParam, list));
        }
        if (lts.getFinanceTisSize() > 0) {
            result.addAll(getResultList(lts.getSpecialSize(), "14", persAreaPris.getIsReason(), tacWorkerBParam, list));
        }
        if (lts.getQualityTisSize() > 0) {
            result.addAll(getResultList(lts.getSpecialSize(), "15", persAreaPris.getIsReason(), tacWorkerBParam, list));
        }
        if (lts.getSafetyTisSize() > 0) {
            result.addAll(getResultList(lts.getSpecialSize(), "16", persAreaPris.getIsReason(), tacWorkerBParam, list));
        }
        return result;
    }

    /**
     * 按照专家规则分配人员
     * @param tacWorkerBParam
     * @param persAreaPris 批次的专家人数以及规则
     * @param groupType 所属人员库别字典
     * @return
     */
    private List<TacWorkerB> getWorkerByGourpType(TacWorkerBParam tacWorkerBParam, TacInspPersAreaPris persAreaPris, String groupType) {
        List<TacWorkerB> result = new ArrayList<>();
        tacWorkerBParam.setGroupType(groupType);
        TacTacInspPersPrisLtsParam ltsParam = new TacTacInspPersPrisLtsParam();
        TacTacInspPersPrisLts lts = null;
        if (StringUtils.isBlank(tacWorkerBParam.getPrisId())) {
            lts = new TacTacInspPersPrisLts();
            setLtsContent(lts, persAreaPris, groupType);
        } else {//设置专家规则
            ltsParam.setPersPrisId(tacWorkerBParam.getPrisId());
            ltsParam.setTenetType(groupType);
            lts = ltsDao.getBy(ltsParam);
        }
        if (lts == null) {//设置专家规则
            return result;
        }
        if (lts.getTotalSize() == null || lts.getTotalSize() == 0) {//人员总数
            return result;
        }
        if (lts.getSpecialSize() != null && lts.getSpecialSize() > 0) {//特派员人数
            result.addAll(getResultList(lts.getSpecialSize(), "20", persAreaPris.getIsReason(), tacWorkerBParam, null));
        }
        if (lts.getAssistantSize() != null && lts.getAssistantSize() > 0) {//助理人数
            result.addAll(getResultList(lts.getAssistantSize(), "19", persAreaPris.getIsReason(), tacWorkerBParam, null));
        }
        if (lts.getEarlyTisSize() != null && lts.getEarlyTisSize() > 0) {//前期专家人数
            result.addAll(getResultList(lts.getEarlyTisSize(), "11", persAreaPris.getIsReason(), tacWorkerBParam, null));
        }
        if (lts.getDevemanageTisSize() != null && lts.getDevemanageTisSize() > 0) {//建管专家人数
            result.addAll(getResultList(lts.getDevemanageTisSize(), "12", persAreaPris.getIsReason(), tacWorkerBParam, null));
        }
        if (lts.getPlanTisSize() != null && lts.getPlanTisSize() > 0) {//计划专家人数
            result.addAll(getResultList(lts.getPlanTisSize(), "13", persAreaPris.getIsReason(), tacWorkerBParam, null));
        }
        if (lts.getFinanceTisSize() != null && lts.getFinanceTisSize() > 0) {//财务专家人数
            result.addAll(getResultList(lts.getFinanceTisSize(), "14", persAreaPris.getIsReason(), tacWorkerBParam, null));
        }
        if (lts.getQualityTisSize() != null && lts.getQualityTisSize() > 0) {//质量专家人数
            result.addAll(getResultList(lts.getQualityTisSize(), "15", persAreaPris.getIsReason(), tacWorkerBParam, null));
        }
        if (lts.getSafetyTisSize() != null && lts.getSafetyTisSize() > 0) {//安全专家人数
            result.addAll(getResultList(lts.getSafetyTisSize(), "16", persAreaPris.getIsReason(), tacWorkerBParam, null));
        }
        return result;
    }

    /**
     *
     * @param lts
     * @param persAreaPris
     * @param groupType
     */
    private void setLtsContent(TacTacInspPersPrisLts lts, TacInspPersAreaPris persAreaPris, String groupType) {
        List<TacCountDto> list = new ArrayList<>();
        switch (groupType) {
            case "1":
                list.addAll(persAreaPris.getCommList());
                break;
            case "7":
                list.addAll(persAreaPris.getProList());
                break;
            case "4":
                list.addAll(persAreaPris.getGoldList());
                break;
            case "5":
                list.addAll(persAreaPris.getRedList());
                break;
            case "8":
                list.addAll(persAreaPris.getNewList());
                break;
        }
        if (list.size() > 0) {
            lts.setTenetType(groupType);
            list.forEach(tacCountDto -> {
                if (StringUtils.isNotBlank(tacCountDto.getSelectCount())) {
                    lts.setTotalSize((lts.getTotalSize() == null ? 0 : lts.getTotalSize()) + Long.valueOf(tacCountDto.getSelectCount()));
                    switch (tacCountDto.getCode()) {
                        case "20":
                            lts.setSpecialSize(Long.valueOf(tacCountDto.getSelectCount()));
                            break;
                        case "19":
                            lts.setAssistantSize(Long.valueOf(tacCountDto.getSelectCount()));
                            break;
                        case "11":
                            lts.setEarlyTisSize(Long.valueOf(tacCountDto.getSelectCount()));
                            break;
                        case "12":
                            lts.setDevemanageTisSize(Long.valueOf(tacCountDto.getSelectCount()));
                            break;
                        case "13":
                            lts.setPlanTisSize(Long.valueOf(tacCountDto.getSelectCount()));
                            break;
                        case "14":
                            lts.setFinanceTisSize(Long.valueOf(tacCountDto.getSelectCount()));
                            break;
                        case "15":
                            lts.setQualityTisSize(Long.valueOf(tacCountDto.getSelectCount()));
                            break;
                        case "16":
                            lts.setFinanceTisSize(Long.valueOf(tacCountDto.getSelectCount()));
                            break;
                    }
                }
            });
        }
    }

    /**
     * 把集合转换成角色 -> list 形式
     *
     * @param comList
     * @return
     */

    private Map<String, List<TacWorkerB>> converToMap(List<TacWorkerB> comList) {
        Map<String, List<TacWorkerB>> map = new HashMap<>();
        Collections.shuffle(comList);
        for (TacWorkerB tacWorkerB : comList) {
            if (StringUtils.isBlank(tacWorkerB.getRoleType())) {
                continue;
            }
            if (map.keySet().contains(tacWorkerB.getRoleType())) {
                if (map.get(tacWorkerB.getRoleType()) == null) {
                    List<TacWorkerB> list = new ArrayList<>();
                    list.add(tacWorkerB);
                    map.put(tacWorkerB.getRoleType(), list);
                } else {
                    map.get(tacWorkerB.getRoleType()).add(tacWorkerB);
                }
            } else {
                List<TacWorkerB> list = new ArrayList<>();
                list.add(tacWorkerB);
                map.put(tacWorkerB.getRoleType(), list);
            }
        }
        return map;
    }

    /**
     * 获取专家人员
     * @param size 获取对应专家人数
     * @param type 对应专家专业
     * @param isReason 是否理求合理分配
     * @return 专家人员列表
     */
    private List<TacWorkerB> getResultList(Long size, String type, String isReason, TacWorkerBParam tacWorkerBParam, List<TacWorkerB> list) {
        tacWorkerBParam.setRoleType(type);
        //排除匹配分组人员（过滤条件--筛选专业） 数据去重
        List<TacWorkerB> inList = this.tacWorkerBDao.getWorkerList(tacWorkerBParam);
        //排除匹配分组所有人员
        List<TacWorkerB> notInList = this.tacWorkerBDao.getIsNotFitWorkerList(tacWorkerBParam);
        if (list == null) {
            list = new ArrayList<>();
        }
        inList.removeAll(list);
        notInList.removeAll(list);
        if (size > (inList.size() + notInList.size())) {
            throw new NullPointerException("抽取失败:人员数量不够");
        }
        List<TacWorkerB> result = new ArrayList<>();
        if (size > inList.size()) {//规定专家人数大于排除匹配分组人员（过滤条件--筛选专业）
            int index = 0;
            for (TacWorkerB tacWorkerB : inList) {
                if (list.contains(tacWorkerB)) {
                    continue;
                }
                tacWorkerB.setRoleType(type);
                index++;
                result.add(tacWorkerB);
            }
            //加入相同的数据？inList  notInList 存在数据并集
            result.addAll(getReasonList(size - index, notInList, isReason, list, type));

        } else {
            //要求合理分配
            result.addAll(getReasonList(size, inList, isReason, list, type));
        }
        return result;
    }


    /**
     * 处理是否合理原则
     *
     * @param size
     * @param list
     * @param isReason
     * @return
     */
    private List<TacWorkerB> getReasonList(Long size, List<TacWorkerB> list, String isReason, List<TacWorkerB> bs, String type) {
        List<TacWorkerB> result = new ArrayList<>();
        Collections.shuffle(list);
        if ("1".equals(isReason)) {
            Map<Long, List<TacWorkerB>> map = new TreeMap<>();
            for (TacWorkerB tacWorkerB : list) {
                if (bs.contains(tacWorkerB)) {
                    continue;
                }
                tacWorkerB.setRoleType(type);
                if (map.containsKey(tacWorkerB.getCount())) {
                    if (map.get(tacWorkerB.getCount()) == null) {
                        List<TacWorkerB> tacWorkers = new ArrayList<>();
                        tacWorkers.add(tacWorkerB);
                        map.put(tacWorkerB.getCount(), tacWorkers);
                    } else {
                        map.get(tacWorkerB.getCount()).add(tacWorkerB);
                    }
                } else {
                    List<TacWorkerB> tacWorkers = new ArrayList<>();
                    tacWorkers.add(tacWorkerB);
                    map.put(tacWorkerB.getCount(), tacWorkers);
                }
            }
            Long resultSize = size;
            for (Long index : map.keySet()) {
                if (map.get(index).size() <= resultSize) {
                    result.addAll(map.get(index));
                    resultSize = resultSize - map.get(index).size();
                } else {
                    for (int i = 0; i < resultSize; i++) {
                        int a = Math.round(map.get(index).size());
                        TacWorkerB b = map.get(index).get(a == map.get(index).size() ? a - 1 : a);
                        b.setRoleType(type);
                        result.add(b);
                        map.get(index).remove(b);
                    }
                    break;
                }
            }
        } else {
            for (int i = 0; i < size; i++) {
                int index = Math.round(list.size());
                TacWorkerB b = list.get(index == list.size() ? index - 1 : index);
                if (bs.contains(b)) {
                    continue;
                }
                b.setRoleType(type);
                result.add(b);
                list.remove(b);
            }
        }
        return result;
    }

    @Override
    public PageInfo<TacWorkerB> getWorkerbsPage(TacWorkerBParam tacWorkerBParam) {
        PageHelper.startPage(tacWorkerBParam);
        List<TacWorkerB> list = this.tacWorkerBDao.getWorkerbsList(tacWorkerBParam);
        if (list.size() > 0) {
            for (TacWorkerB workerB : list) {
                TacWorkerTypeParam typeParam = new TacWorkerTypeParam();
                typeParam.setType("1");
                typeParam.setWorkerid(workerB.getId());
                workerB.setRoleTypeList(tacWorkerTypeDao.findList(typeParam));

                // 判断字段是否为 ‘null’，为null赋空值
                if (ifParamIsNull(workerB.getTelnumb())) {
                    workerB.setTelnumb("");
                }
                if (ifParamIsNull(workerB.getOrgNm())) {
                    workerB.setOrgNm("");
                }
                if (ifParamIsNull(workerB.getOe())) {
                    workerB.setOe("");
                }
                if (ifParamIsNull(workerB.getRecommendedUnits())) {
                    workerB.setRecommendedUnits("");
                }

            }
        }
        return new PageInfo<TacWorkerB>(list);
    }

    // 判断是否含有 null
    private boolean ifParamIsNull(String param) {
        return StringUtils.isNotBlank(param) && param.contains("null");
    }


    @Override
    public List<TacWorkerB> getWorkerbsList(TacWorkerBParam tacWorkerBParam) {
        List<TacWorkerB> list = this.tacWorkerBDao.getWorkerbsList(tacWorkerBParam);
        if ("1".equals(tacWorkerBParam.getIsExport())) {
            fieldFormat(list);
        }
        return list;
    }

    /**
     * 字段转换
     *
     * @param list
     */
    private void fieldFormat(List<TacWorkerB> list) {
        for (TacWorkerB workerB : list) {
            workerB.setGroupType(groupFormat(workerB.getGroupType()));
            workerB.setRoleType(roleFormat(workerB.getRoleType()));
            workerB.setEducation(educationFormat(workerB.getEducation()));
            workerB.setUnitRanks(unitRanksFormat(workerB.getUnitRanks()));
            workerB.setTitles(titlesFormat(workerB.getTitles()));
            workerB.setIsA(commonFormat(workerB.getIsA()));
            workerB.setIsB(commonFormat(workerB.getIsB()));
            workerB.setIsC(commonFormat(workerB.getIsC()));
            workerB.setIsD(commonFormat(workerB.getIsD()));
            workerB.setIsE(commonFormat(workerB.getIsE()));
            workerB.setIsNew(commonFormat(workerB.getIsNew()));
            workerB.setIsOffice(commonFormat(workerB.getIsOffice()));
            workerB.setIsTraining(commonFormat(workerB.getIsTraining()));
        }
    }

    private String titlesFormat(String key) {
        if ("1".equals(key)) {
            return "正高";
        }
        if ("2".equals(key)) {
            return "副高";
        }
        if ("3".equals(key)) {
            return "中级";
        }
        if ("4".equals(key)) {
            return "初级";
        }
        if ("正高".equals(key)) {
            return "1";
        }
        if ("副高".equals(key)) {
            return "2";
        }
        if ("中级".equals(key)) {
            return "3";
        }
        if ("初级".equals(key)) {
            return "4";
        }
        return "";
    }

    private String unitRanksFormat(String key) {
        if ("1".equals(key)) {
            return "省部级";
        }
        if ("2".equals(key)) {
            return "地市级";
        }
        if ("3".equals(key)) {
            return "县市级";
        }
        if ("省部级".equals(key)) {
            return "1";
        }
        if ("地市级".equals(key)) {
            return "2";
        }
        if ("县市级".equals(key)) {
            return "3";
        }
        return "";
    }

    private String educationFormat(String key) {
        if ("1".equals(key)) {
            return "专科及以下";
        }
        if ("2".equals(key)) {
            return "本科";
        }
        if ("3".equals(key)) {
            return "研究生";
        }
        if ("4".equals(key)) {
            return "博士";
        }
        if ("专科及以下".equals(key)) {
            return "1";
        }
        if ("本科".equals(key)) {
            return "2";
        }
        if ("研究生".equals(key)) {
            return "3";
        }
        if ("博士".equals(key)) {
            return "4";
        }
        return "";
    }

    private String groupFormat(String key) {
        if ("1".equals(key)) {
            return "一般库";
        }
        if ("2".equals(key)) {
            return "备用库";
        }
        if ("3".equals(key)) {
            return "退役库";
        }
        if ("4".equals(key)) {
            return "金名单";
        }
        if ("5".equals(key)) {
            return "红名单";
        }
        if ("6".equals(key)) {
            return "蓝名单";
        }
        if ("7".equals(key)) {
            return "见习专家库";
        }
        if ("一般库".equals(key)) {
            return "1";
        }
        if ("备用库".equals(key)) {
            return "2";
        }
        if ("退役库".equals(key)) {
            return "3";
        }
        if ("金名单".equals(key)) {
            return "4";
        }
        if ("红名单".equals(key)) {
            return "5";
        }
        if ("蓝名单".equals(key)) {
            return "6";
        }
        if ("见习专家库".equals(key)) {
            return "7";
        }
        return "";
    }

    /**
     * 角色转换，修改成逗号分隔形式
     *
     * @param key
     * @return
     */
    private String roleFormat(String key) {
        if (StringUtils.isBlank(key)) {
            return "";
        }
        String[] roleTypes = null;
        if (key.contains(",")) {
            roleTypes = key.split(",");
        } else {
            roleTypes = new String[]{key};
        }
        StringBuilder sb = new StringBuilder("");
        for (String roleType : roleTypes) {
            if ("20".equals(roleType)) {
                sb.append("特派员").append(",");
            }
            if ("19".equals(roleType)) {
                sb.append("助理").append(",");
            }
            if ("11".equals(roleType)) {
                sb.append("前期专家").append(",");
            }
            if ("12".equals(roleType)) {
                sb.append("建管专家").append(",");
            }
            if ("13".equals(roleType)) {
                sb.append("计划专家").append(",");
            }
            if ("14".equals(roleType)) {
                sb.append("财务专家").append(",");
            }
            if ("15".equals(roleType)) {
                sb.append("质量专家").append(",");
            }
            if ("16".equals(roleType)) {
                sb.append("安全专家").append(",");
            }
            if ("特派员".equals(roleType)) {
                sb.append("20").append(",");
            }
            if ("助理".equals(roleType)) {
                sb.append("19").append(",");
            }
            if ("前期专家".equals(roleType)) {
                sb.append("11").append(",");
            }
            if ("建管专家".equals(roleType)) {
                sb.append("12").append(",");
            }
            if ("计划专家".equals(roleType)) {
                sb.append("13").append(",");
            }
            if ("财务专家".equals(roleType)) {
                sb.append("14").append(",");
            }
            if ("质量专家".equals(roleType)) {
                sb.append("15").append(",");
            }
            if ("安全专家".equals(roleType)) {
                sb.append("16").append(",");
            }
        }
        return sb.length() > 0 ? sb.substring(0, sb.length() - 1) : "";
    }

    private String commonFormat(String key) {
        if ("1".equals(key)) {
            return "是";
        }
        if ("2".equals(key)) {
            return "否";
        }
        if ("是".equals(key)) {
            return "1";
        }
        if ("否".equals(key)) {
            return "2";
        }
        return "";
    }

    @Autowired
    private OlBisInspOrgService olBisInspOrgService;

    @Override
    public Map<String, Object> insertList(MultipartFile file, TacWorkerBParam tacWorkerBParam, String orgId) {
        Map<String, Object> map = new HashedMap();
        int success = 0;
        int fail = 0;
        String province = olBisInspOrgService.getRlProvince(orgId);
        List<Row> rowList = ExportUtil.getRowListByFile(file);
        List<TacWorkerB> list = new ArrayList<>();
        if (rowList.size() > 2) {
            Map<Integer, String> cols = new HashedMap();
            Row row = rowList.get(1);
            for (int j = row.getFirstCellNum(); j < row.getLastCellNum(); j++) {
                cols.put(j, String.valueOf(row.getCell(j)));
            }
            for (int i = 2; i < rowList.size(); i++) {
                row = rowList.get(i);
                TacWorkerB b = new TacWorkerB();
                for (int j = row.getFirstCellNum(); j < row.getLastCellNum(); j++) {
                    if (row.getCell(j) == null) {
                        continue;
                    }
                    if (row.getCell(j).getCellType() == CellType.NUMERIC) {
                        if (80000000.0 - row.getCell(j).getNumericCellValue() < 0) {
                            ExportUtil.setClassFiledValue(String.valueOf((long) row.getCell(j).getNumericCellValue()), cols.get(j), b, true);
                        } else {
                            ExportUtil.setClassFiledValue(String.valueOf(row.getCell(j)), cols.get(j), b, true);
                        }
                    } else {
                        ExportUtil.setClassFiledValue(String.valueOf(row.getCell(j)), cols.get(j), b, true);
                    }
                }
                b.setProvince(province);
                list.add(b);

            }
        }
        fieldFormat(list);
        for (TacWorkerB b : list) {
            if (StringUtils.isBlank(b.getMobilenumb())) {
                continue;
            }
            if(StringUtils.isNotBlank(b.getIdNo())){
               b.setIdNo(b.getIdNo().trim());
            }
            success++;
            TacWorkerBParam workerBParam = new TacWorkerBParam();
            workerBParam.setProvince(tacWorkerBParam.getProvince());
            workerBParam.setMobilenumb(b.getMobilenumb());
            workerBParam.setRoleType(b.getRoleType());
            b.setProvince(tacWorkerBParam.getProvince());
            TacWorkerB workerB = this.tacWorkerBDao.getBy(workerBParam);
            if (workerB == null) {
                //新增
                BisInspAllRlationPersParam param = new BisInspAllRlationPersParam();
                param.setMobilenumb(b.getMobilenumb());
                List<BisInspAllRlationPers> persList = persDao.findList(param);
                b.setId(UuidUtil.uuid());
                if (persList.size() == 0) {
                    BisInspAllRlationPers pers = new BisInspAllRlationPers();
                    BeanUtil.copyObject1(b, pers);
                    pers.setGuid(UuidUtil.uuid());
                    pers.setPwd("JinShui@433");
                    pers.setOwnerSystem(SystemFlagEnum.DC_ALL.getValue());
                    if (StringUtils.isNotBlank(pers.getSex())) {
                        pers.setSex("男".equals(pers.getSex()) ? "1" : "2");
                    }
                    OlBisInspOrg olBisInspOrg = olBisInspOrgService.get(orgId);
                    if (olBisInspOrg != null) {
                        pers.setOrgNm(olBisInspOrg.getOrgNm());
                    }
                    pers.setPersType("4");
                    pers.setOrgId(orgId);
                    pers.setPersName(b.getName());
                    addRole(orgId, pers, b);
                    persDao.insert(pers);
                    b.setLoginId(pers.getGuid());
                } else {
                    b.setLoginId(persList.get(0).getGuid());
                }
                if (StringUtils.isNotBlank(b.getRoleType())) {
                    String[] roleTypes = null;
                    if (b.getRoleType().contains(",")) {
                        roleTypes = b.getRoleType().split(",");
                    } else {
                        roleTypes = new String[]{b.getRoleType()};
                    }
                    for (String roleType : roleTypes) {
                        TacWorkerType tacWorkerType = new TacWorkerType();
                        tacWorkerType.setId(UuidUtil.uuid());
                        tacWorkerType.setType("1");
                        tacWorkerType.setWorkerid(b.getId());
                        tacWorkerType.setValue(roleType);
                        tacWorkerTypeDao.insert(tacWorkerType);
                    }
                }
                tacWorkerBDao.insert(b);
                continue;
            }
            List<String> cols = new ArrayList<>();
            cols.add("id");
            cols.add("loginId");
            cols.add("orgCode");
            cols.add("isNew");
            cols.add("persId");
            cols.add("upTm");
            cols.add("dataStat");
            cols.add("count");
            BeanUtil.copyObject(b, workerB, cols);
            TacWorkerTypeParam tacWorkerTypeParam = new TacWorkerTypeParam();
            tacWorkerTypeParam.setType("1");
            tacWorkerTypeParam.setWorkerid(workerB.getId());
            List<TacWorkerType> tacWorkerTypes = tacWorkerTypeDao.findList(tacWorkerTypeParam);
            if (StringUtils.isNotBlank(b.getRoleType())) {
                String[] roleTypes = null;
                if (workerB.getRoleType().contains(",")) {
                    roleTypes = workerB.getRoleType().split(",");
                } else {
                    roleTypes = new String[]{workerB.getRoleType()};
                }
                for (String roleType : roleTypes) {
                    if (isContain(tacWorkerTypes, roleType)) {
                        continue;
                    }
                    TacWorkerType tacWorkerType = new TacWorkerType();
                    tacWorkerType.setId(UuidUtil.uuid());
                    tacWorkerType.setType("1");
                    tacWorkerType.setWorkerid(workerB.getId());
                    tacWorkerType.setValue(roleType);
                    tacWorkerTypeDao.insert(tacWorkerType);
                }
            }
            if (tacWorkerTypes != null && tacWorkerTypes.size() > 0) {
                for (TacWorkerType tacWorkerType : tacWorkerTypes) {
                    tacWorkerTypeDao.delete(tacWorkerType.getId());
                }
            }
            BisInspAllRlationPersParam param = new BisInspAllRlationPersParam();
            param.setMobilenumb(b.getMobilenumb());
            List<BisInspAllRlationPers> persList = persDao.findList(param);
            if (persList.size() == 0) {
                BisInspAllRlationPers pers = new BisInspAllRlationPers();
                BeanUtil.copyObject1(b, pers);
                pers.setGuid(UuidUtil.uuid());
                pers.setPwd("JinShui@433");
                if (StringUtils.isNotBlank(pers.getSex())) {
                    pers.setSex("男".equals(pers.getSex()) ? "1" : "2");
                }
                OlBisInspOrg olBisInspOrg = olBisInspOrgService.get(orgId);
                if (olBisInspOrg != null) {
                    pers.setOrgNm(olBisInspOrg.getOrgNm());
                }
                pers.setPersType("4");
                pers.setOrgId(orgId);
                pers.setPersName(b.getName());
                addRole(orgId, pers, workerB);
                persDao.insert(pers);
                workerB.setLoginId(pers.getGuid());
            } else {
                workerB.setLoginId(persList.get(0).getGuid());
            }
            tacWorkerBDao.update(workerB);
        }
        map.put("success", success);
        map.put("fail", list.size() - success);
        return map;
    }

    private boolean isContain(List<TacWorkerType> tacWorkerTypes, String roleType) {
        Iterator<TacWorkerType> iterator = tacWorkerTypes.iterator();
        while (iterator.hasNext()) {
            TacWorkerType tacWorkerType = iterator.next();
            if (roleType.equals(tacWorkerType.getValue())) {
                tacWorkerTypes.remove(tacWorkerType);
                return true;
            }
        }
        return false;
    }

    private void addRole(String orgId, BisInspAllRlationPers pers, TacWorkerB workerB) {
        BisInspPersOrg inspPersOrg = new BisInspPersOrg();
        inspPersOrg.setOrgId(pers.getOrgId());
        inspPersOrg.setPersId(pers.getGuid());
        if (StringUtils.isNotBlank(pers.getPersType())) {
            inspPersOrg.setUserType(pers.getPersType());
        } else {
            inspPersOrg.setUserType(AdCodeLabel.GROUP_LEADER);
        }
        persOrgService.insert(inspPersOrg);
        if ("19".equals(workerB.getRoleType())) {
            pers.setPermission("1");
            RoleParam roleParam = new RoleParam();
            roleParam.setRoleName("稽察助理");
            roleParam.setOfcId(orgId);
            Role role = roleDao.getBy(roleParam);
            if (role != null) {
                UserRole userRole = new UserRole();
                userRole.setRoleId(role.getId());
                userRole.setUserId(pers.getGuid());
                userRoleDao.insert(userRole);
            }
        } else {
            pers.setPermission("0");
            RoleParam roleParam = new RoleParam();
            roleParam.setRoleName("稽察填报");
            roleParam.setOfcId(orgId);
            Role role = roleDao.getone(roleParam);
            if (role != null) {
                UserRole userRole = new UserRole();
                userRole.setRoleId(role.getId());
                userRole.setUserId(pers.getGuid());
                userRoleDao.insert(userRole);
            }
        }
    }

    @Override
    public int distributePers(TacWorkerBParam tacWorkerBParam) {
        TacInspPersAreaPris pris = prisDao.get(tacWorkerBParam.getPrisId());
        TacWorkerBParam workerBParam = new TacWorkerBParam();
        workerBParam.setProvince(tacWorkerBParam.getProvince());
        workerBParam.setYearBatchId(pris.getYearBatchId());
        if (pris.getYear() != null) {
            workerBParam.setYear(pris.getYear() - 1);
        }
        //人员列表
        List<TacWorkerB> list = this.tacWorkerBDao.getWorkerbsListByYear(workerBParam);
        //组列表
        TacInspYearBatchGroupParam groupParam = new TacInspYearBatchGroupParam();
        groupParam.setYearBatchId(pris.getYearBatchId());
        groupParam.setProvince(tacWorkerBParam.getProvince());
        //分组人员固定后，人员分配，人员刷新，人员单角色刷新无法改变当前组的人员（浙江需求）
        groupParam.setConfirmer("0");
        List<TacInspYearBatchGroup> groupList = groupService.getGroupList(groupParam);
        if ("1".equals(pris.getIsPorc())) {//是否合理搭配原则
            return dealPris(tacWorkerBParam.getRoleType(), list, groupList, pris, tacWorkerBParam);
        }
        //得到角色-> 人员列表
        Map<String, List<TacWorkerB>> disMap = converToMap(list);
        //一般分配
        for (TacInspYearBatchGroup tacInspYearBatchGroup : groupList) {
            if (tacInspYearBatchGroup.getWorkersList() != null && tacInspYearBatchGroup.getWorkersList().size() > 0) {
                //先删除以前关系
                TacInspYearBatchGroupPersParam persParam = new TacInspYearBatchGroupPersParam();
                persParam.setRoleType(tacWorkerBParam.getRoleType());
                persParam.setGroupId(tacInspYearBatchGroup.getId());
                groupPersDao.deleteGroupPersByGroupId(persParam);
            }
            if (StringUtils.isNotBlank(tacWorkerBParam.getRoleType())) {
                insertGroupPersList(disMap.get(tacWorkerBParam.getRoleType()), tacInspYearBatchGroup, tacWorkerBParam.getCurrPersId());
            } else {
                //分配特派员
                insertGroupPersList(disMap.get("20"), tacInspYearBatchGroup, tacWorkerBParam.getCurrPersId());
                //分配助理
                insertGroupPersList(disMap.get("19"), tacInspYearBatchGroup, tacWorkerBParam.getCurrPersId());
                //分配专家；11前期专家 12建管专家 13计划专家 14财务专家 15质量专家 16安全专家
                insertGroupPersList(disMap.get("11"), tacInspYearBatchGroup, tacWorkerBParam.getCurrPersId());
                insertGroupPersList(disMap.get("12"), tacInspYearBatchGroup, tacWorkerBParam.getCurrPersId());
                insertGroupPersList(disMap.get("13"), tacInspYearBatchGroup, tacWorkerBParam.getCurrPersId());
                insertGroupPersList(disMap.get("14"), tacInspYearBatchGroup, tacWorkerBParam.getCurrPersId());
                insertGroupPersList(disMap.get("15"), tacInspYearBatchGroup, tacWorkerBParam.getCurrPersId());
                insertGroupPersList(disMap.get("16"), tacInspYearBatchGroup, tacWorkerBParam.getCurrPersId());
            }
        }
        TacInspYearBatch batch = new TacInspYearBatch();
        batch.setId(pris.getYearBatchId());
        batch.setIsPersGroup("1");
        yearBatchDao.update(batch);
        return 1;
    }

    private int dealPris(String roleType, List<TacWorkerB> list, List<TacInspYearBatchGroup> groupList, TacInspPersAreaPris pris, TacWorkerBParam tacWorkerBParam) {
        List<TacWorkerB> allTacWorker = new ArrayList<>();
        //优生列表
        if (pris.getSiBadPersNum() != null && pris.getSiBadPersNum().intValue() > 0) {
            TacWorkerBParam bParam = new TacWorkerBParam();
            bParam.setYear(pris.getYear() - 1);
            bParam.setOrderBy("SYN_LOT");
            bParam.setProvince(tacWorkerBParam.getProvince());
            allTacWorker = tacWorkerBDao.getWorkerbsListByYear(bParam);
        }
        //差生列表
        if (pris.getSiGoodPersNum() != null && pris.getSiGoodPersNum().intValue() > 0) {
            if (allTacWorker == null) {
                TacWorkerBParam bParam = new TacWorkerBParam();
                bParam.setYear(pris.getYear() - 1);
//                bParam.setYearBatchId(pris.getYearBatchId());
                bParam.setOrderBy("SYN_LOT");
                bParam.setProvince(tacWorkerBParam.getProvince());
                allTacWorker = tacWorkerBDao.getWorkerbsListByYear(bParam);
            }
        }
        if (allTacWorker.size() > 0) {
            int badIndex = (int) (allTacWorker.size() * 0.2);
            int goodIndex = (int) (allTacWorker.size() * 0.8);
            for (TacWorkerB workerB : list) {
                if (allTacWorker.indexOf(workerB) < 0) {
                    workerB.setLevel("2");
                    continue;
                }
                if (allTacWorker.indexOf(workerB) < goodIndex) {
                    workerB.setLevel("1");
                    continue;
                }
                if (allTacWorker.indexOf(workerB) > badIndex) {
                    workerB.setLevel("3");
                    continue;
                }
                workerB.setLevel("2");
            }
        }
        //已选择的list
        List<TacWorkerB> fitList = new ArrayList<>(list);
        Map<String, List<TacWorkerB>> mapWork = new HashedMap();
        list.forEach(tacWorkerB -> {
            if (mapWork.keySet().contains(tacWorkerB.getWorkAd())) {
                mapWork.get(tacWorkerB.getWorkAd()).add(tacWorkerB);
            } else {
                List<TacWorkerB> bs = new ArrayList<>();
                bs.add(tacWorkerB);
                mapWork.put(tacWorkerB.getWorkAd(), bs);
            }
        });

        //处理年度
        List<TacWorkerB> persList = new ArrayList<>();
        if (pris.getAvoidYrSize() != null && pris.getAvoidYrSize().intValue() > 0) {
            //得到前几年度的人员列表
            Long styr = pris.getYear() - pris.getAvoidYrSize();
            TacWorkerBParam bParam = new TacWorkerBParam();
            bParam.setStyr(styr);
            bParam.setEnyr(pris.getYear());
            bParam.setProvince(tacWorkerBParam.getProvince());
            persList.addAll(tacWorkerBDao.getWorkerList(bParam));
        }
        fitList.removeAll(persList);
        //处理批次
        List<TacWorkerB> bList = new ArrayList<>();
        if (pris.getAvoidSize() != null && pris.getAvoidSize().intValue() > 0) {
            TacWorkerBParam bParam = new TacWorkerBParam();
            bParam.setProvince(tacWorkerBParam.getProvince());
            if (pris.getAvoidSize() > pris.getBatch()) {
                bParam.setStba(new Long(0));
            } else {
                bParam.setStba(pris.getBatch() - pris.getAvoidSize());
            }
            bParam.setEnba(pris.getBatch());
            bList.addAll(tacWorkerBDao.getWorkerList(bParam));
        }
        fitList.removeAll(bList);
        List<TacWorkerB> allList = new ArrayList<>(list);
        for (TacInspYearBatchGroup tacInspYearBatchGroup : groupList) {
            int sexNum = 0;
            if (pris.getSiNvPersNum() != null && pris.getSiNvPersNum() > 0) {
                sexNum = (int) (list.size() / groupList.size() * pris.getSiNvPersNum());
            }
            int saNum = 0;
            if (pris.getSiSaPersNum() != null && pris.getSiSaPersNum() > 0) {
                saNum = pris.getSiSaPersNum().intValue();
            }
            int siBad = 0;
            if (pris.getSiBadPersNum() != null && pris.getSiBadPersNum() > 0) {
                siBad = pris.getSiBadPersNum().intValue();
            }
            int siGood = 0;
            if (pris.getSiGoodPersNum() != null && pris.getSiGoodPersNum() > 0) {
                siGood = pris.getSiGoodPersNum().intValue();
            }
            //得到该组的所有符合原则的人员列表
            List<TacWorkerB> groupPersList = new ArrayList<>(fitList);
            List<TacWorkerB> notFitList = new ArrayList<>();
            //工作地回避
            if ("1".equals(pris.getIsArea())) {
                //得到区域列表
                List<TacInspYearBatchArea> areaList = tacInspYearBatchGroup.getAreaList();
                //得到工作地列表的人员列表
                areaList.forEach(tacInspYearBatchArea -> {
                    groupList.removeAll(mapWork.get(tacInspYearBatchArea.getAdCode()));
                });
            }
            if (groupPersList.size() < list.size()) {
                notFitList.addAll(list);
                notFitList.removeAll(groupPersList);
            }
            //开始分配
            if (tacInspYearBatchGroup.getWorkersList() != null && tacInspYearBatchGroup.getWorkersList().size() > 0) {
                //先删除以前关系
                TacInspYearBatchGroupPersParam persParam = new TacInspYearBatchGroupPersParam();
                persParam.setRoleType(roleType);
                if (StringUtils.isNotBlank(tacInspYearBatchGroup.getId())) {
                    persParam.setGroupId(tacInspYearBatchGroup.getId());
                    groupPersDao.deleteGroupPersByGroupId(persParam);
                }
            }

            int a = distributePersByPris(allList, fitList, groupPersList, notFitList, list, tacInspYearBatchGroup, pris, tacWorkerBParam.getCurrPersId(), groupList.size(), sexNum, saNum, siBad, siGood, tacWorkerBParam.getRoleType());
        }
        return 0;
    }

    /**
     * @param groupPersList
     * @param notFitList
     * @param tacInspYearBatchGroup
     * @param pris
     * @param currPersId
     * @param groupSize
     * @param sexNum
     * @param saNum
     * @param siBad
     * @return
     */
    private int distributePersByPris(List<TacWorkerB> allList, List<TacWorkerB> fitList, List<TacWorkerB> groupPersList, List<TacWorkerB> notFitList, List<TacWorkerB> list, TacInspYearBatchGroup tacInspYearBatchGroup, TacInspPersAreaPris pris, String currPersId, int groupSize, int sexNum, int saNum, int siBad, int siGood, String roleType) {
        List<TacWorkerB> selectList = new ArrayList<>();
        Map<String, List<TacWorkerB>> map = converToMap(groupPersList);
        Map<String, List<TacWorkerB>> notFitMap = converToMap(notFitList);
        Map<String, List<TacWorkerB>> allMap = converToMap(list);
        if (StringUtils.isNotBlank(roleType)) {
            insertGroupPersList(allList, fitList, map, notFitMap, allMap, roleType, tacInspYearBatchGroup, currPersId, pris, sexNum, saNum, siBad, siGood, groupSize, selectList);
        } else {
            //分配特派人
            insertGroupPersList(allList, fitList, map, notFitMap, allMap, "20", tacInspYearBatchGroup, currPersId, pris, sexNum, saNum, siBad, siGood, groupSize, selectList);
            //分配助理
            insertGroupPersList(allList, fitList, map, notFitMap, allMap, "19", tacInspYearBatchGroup, currPersId, pris, sexNum, saNum, siBad, siGood, groupSize, selectList);
            //分配专家
            insertGroupPersList(allList, fitList, map, notFitMap, allMap, "11", tacInspYearBatchGroup, currPersId, pris, sexNum, saNum, siBad, siGood, groupSize, selectList);
            insertGroupPersList(allList, fitList, map, notFitMap, allMap, "12", tacInspYearBatchGroup, currPersId, pris, sexNum, saNum, siBad, siGood, groupSize, selectList);
            insertGroupPersList(allList, fitList, map, notFitMap, allMap, "13", tacInspYearBatchGroup, currPersId, pris, sexNum, saNum, siBad, siGood, groupSize, selectList);
            insertGroupPersList(allList, fitList, map, notFitMap, allMap, "14", tacInspYearBatchGroup, currPersId, pris, sexNum, saNum, siBad, siGood, groupSize, selectList);
            insertGroupPersList(allList, fitList, map, notFitMap, allMap, "15", tacInspYearBatchGroup, currPersId, pris, sexNum, saNum, siBad, siGood, groupSize, selectList);
            insertGroupPersList(allList, fitList, map, notFitMap, allMap, "16", tacInspYearBatchGroup, currPersId, pris, sexNum, saNum, siBad, siGood, groupSize, selectList);
        }
        return 1;
    }

    private void insertGroupPersList(List<TacWorkerB> allList, List<TacWorkerB> fitList, Map<String, List<TacWorkerB>> map, Map<String, List<TacWorkerB>> notFitMap, Map<String, List<TacWorkerB>> allMap, String roleType, TacInspYearBatchGroup tacInspYearBatchGroup, String currPersId, TacInspPersAreaPris pris, int sexNum, int saNum, int siBad, int siGood, int groupSize, List<TacWorkerB> selectList) {
        insertGourpPers(allList, fitList, map.get(roleType), notFitMap.get(roleType), sexNum, saNum, siBad, siGood, tacInspYearBatchGroup, currPersId, selectList, pris);
    }


    private void insertGourpPers(List<TacWorkerB> allList, List<TacWorkerB> allFitList, List<TacWorkerB> fitList, List<TacWorkerB> notFitList, int sexNum, int saNum, int siBad, int siGood, TacInspYearBatchGroup tacInspYearBatchGroup, String currPersId, List<TacWorkerB> selectList, TacInspPersAreaPris pris) {
        TacWorkerB b = null;
        if (fitList == null || fitList.size() == 0) {
            if (notFitList == null || notFitList.size() == 0) {
                return;
            }
            int index = Math.round(notFitList.size());
            b = notFitList.get(index == notFitList.size() ? index - 1 : index);
            notFitList.remove(b);
            tacInspYearBatchGroup.setDataStat("1");
            tacInspYearBatchGroup.setPris("地域或年度批次回避失败");
            insertGroupPers(tacInspYearBatchGroup, b, currPersId);
            allList.remove(b);
            allFitList.remove(b);
            return;
        }
        int index = Math.round(fitList.size());
        b = fitList.get(index == fitList.size() ? index - 1 : index);
        //计算女性人数
        if ("女".equalsIgnoreCase(b.getSex())) {
            if (!calSexNum(sexNum, pris)) {
                b = isFitSexObj(b, tacInspYearBatchGroup, fitList);
            }
        }
        //计算同组专家人数
        if (pris.getSiSaPersNum() != null && !"1".equals(tacInspYearBatchGroup.getDataStat())) {
            b = calSiSaPersNum(b, fitList, saNum, sexNum, selectList, tacInspYearBatchGroup);
        }
        //计算最差人数
        if (pris.getSiSaPersNum() != null && !"1".equals(tacInspYearBatchGroup.getDataStat())) {
            b = calSiBadPersNum(b, fitList, siBad, siGood, saNum, sexNum, selectList, tacInspYearBatchGroup);
        }
        //计算最优人数
        if (pris.getSiSaPersNum() != null && !"1".equals(tacInspYearBatchGroup.getDataStat())) {
            b = calSiGoodPersNum(b, fitList, siGood, siBad, saNum, sexNum, selectList, tacInspYearBatchGroup);
        }
        selectList.add(b);
        fitList.remove(b);
        allList.remove(b);
        allFitList.remove(b);
        insertGroupPers(tacInspYearBatchGroup, b, currPersId);
    }

    private TacWorkerB calSiGoodPersNum(TacWorkerB b, List<TacWorkerB> fitList, int siGood, int siBad, int saNum, int sexNum, List<TacWorkerB> selectList, TacInspYearBatchGroup tacInspYearBatchGroup) {
        if (siGood > 0) {
            siGood--;
            return b;
        }
        Map<String, List<TacWorkerB>> map = new HashedMap();
        fitList.forEach(tacWorkerB -> {
            if (map.keySet().contains(tacWorkerB.getLevel())) {
                map.get(tacWorkerB.getLevel()).add(tacWorkerB);
            } else {
                List<TacWorkerB> list = new ArrayList<>();
                list.add(tacWorkerB);
                map.put(tacWorkerB.getLevel(), list);
            }
        });
        if (map.get("2") != null || map.get("2").size() > 0) {
            return calSiSaPersNum(b, map.get("2"), saNum, sexNum, selectList, tacInspYearBatchGroup);
        }
        if (map.get("3") != null || map.get("3").size() > 0) {
            if (siBad > 0) {
                siBad--;
                return calSiSaPersNum(b, map.get("3"), saNum, sexNum, selectList, tacInspYearBatchGroup);
            }
        }
        tacInspYearBatchGroup.setPris("不符合优等生原则");
        tacInspYearBatchGroup.setDataStat("1");
        return b;
    }

    private TacWorkerB calSiBadPersNum(TacWorkerB b, List<TacWorkerB> fitList, int siBad, int siGood, int saNum, int sexNum, List<TacWorkerB> selectList, TacInspYearBatchGroup tacInspYearBatchGroup) {
        if (siBad > 0) {
            siBad--;
            return b;
        }
        Map<String, List<TacWorkerB>> map = new HashedMap();
        fitList.forEach(tacWorkerB -> {
            if (map.keySet().contains(tacWorkerB.getLevel())) {
                map.get(tacWorkerB.getLevel()).add(tacWorkerB);
            } else {
                List<TacWorkerB> list = new ArrayList<>();
                list.add(tacWorkerB);
                map.put(tacWorkerB.getLevel(), list);
            }
        });
        if (map.get("2") != null || map.get("2").size() > 0) {
            return calSiSaPersNum(b, map.get("2"), saNum, sexNum, selectList, tacInspYearBatchGroup);
        }
        if (map.get("1") != null || map.get("1").size() > 0) {
            if (siGood > 0) {
                siGood--;
                return calSiSaPersNum(b, map.get("1"), saNum, sexNum, selectList, tacInspYearBatchGroup);
            }
        }
        tacInspYearBatchGroup.setPris("不符合差生原则");
        tacInspYearBatchGroup.setDataStat("1");
        return b;
    }


    private TacWorkerB calSiSaPersNum(TacWorkerB b, List<TacWorkerB> fitList, int saNum, int sexNum, List<TacWorkerB> selectList, TacInspYearBatchGroup tacInspYearBatchGroup) {
        if (saNum > 0) {
            saNum--;
            return b;
        }
        Map<String, List<TacWorkerB>> map = new HashedMap();
        selectList.forEach(tacWorkerB -> {
            if (map.keySet().contains(tacWorkerB.getWorkAd())) {
                map.get(tacWorkerB.getWorkAd()).add(tacWorkerB);
            } else {
                List<TacWorkerB> list = new ArrayList<>();
                list.add(tacWorkerB);
                map.put(tacWorkerB.getWorkAd(), list);
            }
        });
        List<TacWorkerB> tempList = new ArrayList(fitList);
        if (map.get(b.getWorkAd()) != null) {
            if (map.get(b.getWorkAd()).size() + 1 > saNum) {
                for (List<TacWorkerB> bs : map.values()) {
                    if (bs.size() >= saNum) {
                        tempList.removeAll(bs);
                    }
                }
                if (sexNum > 0) {
                    //抽取

                    int index = Math.round(tempList.size());
                    return tempList.get(index == tempList.size() ? index - 1 : index);
                }
                Map<String, List<TacWorkerB>> tempMap = new HashedMap();
                tempList.forEach(tacWorkerB -> {
                    if (tempMap.keySet().contains(tacWorkerB.getSex())) {
                        tempMap.get(tacWorkerB.getSex()).add(tacWorkerB);
                    } else {
                        List<TacWorkerB> list = new ArrayList<>();
                        list.add(tacWorkerB);
                        tempMap.put(tacWorkerB.getSex(), list);
                    }
                });
                if (tempMap.get("男") == null || tempMap.get("男").size() == 0) {
                    tacInspYearBatchGroup.setPris("同组专家工作地原则不符");
                    tacInspYearBatchGroup.setDataStat("1");
                    return b;
                }
            }
        }
        return b;
    }

    private TacWorkerB isFitSexObj(TacWorkerB b, TacInspYearBatchGroup tacInspYearBatchGroup, List<TacWorkerB> fitList) {
        Map<String, List<TacWorkerB>> map = new HashedMap();
        fitList.forEach(tacWorkerB -> {
            if (map.keySet().contains(tacWorkerB.getSex())) {
                map.get(tacWorkerB.getSex()).add(tacWorkerB);
            } else {
                List<TacWorkerB> list = new ArrayList<>();
                list.add(tacWorkerB);
                map.put(tacWorkerB.getSex(), list);
            }
        });
        if (map.get("男") == null || map.get("男").size() == 0) {
            tacInspYearBatchGroup.setPris("性别原则不符和");
            tacInspYearBatchGroup.setDataStat("1");
            return b;
        }
        int index = Math.round(map.get("男").size());
        return map.get("男").get(index == map.get("男").size() ? index - 1 : index);
    }

    private boolean calSexNum(int sexNum, TacInspPersAreaPris pris) {
        if (pris.getSiNvPersNum() == null) {
            return true;
        }
        if (pris.getSiNvPersNum() > 0) {
            if (sexNum > 0) {
                sexNum--;
                return true;
            }
            return false;
        }
        return true;
    }


    /**
     * @param tacInspYearBatchGroup 组对象
     * @param currPersId            当前用户id
     */
    private void insertGroupPersList(List<TacWorkerB> list, TacInspYearBatchGroup tacInspYearBatchGroup, String currPersId) {
//        for (int i = 0; i < map.get(roleType).size()/groupSize; i++) {
//            insertGourpPers(list,tacInspYearBatchGroup,currPersId);
//        }
//        if (map.get(roleType).size() % groupSize > 0) {
//            insertGourpPers(list,tacInspYearBatchGroup,currPersId);
//            map.get(roleType).remove(0);
//        }
        insertGourpPers(list, tacInspYearBatchGroup, currPersId);
    }

    private void insertGroupPers(TacInspYearBatchGroup group, TacWorkerB b, String currPersId) {
        TacInspYearBatchGroupPersParam persParam = new TacInspYearBatchGroupPersParam();
        persParam.setYearBatchId(group.getYearBatchId());
        persParam.setPersId(b.getId());
        List<TacInspYearBatchGroupPers> groupPersDaoList = groupPersDao.findList(persParam);
        if (groupPersDaoList != null) {
            TacInspYearBatchGroupPers groupPers = groupPersDaoList.get(0);
            groupPers.setGroupNm(group.getGroupNm());
            groupPers.setGroupId(group.getId());
            groupPers.setIsNotice("0");
            groupPers.setIsSms("0");
            groupPers.setIsJoin("0");
            groupPers.setSendsmsTm(null);
            groupPersDao.update(groupPers);
        } else {
            TacInspYearBatch batch = yearBatchDao.get(group.getYearBatchId());
            TacInspYearBatchGroupPers groupPers = new TacInspYearBatchGroupPers();
            groupPers.setId(UuidUtil.uuid());
            groupPers.setYear(batch.getYear());
            groupPers.setBatch(batch.getBatch());
            groupPers.setYearBatchId(batch.getId());
            groupPers.setRoleType(b.getRoleType());
            groupPers.setPersId(b.getId());
            groupPers.setCtPersId(currPersId);
            groupPers.setInTm(new Date());
            groupPers.setUpTm(new Date());
            groupPers.setIsNotice("0");
            groupPers.setIsSms("0");
            groupPers.setIsJoin("0");
            groupPers.setDataStat("0");
            groupPers.setGroupNm(group.getGroupNm());
            groupPers.setGroupId(group.getId());
            groupPersDao.insert(groupPers);
        }
        if (StringUtils.isNotBlank(group.getPris())) {
            this.groupService.update(group);
        }
    }

    private void insertGourpPers(List<TacWorkerB> list, TacInspYearBatchGroup tacInspYearBatchGroup, String currPersId) {
        if (list == null || list.size() == 0) {
            return;
        }
        int index = Math.round(list.size());
        TacWorkerB b = list.get(index == list.size() ? index - 1 : index);
        insertGroupPers(tacInspYearBatchGroup, b, currPersId);
        list.remove(b);
    }

    @Override
    public List<TacWorkerB> countPersBatch(TacWorkerBParam tacWorkerBParam) {
        return tacWorkerBDao.countPersBatch(tacWorkerBParam);
    }


    @Override
    public List<TacWorkerB> getWorkerbsListExpId(TacWorkerBParam tacWorkerBParam) {
        List<TacWorkerB> list = tacWorkerBDao.getWorkerbsListById(tacWorkerBParam);
        if (list.size() > 0) {
            for (TacWorkerB workerB : list) {
                TacInspYearBatchGroupPersParam groupPersParam = new TacInspYearBatchGroupPersParam();
                groupPersParam.setPersId(workerB.getId());
                groupPersParam.setYearBatchId(tacWorkerBParam.getYearBatchId());
                groupPersParam.setProvince(tacWorkerBParam.getProvince());
                List<TacInspYearBatchGroupPers> groupPersList = groupPersDao.findList(groupPersParam);
                List<TacWorkerType> roleTypeList = new ArrayList<>();
                for (TacInspYearBatchGroupPers groupPers : groupPersList) {
                    //去除重复的角色
                    if(cn.com.goldenwater.dcproj.utils.StringUtils.isEmpty(roleTypeList.stream().filter(f->groupPers.getRoleType().equals(f.getValue())).collect(Collectors.toList()) )){
                        TacWorkerType tacWorkerType = new TacWorkerType();
                        tacWorkerType.setValue(groupPers.getRoleType());
                        roleTypeList.add(tacWorkerType);
                    }
                }
                workerB.setRoleTypeList(roleTypeList);
            }
        }
        return list;
    }

    @Override
    public List<TacWorkerB> getWorkerList(TacWorkerBParam tacWorkerBParam) {
        List<TacWorkerB> list = tacWorkerBDao.getWorkerList(tacWorkerBParam);
        if (list.size() > 0) {
            for (TacWorkerB workerB : list) {
                TacWorkerTypeParam typeParam = new TacWorkerTypeParam();
                typeParam.setType("1");
                typeParam.setWorkerid(workerB.getId());
                workerB.setRoleTypeList(tacWorkerTypeDao.findList(typeParam));
            }
        }
        return list;
    }

    @Override
    public List<TacCountDto> countRoleNew(TacWorkerBParam tacWorkerBParam) {
        return tacWorkerBDao.countByRoleNew(tacWorkerBParam);
    }

    @Override
    public List<TacWorkerB> getWorkerListByPris(TacInspPersAreaPris persAreaPris) {
        List<TacWorkerB> result = new ArrayList<>();
        TacWorkerBParam tacWorkerBParam = new TacWorkerBParam();
        tacWorkerBParam.setYearBatchId(persAreaPris.getYearBatchId());
        String isAll = "";
        String isNotAll = "";
        if ("1".equals(persAreaPris.getIsFit())) {
            if ("1".endsWith(persAreaPris.getIsA())) {
                isAll = "or is_a = '1'" + isAll;
            } else {
                isNotAll = "or is_a != '1'";
            }
            if ("1".endsWith(persAreaPris.getIsB())) {
                isAll = "or is_B = '1'" + isAll;
            } else {
                isNotAll = "or is_B != '1'";
            }
            if ("1".endsWith(persAreaPris.getIsC())) {
                isAll = "or is_c = '1'" + isAll;
            } else {
                isNotAll = "or is_c != '1'";
            }
            if ("1".endsWith(persAreaPris.getIsD())) {
                isAll = "or is_d = '1'" + isAll;
            } else {
                isNotAll = "or is_d != '1'";
            }
            if ("1".endsWith(persAreaPris.getIsE())) {
                isAll = "or is_e = '1'" + isAll;
            } else {
                isNotAll = "or is_e != '1'";
            }
            if (isAll.length() > 0) {
                isAll = isAll.substring(2);
            }
            if (isNotAll.length() > 0) {
                isNotAll = isNotAll.substring(2);
            }
        }
        tacWorkerBParam.setIsAll(isAll);
        if ("1".equals(persAreaPris.getIsCommon())) {
            result.addAll(getWorkerByGourpType(tacWorkerBParam, persAreaPris, "1"));
        }
        if ("1".equals(persAreaPris.getIsProbation())) {
            result.addAll(getWorkerByGourpType(tacWorkerBParam, persAreaPris, "7"));
        }
        //择优选择
        if ("1".equals(persAreaPris.getIsPick())) {
            result.addAll(getWorkerByGourpType(tacWorkerBParam, persAreaPris, "4"));
            result.addAll(getWorkerByGourpType(tacWorkerBParam, persAreaPris, "5"));
        }
        //拼接新人
        if ("1".equals(persAreaPris.getIsNew())) {
            tacWorkerBParam.setNewSize(persAreaPris.getNewSize());
            getNewWorker(tacWorkerBParam, persAreaPris, "8", result);
        }
        for (TacWorkerB workerB : result) {
            TacInspYearBatch batch = yearBatchDao.get(tacWorkerBParam.getYearBatchId());
            TacInspYearBatchGroupPers groupPers = new TacInspYearBatchGroupPers();
            groupPers.setId(UuidUtil.uuid());
            groupPers.setYear(batch.getYear());
            groupPers.setBatch(batch.getBatch());
            groupPers.setYearBatchId(batch.getId());
            groupPers.setRoleType(workerB.getRoleType());
            groupPers.setPersId(workerB.getId());
            groupPers.setCtPersId(persAreaPris.getPersId());
            groupPers.setInTm(new Date());
            groupPers.setUpTm(new Date());
            groupPers.setIsNotice("0");
            groupPers.setIsSms("0");
            groupPers.setIsJoin("0");
            groupPers.setDataStat("0");
            groupPersDao.insert(groupPers);
        }
        return result;
    }

    @Override
    public List<TacWorkerB> insertTacWorkerB(TacWorkerBDto bDto) {
        if (bDto == null) {
            return null;
        }
        TacInspYearBatch batch = yearBatchDao.get(bDto.getYearBatchId());
        if (batch == null) {
            return null;
        }
        for (TacWorkerB workerB : bDto.getWorkerBList()) {

            if (workerB.getRoleTypeList() == null) {
                continue;
            }
            TacInspYearBatchGroupPers groupPers = new TacInspYearBatchGroupPers();

//            TacInspYearBatchGroupParam batchGroupParam=new TacInspYearBatchGroupParam();
//            batchGroupParam.setYear(batch.getYear());
//            batchGroupParam.setBatch(batch.getBatch());
//            batchGroupParam.setYearBatchId(batch.getId());
//            TacInspYearBatchGroup yearBatchGroup=groupService.getBy(batchGroupParam);
            groupPers.setYear(batch.getYear());
            groupPers.setBatch(batch.getBatch());
            groupPers.setYearBatchId(batch.getId());
            groupPers.setPersId(workerB.getId());
            groupPers.setCtPersId(bDto.getPersId());
            groupPers.setInTm(new Date());
//            if(yearBatchGroup!=null) {
//                groupPers.setGroupId(yearBatchGroup.getId());
//            }
            groupPers.setUpTm(new Date());
            groupPers.setIsNotice("0");
            groupPers.setIsSms("0");
            groupPers.setIsJoin("0");
            groupPers.setDataStat("0");
            for (TacWorkerType tacWorkerType : workerB.getRoleTypeList()) {
                groupPers.setId(UuidUtil.uuid());
                groupPers.setRoleType(tacWorkerType.getValue());
                groupPersDao.insert(groupPers);
            }
        }
        return bDto.getWorkerBList();
    }

    @Override
    public List<TacWorkerB> getNotDisPersList(TacWorkerBParam tacWorkerBParam) {
        List<TacWorkerB> list = null;
        if (tacWorkerBParam.getWorkerList() != null && tacWorkerBParam.getWorkerList().size() > 0) {
            list = tacWorkerBParam.getWorkerList();
        } else {
            TacWorkerBParam param = new TacWorkerBParam();
            param.setGroupId(tacWorkerBParam.getGroupId());
            param.setProvince(tacWorkerBParam.getProvince());
            param.setRoleType(tacWorkerBParam.getRoleType());
            list = tacWorkerBDao.getWorkerbsListById(param);
        }
        StringBuilder sb = new StringBuilder("");
        list.forEach(tacWorkerB -> {
            sb.append("'").append(tacWorkerB.getId()).append("'").append(",");
        });
        if (sb.length() > 1) {
            tacWorkerBParam.setWorkerIds(sb.substring(0, sb.length() - 1));
        }
        List<TacWorkerB> tacWorkerBS = tacWorkerBDao.getNotDisPersList(tacWorkerBParam);
        for (TacWorkerB tacWorkerB : tacWorkerBS) {
            if (tacWorkerB.getRoleTypeList() == null) {
                List<TacWorkerType> roleTypeList = new ArrayList<>();
                TacWorkerType tacWorkerType = new TacWorkerType();
                tacWorkerType.setValue(tacWorkerBParam.getRoleType());
                roleTypeList.add(tacWorkerType);
                tacWorkerB.setRoleTypeList(roleTypeList);
            }
        }
        return tacWorkerBS;
    }

    @Override
    public List<TacWorkerB> getObjTacWorkerbList(TacWorkerBParam tacWorkerBParam) {
        return tacWorkerBDao.getObjTacWorkerbList(tacWorkerBParam);
    }

    @Override
    public PageInfo<TacWorkerB> getObjTacWorkerbPage(TacWorkerBParam tacWorkerBParam) {
        PageHelper.startPage(tacWorkerBParam);
        List<TacWorkerB> list = tacWorkerBDao.getObjTacWorkerbList(tacWorkerBParam);
        PageInfo<TacWorkerB> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    @Override
    public PageInfo<TacWorkerB> getWorkerPage(TacWorkerBParam tacWorkerBParam) {
        PageHelper.startPage(tacWorkerBParam);
        List<TacWorkerB> list = tacWorkerBDao.getWorkerList(tacWorkerBParam);
        if (list.size() > 0) {
            for (TacWorkerB workerB : list) {
                TacWorkerTypeParam typeParam = new TacWorkerTypeParam();
                typeParam.setType("1");
                typeParam.setWorkerid(workerB.getId());
                workerB.setRoleTypeList(tacWorkerTypeDao.findList(typeParam));
            }
        }
        PageInfo<TacWorkerB> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    @Override
    public boolean updateWorkerbList(TacWorkerBDto dto) {
        if (dto == null) {
            return false;
        }
        if (dto.getWorkerBList() != null && dto.getWorkerBList().size() > 0) {
            dto.getWorkerBList().forEach(tacWorkerB -> {
                if (StringUtils.isNotBlank(dto.getGroupType())) {
                    tacWorkerB.setGroupType(dto.getGroupType());
                }
                if (StringUtils.isNotBlank(dto.getIsTraining())) {
                    tacWorkerB.setIsTraining(dto.getIsTraining());
                }
                tacWorkerBDao.update(tacWorkerB);
            });
        }
        return true;
    }

    @Override
    public PageInfo<TacWorkerbAuditDto> countWorkerAudit(TacWorkerBParam tacWorkerBParam) {
        PageHelper.startPage(tacWorkerBParam);
        parseParam(tacWorkerBParam);
        List<TacWorkerbAuditDto> list = tacWorkerBDao.countWorkerAudit(tacWorkerBParam);
        PageInfo pageInfo = new PageInfo(list);
        return pageInfo;
    }

    @Override
    public int downWorkerExcel(TacWorkerBDto dto, HttpServletResponse response) {
        List<TacWorkerB> list = new ArrayList<>();
        if (dto != null) {
            list = dto.getWorkerBList();
        }
        if (list != null && list.size() > 0) {
            fieldFormat(list);
            List<Map<String, Object>> map = listToMap(list);
            try {
                ExportUtil.download(response, map, templatePath + "/人员列表.xls");
            } catch (IOException e) {
                return 0;
            }
        } else {
            try {
                ExportUtil.download(response, new ArrayList<Map<String, Object>>(), templatePath + "/人员列表.xls");
            } catch (IOException e) {
                return 0;
            }
        }
        return 1;
    }

    private List<Map<String, Object>> listToMap(List<TacWorkerB> list) {
        List<Map<String, Object>> mapList = new ArrayList<>();
        if (list == null || list.size() == 0) {
            return mapList;
        }
        list.forEach(tacWorkerB -> {
            Map<String, Object> map = ExportUtil.objToMap(tacWorkerB, true);
            if (map != null) {
                mapList.add(map);
            }
        });
        return mapList;
    }

    @Override
    public Map<String, Object> uploadWorkerExcel(MultipartFile file, TacWorkerBParam tacWorkerBParam) {
        List<Row> rowList = ExportUtil.getRowListByFile(file);
        List<TacWorkerB> list = new ArrayList<>();
        if (rowList.size() > 2) {
            List<Map<String, Object>> mapList = ExportUtil.rowToMap(rowList, 1);
            if (mapList.size() > 0) {
                list = ExportUtil.mapToObj(mapList, TacWorkerB.class, true);
            }
        }

        if (list.size() > 0) {
            fieldFormat(list);
            list.forEach(tacWorkerB -> {
                if (StringUtils.isBlank(tacWorkerB.getId())) {
                    TacWorkerBParam param = new TacWorkerBParam();
                    param.setMobilenumb(tacWorkerB.getMobilenumb());
                    List<TacWorkerB> bs = tacWorkerBDao.findList(param);
                    if (bs.size() == 1) {
                        tacWorkerB.setId(bs.get(0).getId());
                        tacWorkerBDao.update(tacWorkerB);
                    } else if (bs.size() == 0) {
                        tacWorkerBDao.insert(tacWorkerB);
                    }
                } else {
                    tacWorkerBDao.update(tacWorkerB);
                }
            });
        }
        Map<String, Object> map = new HashedMap();
        map.put("success", String.valueOf(list.size()));
        map.put("fail", String.valueOf(rowList.size() - list.size() - 2));
        return map;
    }

    @Override
    public PageInfo<TacWorkerBCountDto> getWorkerNotJoinCount(TacWorkerBParam tacWorkerBParam) {
        parseParam(tacWorkerBParam);
        PageHelper.startPage(tacWorkerBParam);
        List<TacWorkerBCountDto> list = tacWorkerBDao.getWorkerNotJoinCountList(tacWorkerBParam);
        PageInfo<TacWorkerBCountDto> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    @Override
    public int downWorkerNotJoinExcel(TacWorkerBParam param, HttpServletResponse response) {
        parseParam(param);
        List<TacWorkerBCountDto> list = tacWorkerBDao.getWorkerNotJoinCountList(param);
        List<String> columns = new ArrayList<>();
        columns.add("id");
        ExportUtil.exportExcel(list, response, "未参加稽察人员列表", columns, TacWorkerBCountDto.class);
        return 0;
    }

    @Value("${api.url}")
    private String apiUrl;

    @Override
    public String sendMessage(TacWorkerBParam tacWorkerBParam) throws Exception {
        TacInspYearBatchGroupPersParam persParam = new TacInspYearBatchGroupPersParam();
        persParam.setYearBatchId(tacWorkerBParam.getYearBatchId());
        List<TacInspYearBatchGroupPers> list = groupPersDao.findList(persParam);
        if (list.size() > 0) {
            boolean flag = false;
            Base64.Encoder encoder = Base64.getEncoder();
            Map<String, String> params = new HashMap<String, String>();
            params.put("apiKey", apiKey);
            params.put("apiSecrect", apiSecrect);
            params.put("signName", "金水云平台");
            for (TacInspYearBatchGroupPers groupPers : list) {
                if ("1".equals(groupPers.getIsSms())) {
                    continue;
                }
                if (StringUtils.isBlank(groupPers.getPhone())) {
                    continue;
                }
                if (!flag) {
                    flag = true;
                }
                String message = groupPers.getPhone() + groupPers.getYearBatchId();
                String code = encoder.encodeToString(message.getBytes());
                params.put("mobile", groupPers.getPhone());
                HttpClientUtils.simplePostInvoke(apiUrl+"/gateway/api/sms/send", params);
                groupPers.setIsSms("1");
                groupPers.setIsNotice("1");
                groupPersDao.update(groupPers);
            }
            if (flag && tacWorkerBParam.getHour() != 0) {
                //创建定时任务
                Timer timer = new Timer("发送通知定时任务");
                TimerTask task = new TimerTask() {
                    @Override
                    public void run() {
                        if (StringUtils.isNotBlank(tacWorkerBParam.getYearBatchId())) {
                            List<TacInspYearBatchGroupPers> list = groupPersDao.findList(persParam);
                            if (list.size() > 0) {
                                list.forEach(groupPers -> {
                                    if ("1".equals(groupPers.getIsSms())) {
                                        if ("0".equals(groupPers.getIsJoin()) || StringUtils.isBlank(groupPers.getIsJoin())) {
                                            //回复超时
                                        } else if ("2".equals(groupPers.getIsJoin())) {
                                            //确认不参加
                                        }
                                    }
                                });
                            }
                        }
                    }
                };
                LocalDateTime dt = LocalDateTime.now();
                dt.minusHours(tacWorkerBParam.getHour());
                ZoneId zone = ZoneId.systemDefault();
                String time = dt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                redisTemplate.opsForValue().set(tacWorkerBParam.getYearBatchId(), time, tacWorkerBParam.getHour(), TimeUnit.HOURS);

                Instant instant = dt.atZone(zone).toInstant();
                Date date = Date.from(instant);

                timer.schedule(task, date);
            }
        }
        return SmsCodeEnum.SUCCESS.getKey();
    }

    @Autowired
    private GwComFileService gwComFileService;

    @Value("${getFile.prefix}")
    public String prefix;
    @Value("${web.upload-path}")
    public String fileDir;

    @Override
    public int uploadBio(MultipartFile file, TacWorkerBParam tacWorkerBParam) throws Exception {
        List<GwComFile> list = FileUtil.getFileList(file, prefix, fileDir);
        if (list != null && list.size() > 0) {
            list.forEach(gwComFile -> {
                String persNameAndIdNum = gwComFile.getFileName();
                String persName = persNameAndIdNum.split("-")[0];
                String idNum = persNameAndIdNum.split("-")[1].substring(0, persNameAndIdNum.split("-")[1].indexOf("."));
                TacWorkerBParam param = new TacWorkerBParam();
                param.setIdNo(idNum);
                param.setName(persName);
                param.setProvince(tacWorkerBParam.getProvince());
                TacWorkerB b = tacWorkerBDao.getBy(param);
                if (b != null) {
                    List<GwComFile> gwComFiles = gwComFileService.findFileByBiz(b.getId());
                    if (gwComFiles.size() > 0) {
                        //删除关联简历
                        GwComFileParam gwComFileParam = new GwComFileParam();
                        gwComFileParam.setBizId(b.getId());
                    }
                    gwComFile.setBizId(b.getId());
                }
            });
        }
        return 0;
    }

    @Override
    public List<TacWorkerB> findPerInZLOrTPY(String currentPersId) {
        return tacWorkerBDao.findPerInZLOrTPY(currentPersId);
    }

    @Autowired
    private BisInspPersOrgService persOrgService;
    @Autowired
    private RoleDao roleDao;
    @Autowired
    private UserRoleDao userRoleDao;

    @Override
    public int makeData(String orgId) {
        String province = olBisInspOrgService.getRlProvince(orgId);
        List<TacWorkerB> workerBList = tacWorkerBDao.findBlankList(province);
        for (TacWorkerB workerB : workerBList) {
            BisInspAllRlationPersParam rlationPersParam = new BisInspAllRlationPersParam();
            rlationPersParam.setMobilenumb(workerB.getMobilenumb());
            BisInspAllRlationPers allRlationPers = persDao.getBy(rlationPersParam);
            if (allRlationPers == null) {
                allRlationPers = new BisInspAllRlationPers();
                allRlationPers.setGuid(UuidUtil.uuid());
                allRlationPers.setPersType("4");
                allRlationPers.setAdmDuty(workerB.getDuty());
                allRlationPers.setEmail(workerB.getEmail());
                allRlationPers.setBornDate(workerB.getBirthdate());
                allRlationPers.setMobilenumb(workerB.getMobilenumb());
                OlBisInspOrg olBisInspOrg = olBisInspOrgService.get(orgId);
                if (olBisInspOrg != null) {
                    allRlationPers.setOrgNm(olBisInspOrg.getOrgNm());
                }
                allRlationPers.setPermission("0");
                allRlationPers.setPwd("JinShui@433");
                allRlationPers.setOrgId(orgId);
                allRlationPers.setOwnerSystem("DC_ALL");
                allRlationPers.setPersName(workerB.getName());
                BisInspPersOrg inspPersOrg = new BisInspPersOrg();
                inspPersOrg.setOrgId(allRlationPers.getOrgId());
                inspPersOrg.setPersId(allRlationPers.getGuid());
                if (StringUtils.isNotBlank(allRlationPers.getPersType())) {
                    inspPersOrg.setUserType(allRlationPers.getPersType());
                } else {
                    inspPersOrg.setUserType(AdCodeLabel.GROUP_LEADER);
                }
                addRole(orgId, allRlationPers, workerB);
                allRlationPers.setCollTime(new Date());
                persOrgService.insert(inspPersOrg);
                persDao.insert(allRlationPers);

            }
            workerB.setLoginId(allRlationPers.getGuid());
            tacWorkerBDao.update(workerB);
        }

        return 0;
    }

    @Override
    public int insertIntoData(TacWorkerType workerType) {
        TacWorkerBParam param = new TacWorkerBParam();
        List<TacWorkerB> list = tacWorkerBDao.findList(param);
        for (TacWorkerB workerB : list) {
            if (StringUtils.isBlank(workerType.getType())) {
                continue;
            }
            if ("1".equals(workerType.getType())) {
                if (StringUtils.isBlank(workerB.getRoleType())) {
                    continue;
                }
                TacWorkerType wt = new TacWorkerType();
                String[] roltypes = null;
                if (workerB.getRoleType().contains(",")) {
                    roltypes = workerB.getRoleType().split(",");
                } else {
                    roltypes = new String[]{workerB.getRoleType()};
                }
                for (String roltype : roltypes) {
                    wt.setId(UuidUtil.uuid());
                    wt.setWorkerid(workerB.getId());
                    wt.setType(workerType.getType());
                    wt.setValue(roltype);
                    tacWorkerTypeDao.insert(wt);
                }
            }
        }
        return 0;
    }

    @Override
    public PageInfo<TacWorkerPerDto> listByList(Map<String, String> paramMap) {
        PageHelper.startPage(MapUtils.getIntValue(paramMap, "pageNum"), MapUtils.getIntValue(paramMap, "pageSize"));

        String province = olBisInspOrgService.getRlProvince(paramMap.get("orgId"));
        paramMap.put("province",province);
        List<TacWorkerPerDto> persList = tacWorkerBDao.listByMap(paramMap);
        for (TacWorkerPerDto tacWorkerPerDto : persList) {

            //手机号脱敏处理
            tacWorkerPerDto.setMobilenumb(UserMsgSectrityUtils.blurPhoneNotExc(tacWorkerPerDto.getMobilenumb()));
        }



        return new PageInfo<>(persList);
    }

    @Override
    public List<TacWorkerB> findListExist(TacWorkerB param) {
        return tacWorkerBDao.findListExist(param);
    }
}