weaver-hrm-salary/src/com/engine/salary/service/impl/SIArchivesServiceImpl.java

package com.engine.salary.service.impl;

import com.cloudstore.eccom.pc.table.WeaTableColumn;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.biz.SIArchivesBiz;
import com.engine.salary.cmd.siarchives.SIArchivesTipsCmd;
import com.engine.salary.entity.siarchives.bo.InsuranceArchivesBaseInfoBO;
import com.engine.salary.entity.siarchives.param.InsuranceArchivesListParam;
import com.engine.salary.entity.siarchives.param.InsuranceArchivesSaveParam;
import com.engine.salary.entity.siarchives.po.*;
import com.engine.salary.entity.taxagent.dto.TaxAgentEmployeeDTO;
import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeEmployeeDTO;
import com.engine.salary.entity.taxagent.po.TaxAgentEmpChangePO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.siaccount.EmployeeStatusEnum;
import com.engine.salary.enums.sicategory.DeleteTypeEnum;
import com.engine.salary.enums.sicategory.NonPaymentEnum;
import com.engine.salary.enums.sicategory.WelfareTypeEnum;
import com.engine.salary.enums.taxagent.TaxAgentEmpChangeModuleEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.siarchives.FundSchemeMapper;
import com.engine.salary.mapper.siarchives.InsuranceBaseInfoMapper;
import com.engine.salary.mapper.siarchives.OtherSchemeMapper;
import com.engine.salary.mapper.siarchives.SocialSchemeMapper;
import com.engine.salary.service.SIArchivesService;
import com.engine.salary.service.TaxAgentEmpChangeService;
import com.engine.salary.service.TaxAgentService;
import com.engine.salary.sys.entity.vo.OrderRuleVO;
import com.engine.salary.sys.service.SalarySysConfService;
import com.engine.salary.sys.service.impl.SalarySysConfServiceImpl;
import com.engine.salary.util.SalaryEntityUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.db.MapperProxyFactory;
import com.engine.salary.util.excel.ExcelUtil;
import com.google.common.collect.Lists;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.transaction.annotation.Transactional;
import weaver.general.Util;
import weaver.hrm.User;

import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author weaver_cl
 * @Description:
 * @Date 2022/3/11
 * @Version V1.0
 **/
public class SIArchivesServiceImpl extends Service implements SIArchivesService {

    private SIArchivesBiz siArchivesBiz = new SIArchivesBiz();

    private TaxAgentService getTaxAgentService(User user) {
        return ServiceUtil.getService(TaxAgentServiceImpl.class, user);
    }

    private SalarySysConfService getSalarySysConfService(User user) {
        return ServiceUtil.getService(SalarySysConfServiceImpl.class, user);
    }

    private InsuranceBaseInfoMapper getInsuranceBaseInfoMapper() {
        return MapperProxyFactory.getProxy(InsuranceBaseInfoMapper.class);
    }

    private TaxAgentEmpChangeService getTaxAgentEmpChangeService(User user) {
        return ServiceUtil.getService(TaxAgentEmpChangeServiceImpl.class, user);
    }

    private SocialSchemeMapper getSocialSchemeMapper() {
        return MapperProxyFactory.getProxy(SocialSchemeMapper.class);
    }

    private FundSchemeMapper getFundSchemeMapper() {
        return MapperProxyFactory.getProxy(FundSchemeMapper.class);
    }

    private OtherSchemeMapper getOtherSchemeMapper() {
        return MapperProxyFactory.getProxy(OtherSchemeMapper.class);
    }

    @Override
    public Map<String, Object> getTips(Map<String, Object> params) {
        return commandExecutor.execute(new SIArchivesTipsCmd(params, user));
    }

    @Override
    public Map<String, Object> getBaseForm(Map<String, Object> params) {
        long currentEmployeeId = user.getUID();
        Boolean needAuth = getTaxAgentService(user).isNeedAuth(currentEmployeeId);
        Collection<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listAllTaxAgentsAsAdmin(currentEmployeeId);

        Map<String, Object> apidatas = new HashMap<>(16);
        SIArchivesBiz siArchivesBiz = new SIArchivesBiz();
        siArchivesBiz.setNeedAuth(needAuth);
        siArchivesBiz.setTaxAgentPOS(taxAgentPOS);
        WelfareTypeEnum welfareTypeEnum = (WelfareTypeEnum) params.get("welfareTypeEnum");
        Long employeeId = Long.valueOf(Util.null2String(params.get("employeeId")));
        apidatas = siArchivesBiz.getBaseForm(welfareTypeEnum, employeeId, (long) user.getUID(), user);
        return apidatas;
    }

    @Override
    public Map<String, Object> getPaymentForm(Map<String, Object> params) {
        Map<String, Object> apidatas = new HashMap<>(16);
        SIArchivesBiz siArchivesBiz = new SIArchivesBiz();
        WelfareTypeEnum welfareTypeEnum = (WelfareTypeEnum) params.get("welfareTypeEnum");
        Long employeeId = Long.valueOf(Util.null2String(params.get("employeeId")));
        String schemeIdStr = Util.null2String(params.get("schemeId"));
        Long schemeId = null;
        if (StringUtils.isNotBlank(schemeIdStr)) {
            schemeId = Long.valueOf(schemeIdStr);
        }

        apidatas = siArchivesBiz.getPaymentForm(user, welfareTypeEnum, employeeId, (long) user.getUID(), schemeId);
        return apidatas;
    }


    @Override
    public String insert(InsuranceArchivesSaveParam param) {
        SIArchivesBiz siArchivesBiz = new SIArchivesBiz();
        siArchivesBiz.insert(param, (long) user.getUID());
        return null;
    }

    @Override
    public Map<String, Object> listPage(InsuranceArchivesListParam param) {
        long currentEmployeeId = user.getUID();

        // 2.待减员自动处理
        handleStayDelData(currentEmployeeId);
        // 3.增量数据处理
        handleChangeData(currentEmployeeId);

        //排序配置
        OrderRuleVO orderRule = getSalarySysConfService(user).orderRule();
        param.setOrderRule(orderRule);

        Boolean needAuth = getTaxAgentService(user).isNeedAuth(currentEmployeeId);
        param.setNeedAuth(needAuth);
        if (needAuth) {
            List<TaxAgentEmployeeDTO> taxAgentEmployeeDTOS = getTaxAgentService(user).listTaxAgentAndEmployee(currentEmployeeId);
            Set<Long> employeeIds = SalaryEntityUtil.properties(taxAgentEmployeeDTOS, TaxAgentEmployeeDTO::getEmployeeId);
            Set<Long> taxAgentIds = SalaryEntityUtil.properties(taxAgentEmployeeDTOS, TaxAgentEmployeeDTO::getTaxAgentId);
            param.setTaxAgentEmployeeIds(employeeIds);
            param.setTaxAgentIds(taxAgentIds);
        }

        Map<String, Object> apidatas = new HashMap<>(16);
        SIArchivesBiz siArchivesBiz = new SIArchivesBiz();
        apidatas = siArchivesBiz.listPage(param, (long) user.getUID());

        return apidatas;
    }

    /**
     * 福利档案中待减员数据自动处理
     * @param currentEmployeeId
     */
    @Transactional(rollbackFor = Exception.class)
    private void handleStayDelData(long currentEmployeeId) {

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM");
        String today = simpleDateFormat.format(new Date());
        //part1，员工维护了社保/公积金/其他福利最后缴纳日,且任一类信息大于今天的，自动将待减员状态置为正在缴纳状态
        List<InsuranceArchivesBaseInfoPO> rePayList = getInsuranceBaseInfoMapper().getRePayList(today);
        updateInsuranceBaseInfoRunStatus(rePayList, EmployeeStatusEnum.PAYING.getValue());
        //part2，员工维护了社保/公积金/其他福利最后缴纳日,且三类信息都小于今天的，自动置为待减员状态
        List<InsuranceArchivesBaseInfoPO> reStayDelList = getInsuranceBaseInfoMapper().getReStayDelList(today);
        updateInsuranceBaseInfoRunStatus(reStayDelList, EmployeeStatusEnum.STAY_DEL.getValue());

        //part3，非在职员工且处于正常缴纳的福利档案置为待减员状态
        //定义非在职的人事状态
        List<String> personnelStatuses = new ArrayList<String>() {{
            add("5");
            add("6");
            add("7");
        }};

        if (CollectionUtils.isNotEmpty(personnelStatuses)) {
            //获取非在职员工的福利档案基础信息
            InsuranceArchivesListParam insuranceArchivesListParam = new InsuranceArchivesListParam();
            insuranceArchivesListParam.setPersonnelStatuses(personnelStatuses);
            insuranceArchivesListParam.setRunStatuses(Collections.singletonList(EmployeeStatusEnum.PAYING.getValue()));

            List<InsuranceArchivesBaseInfoPO> noNormalList = getInsuranceBaseInfoMapper().getAbnormalList(insuranceArchivesListParam);
            updateInsuranceBaseInfoRunStatus(noNormalList, EmployeeStatusEnum.STAY_DEL.getValue());

        }
    }

    /**
     * 福利档案中增量数据处理
     * @param currentEmployeeId
     */
    @Transactional(rollbackFor = Exception.class)
    private void handleChangeData(long currentEmployeeId) {

        // 所有增量人员列表
        List<TaxAgentEmpChangePO> taxAgentEmpChangeList = getTaxAgentEmpChangeService(user).listAllByModule(TaxAgentEmpChangeModuleEnum.INSURANCE_ARCHIVE);
        if (CollectionUtils.isEmpty(taxAgentEmpChangeList)) {
            return;
        }
        // 当前可以管辖的人员
        Collection<TaxAgentPO> taxAgentList = getTaxAgentService(user).listAllTaxAgents(currentEmployeeId);
        taxAgentEmpChangeList = taxAgentEmpChangeList.stream().filter(f -> taxAgentList.stream().anyMatch(e -> e.getId().equals(f.getTaxAgentId()))).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(taxAgentEmpChangeList)) {
            return;
        }
        // 所有福利档案基础信息数据
        List<InsuranceArchivesBaseInfoPO> baseInfoPOList = getInsuranceBaseInfoMapper().listAll();

        InsuranceArchivesBaseInfoBO.ChangeData changeData = InsuranceArchivesBaseInfoBO.buildChangeData(taxAgentEmpChangeList, baseInfoPOList, currentEmployeeId);
        // 批量修改福利档案
        if (CollectionUtils.isNotEmpty(changeData.getBaseInfoUpdateTodoList())) {
            //对于即将调整为“待减员”的数据，更新社保、公积金、其他福利档案的停止缴纳时间
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM");
            String today = simpleDateFormat.format(new Date());

            List<InsuranceArchivesBaseInfoPO> toStayDelList = changeData.getBaseInfoUpdateTodoList().stream()
                    .filter(f -> f.getRunStatus().equals(EmployeeStatusEnum.STAY_DEL.getValue()))
                    .collect(Collectors.toList());
            if (toStayDelList.size() > 0) {
                List<List<InsuranceArchivesBaseInfoPO>> partitionUpdateEndTime = Lists.partition(toStayDelList, 100);
                partitionUpdateEndTime.forEach(part->{
                    List<Long> socialIds =  part.stream().map(InsuranceArchivesBaseInfoPO::getSocialArchivesId).collect(Collectors.toList());
                    List<Long> fundIds =  part.stream().map(InsuranceArchivesBaseInfoPO::getFundArchivesId).collect(Collectors.toList());
                    List<Long> otherIds =  part.stream().map(InsuranceArchivesBaseInfoPO::getOtherArchivesId).collect(Collectors.toList());

                    getSocialSchemeMapper().batchUpdateEndTime(socialIds, today);
                    getFundSchemeMapper().batchUpdateEndTime(fundIds, today);
                    getOtherSchemeMapper().batchUpdateEndTime(otherIds, today);
                });

            }

            //修改福利档案基础信息
            List<List<InsuranceArchivesBaseInfoPO>> partitionUpdateBase = Lists.partition(changeData.getBaseInfoUpdateTodoList(), 100);
            partitionUpdateBase.forEach(part-> getInsuranceBaseInfoMapper().batchUpdate(part));

        }
        // 批量新增福利档案
        if (CollectionUtils.isNotEmpty(changeData.getBaseInfoAddTodoList())) {
            //新增社保、公积金、其他福利档案、福利档案基础信息
            addNewInsuranceBaseInfo(changeData.getBaseInfoAddTodoList(), currentEmployeeId);
        }

        // 删除增量数据
        if (CollectionUtils.isNotEmpty(changeData.getChangeIds())) {
            getTaxAgentEmpChangeService(user).deleleByIds(changeData.getChangeIds());
        }

    }
    //新增社保、公积金、其他福利档案、福利档案基础信息
    private List<InsuranceArchivesBaseInfoPO> addNewInsuranceBaseInfo(List<InsuranceArchivesBaseInfoPO> baseInfoPOList, Long currentEmployeeId) {
        List<InsuranceArchivesSocialSchemePO> socialList = new ArrayList<>();
        List<InsuranceArchivesFundSchemePO> fundList = new ArrayList<>();
        List<InsuranceArchivesOtherSchemePO> otherList = new ArrayList<>();
        for (InsuranceArchivesBaseInfoPO baseInfoPO : baseInfoPOList) {
            InsuranceArchivesSocialSchemePO insuranceArchivesSocialSchemePO = new InsuranceArchivesSocialSchemePO();
            insuranceArchivesSocialSchemePO.setTenantKey("");
            insuranceArchivesSocialSchemePO.setWelfareType(WelfareTypeEnum.SOCIAL_SECURITY.getValue());
            insuranceArchivesSocialSchemePO.setPaymentOrganization(baseInfoPO.getPaymentOrganization());
            insuranceArchivesSocialSchemePO.setNonPayment(NonPaymentEnum.YES.getValue());
            insuranceArchivesSocialSchemePO.setCreator(currentEmployeeId);
            insuranceArchivesSocialSchemePO.setCreateTime(new Date());
            insuranceArchivesSocialSchemePO.setUpdateTime(new Date());
            insuranceArchivesSocialSchemePO.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue());
            insuranceArchivesSocialSchemePO.setEmployeeId(baseInfoPO.getEmployeeId());
            socialList.add(insuranceArchivesSocialSchemePO);

            InsuranceArchivesFundSchemePO insuranceArchivesFundSchemePO = new InsuranceArchivesFundSchemePO();
            insuranceArchivesFundSchemePO.setTenantKey("");
            insuranceArchivesFundSchemePO.setWelfareType(WelfareTypeEnum.ACCUMULATION_FUND.getValue());
            insuranceArchivesFundSchemePO.setPaymentOrganization(baseInfoPO.getPaymentOrganization());
            insuranceArchivesFundSchemePO.setNonPayment(NonPaymentEnum.YES.getValue());
            insuranceArchivesFundSchemePO.setCreator(currentEmployeeId);
            insuranceArchivesFundSchemePO.setCreateTime(new Date());
            insuranceArchivesFundSchemePO.setUpdateTime(new Date());
            insuranceArchivesFundSchemePO.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue());
            insuranceArchivesFundSchemePO.setEmployeeId(baseInfoPO.getEmployeeId());
            fundList.add(insuranceArchivesFundSchemePO);

            InsuranceArchivesOtherSchemePO insuranceArchivesOtherSchemePO = new InsuranceArchivesOtherSchemePO();
            insuranceArchivesOtherSchemePO.setTenantKey("");
            insuranceArchivesOtherSchemePO.setWelfareType(WelfareTypeEnum.OTHER.getValue());
            insuranceArchivesOtherSchemePO.setPaymentOrganization(baseInfoPO.getPaymentOrganization());
            insuranceArchivesOtherSchemePO.setNonPayment(NonPaymentEnum.YES.getValue());
            insuranceArchivesOtherSchemePO.setCreator(currentEmployeeId);
            insuranceArchivesOtherSchemePO.setCreateTime(new Date());
            insuranceArchivesOtherSchemePO.setUpdateTime(new Date());
            insuranceArchivesOtherSchemePO.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue());
            insuranceArchivesOtherSchemePO.setEmployeeId(baseInfoPO.getEmployeeId());
            otherList.add(insuranceArchivesOtherSchemePO);

        }
        //导入社保档案
        if (CollectionUtils.isNotEmpty(socialList)) {
            socialList = socialList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(InsuranceArchivesSocialSchemePO::getEmployeeId))), ArrayList::new));
            //根据人员id和个税扣缴义务人id删除对应档案
            socialList.forEach(getSocialSchemeMapper()::deleteByEmployeeIdAndPayOrg);
//            List<Long> socialEmployeeIds = socialList.stream().map(InsuranceArchivesSocialSchemePO::getEmployeeId).collect(Collectors.toList());
//            List<List<Long>> socialEmployeeIdPartition = Lists.partition(socialEmployeeIds, 100);
//            socialEmployeeIdPartition.forEach(getSocialSchemeMapper()::batchDeleteByEmployeeIds);
            List<List<InsuranceArchivesSocialSchemePO>> partition = Lists.partition(socialList, 100);
            partition.forEach(getSocialSchemeMapper()::batchSave);
        }
        //导入公积金档案
        if (CollectionUtils.isNotEmpty(fundList)) {
            fundList = fundList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(InsuranceArchivesFundSchemePO::getEmployeeId))), ArrayList::new));
            //根据人员id和个税扣缴义务人id删除对应档案
            fundList.forEach(getFundSchemeMapper()::deleteByEmployeeIdAndPayOrg);
//            List<Long> fundEmployeeIds = fundList.stream().map(InsuranceArchivesFundSchemePO::getEmployeeId).collect(Collectors.toList());
//            List<List<Long>> fundEmployeeIdsPartition = Lists.partition(fundEmployeeIds, 100);
//            fundEmployeeIdsPartition.forEach(getFundSchemeMapper()::batchDeleteByEmployeeIds);
            List<List<InsuranceArchivesFundSchemePO>> partition = Lists.partition(fundList, 100);
            partition.forEach(getFundSchemeMapper()::batchSave);
        }
        //导入其他福利档案
        if (CollectionUtils.isNotEmpty(otherList)) {
            otherList = otherList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(InsuranceArchivesOtherSchemePO::getEmployeeId))), ArrayList::new));
            //根据人员id和个税扣缴义务人id删除对应档案
            otherList.forEach(getOtherSchemeMapper()::deleteByEmployeeIdAndPayOrg);
//            List<Long> otherEmployeeIds = otherList.stream().map(InsuranceArchivesOtherSchemePO::getEmployeeId).collect(Collectors.toList());
//            List<List<Long>> otherEmployeeIdsPartition = Lists.partition(otherEmployeeIds, 100);
//            otherEmployeeIdsPartition.forEach(getOtherSchemeMapper()::batchDeleteByEmployeeIds);
            List<List<InsuranceArchivesOtherSchemePO>> partition = Lists.partition(otherList, 100);
            partition.forEach(getOtherSchemeMapper()::batchSave);
        }
        //导入福利档案基础信息
        if (CollectionUtils.isNotEmpty(baseInfoPOList)) {
            baseInfoPOList = baseInfoPOList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(InsuranceArchivesBaseInfoPO::getEmployeeId))), ArrayList::new));
            //根据人员id和个税扣缴义务人id删除对应档案
            baseInfoPOList.forEach(getInsuranceBaseInfoMapper()::deleteByEmployeeIdAndPayOrg);
//            //分批批量删除
            List<Long> baseInfoEmployeeIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getEmployeeId).collect(Collectors.toList());
//            List<List<Long>> employeeIdPartition = Lists.partition(baseInfoEmployeeIds, 100);
//            employeeIdPartition.forEach(getInsuranceBaseInfoMapper()::batchDeleteByEmployeeIds);
            //查询目标人员的剩余的福利档案基础信息（社保、公积金、其他福利档案id）
            List<InsuranceArchivesBaseInfoPO> moreBaseInfoPOS = getInsuranceBaseInfoMapper().getInsuranceBaseInfoListByInsuranceDetail(baseInfoEmployeeIds);
            List<InsuranceArchivesBaseInfoPO> newInsuranceArchivesBaseInfoList = new ArrayList<>();
            //设置社保、公积金、其他福利档案id
            for (InsuranceArchivesBaseInfoPO po : baseInfoPOList) {
                InsuranceArchivesBaseInfoPO moreBaseInfo = moreBaseInfoPOS.stream().filter(s -> Objects.equals(s.getEmployeeId(), po.getEmployeeId()) && Objects.equals(s.getPaymentOrganization(), po.getPaymentOrganization())).findFirst().orElse(null);
                po.setSocialArchivesId(moreBaseInfo.getSocialArchivesId());
                po.setFundArchivesId(moreBaseInfo.getFundArchivesId());
                po.setOtherArchivesId(moreBaseInfo.getOtherArchivesId());
                newInsuranceArchivesBaseInfoList.add(po);
            }
            //分批批量入库
            List<List<InsuranceArchivesBaseInfoPO>> partition = Lists.partition(newInsuranceArchivesBaseInfoList, 100);
            partition.forEach(getInsuranceBaseInfoMapper()::batchSave);
        }

        return baseInfoPOList;
    }
    /**
     * 分批更新福利档案基础信息的runStatus
     * @param baseInfoPOList
     * @param runStatus
     */
    private void updateInsuranceBaseInfoRunStatus(List<InsuranceArchivesBaseInfoPO> baseInfoPOList, String runStatus) {
        if (CollectionUtils.isNotEmpty(baseInfoPOList)) {
            List<Long> idList = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList());
            List<List<Long>> partition = Lists.partition(idList, 999);
            partition.forEach(
                    part -> {
                        InsuranceArchivesBaseInfoPO baseInfoPO = new InsuranceArchivesBaseInfoPO();
                        baseInfoPO.setIds(part);
                        baseInfoPO.setRunStatus(runStatus);
                        getInsuranceBaseInfoMapper().updateRunStatusByIds(baseInfoPO);
                    }

            );
        }
    }

    @Override
    public Map<String, Object> getSearchCondition(Map<String, Object> param) {
        Map<String, Object> apidatas = new HashMap<>(16);
        SIArchivesBiz siArchivesBiz = new SIArchivesBiz();
        apidatas = siArchivesBiz.getSearchCondition(user);
        return apidatas;
    }

    @Override
    public XSSFWorkbook export(InsuranceArchivesListParam param) {
        InsuranceArchivesListParam request = InsuranceArchivesListParam.builder().build();
        if (param.getHireDate() != null && param.getHireDate().length == 2) {
            param.setHiredateStart(param.getHireDate()[0]);
            param.setHiredateEnd(param.getHireDate()[1]);
        }
        if (param.getDimissionDate() != null && param.getDimissionDate().length == 2) {
            param.setDimissionDateStart(param.getDimissionDate()[0]);
            param.setDimissionDateEnd(param.getDimissionDate()[1]);
        }
        if (Objects.equals("fromQuickSearch", param.getDataSource())) {
            request.setStatuses(param.getStatuses());
            request.setKeyword(param.getUserName());
        } else {
            request = param;
        }
        request.setPageSize(null);
        request.setStartNum(null);
        List<InsuranceArchivesEmployeePO> insuranceArchivesEmployeePOS = listPageEmployeePOS(request);
        if (insuranceArchivesEmployeePOS == null) {
            insuranceArchivesEmployeePOS = new ArrayList<>();
        }
        List<Map<String, Object>> records = siArchivesBiz.buildTableData(insuranceArchivesEmployeePOS);
        List<WeaTableColumn> columns = siArchivesBiz.buildWeaTableColumns(insuranceArchivesEmployeePOS, user.getUID());

        //工作簿list
        List<List<Object>> excelSheetData = new ArrayList<>();

        //工作簿名称
        String sheetName = SalaryI18nUtil.getI18nLabel(85368, "社保福利档案");        //表头
        //表头
        excelSheetData.add(Arrays.asList(columns.stream().map(WeaTableColumn::getText).toArray(String[]::new)));
        //工作簿数据
        List<List<Object>> rows = new LinkedList<>();
        for (Map<String, Object> recordData : records) {
            List<Object> row = new LinkedList<>();
            for (WeaTableColumn column : columns) {
                row.add(recordData.get(column.getColumn()));
            }
            rows.add(row);
        }
        excelSheetData.addAll(rows);
        return ExcelUtil.genWorkbookV2(excelSheetData, sheetName);

    }

    @Override
    public List<InsuranceArchivesEmployeePO> listPageEmployeePOS(InsuranceArchivesListParam param) {
        long currentEmployeeId = user.getUID();
        Boolean needAuth = getTaxAgentService(user).isNeedAuth(currentEmployeeId);
        if (needAuth) {
            List<TaxAgentEmployeeDTO> taxAgentEmployeeDTOS = getTaxAgentService(user).listTaxAgentAndEmployee(currentEmployeeId);
            Set<Long> employeeIds = SalaryEntityUtil.properties(taxAgentEmployeeDTOS, TaxAgentEmployeeDTO::getEmployeeId);
            List<InsuranceArchivesEmployeePO> list = MapperProxyFactory.getProxy(SocialSchemeMapper.class).queryEmployeeList(param);
            return list.stream().filter(f -> employeeIds.contains(f.getEmployeeId())).collect(Collectors.toList());
        }

        return MapperProxyFactory.getProxy(SocialSchemeMapper.class).queryEmployeeList(param);
    }

    /**
     * 获取福利档案各tab总人数
     */
    @Override
    public Map<String, Long> queryInsuranceTabTotal() {
        long currentEmployeeId = user.getUID();

        // tab页签数量
        Map<String, Long> result = new HashMap<>();

        Boolean needAuth = getTaxAgentService(user).isNeedAuth(currentEmployeeId);

        //获取管理的人员范围
        List<TaxAgentManageRangeEmployeeDTO> taxAgentEmployeeDTOS = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId);
        Map<Long, List<TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee>> taxAgentEmployeesMap = SalaryEntityUtil.convert2Map(taxAgentEmployeeDTOS, TaxAgentManageRangeEmployeeDTO::getTaxAgentId, TaxAgentManageRangeEmployeeDTO::getEmployeeList);
        List<InsuranceArchivesBaseInfoPO> list = null;
        if (needAuth) {
            // 获取作为管理员的所有个税扣缴义务人列表
            Collection<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listAllTaxAgentsAsAdmin(currentEmployeeId);
            Set<Long> taxAgentIds = SalaryEntityUtil.properties(taxAgentPOS, TaxAgentPO::getId);

            //获取所有福利档案基础信息
            List<InsuranceArchivesBaseInfoPO> archiveListDTOS = getInsuranceBaseInfoMapper().listAll();
            list = archiveListDTOS.stream().filter(dto -> taxAgentIds.contains(dto.getPaymentOrganization())).collect(Collectors.toList());

            Boolean adminEnable = getTaxAgentService(user).isAdminEnable(currentEmployeeId);
            //不是管理员看不到数据，返回空
            if (!adminEnable) {
                list = new ArrayList<>();
            }

        } else {
            list = getInsuranceBaseInfoMapper().listAll();
        }


        long stayAddTotal = 0L;
        long payTotal = 0L;
        long stayDelTotal = 0L;
        long stopTotal = 0L;

        for (InsuranceArchivesBaseInfoPO baseInfoPO : list) {
            if (baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STAY_ADD.getValue())) {
                stayAddTotal += 1;
            } else if (baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.PAYING.getValue()) || baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STAY_DEL.getValue())) {
                payTotal += 1;
                if (baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STAY_DEL.getValue())) {
                    stayDelTotal += 1;
                }
            } else if (baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STOP_PAYMENT_FROM_ADD.getValue()) || baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STOP_PAYMENT_FROM_DEL.getValue())) {
                stopTotal += 1;
            }
        }

        result.put("stayAdd", stayAddTotal);
        result.put("paying", payTotal);
        result.put("stayDel", stayDelTotal);
        result.put("stopPay", stopTotal);
        return result;
    }

    /**
     * 批量变更档案列表的runStatus
     */
    @Override
    public void updateRunStatus(InsuranceArchivesBaseInfoPO po) {

        getInsuranceBaseInfoMapper().updateRunStatusByIds(po);
    }

    @Override
    public void cancelStopPayment(Collection<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录"));
        }
        List<InsuranceArchivesBaseInfoPO> pos = getInsuranceBaseInfoMapper().listByIds(ids);

        List<Long> stayAddIds = new ArrayList<>();
        List<Long> stayDelIds = new ArrayList<>();

        for(InsuranceArchivesBaseInfoPO po : pos) {
            if (po.getRunStatus().equals(EmployeeStatusEnum.STOP_PAYMENT_FROM_ADD.getValue())) {
                //来自待增员的停缴->待增员
                stayAddIds.add(po.getId());
            } else if (po.getRunStatus().equals(EmployeeStatusEnum.STOP_PAYMENT_FROM_DEL.getValue())) {
                //来自待减员的停缴->待减员
                stayDelIds.add(po.getId());
            }
        }

        //更新调整为待增员的数据
        InsuranceArchivesBaseInfoPO stayAddPO = InsuranceArchivesBaseInfoPO.builder().ids(stayAddIds).runStatus(EmployeeStatusEnum.STAY_ADD.getValue()).build();
        if (stayAddPO.getIds().size() > 0) {
            getInsuranceBaseInfoMapper().updateRunStatusByIds(stayAddPO);
        }
        //更新调整为待减员的数据
        InsuranceArchivesBaseInfoPO stayDelPO = InsuranceArchivesBaseInfoPO.builder().ids(stayDelIds).runStatus(EmployeeStatusEnum.STAY_DEL.getValue()).build();
        if (stayDelPO.getIds().size() > 0) {
            getInsuranceBaseInfoMapper().updateRunStatusByIds(stayDelPO);
        }

    }

    /**
     * 批量减员
     */
    @Override
    public Map<String, Object> stayDelToStop(Collection<Long> ids) {

        if (CollectionUtils.isEmpty(ids)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录"));
        }
        List<InsuranceArchivesBaseInfoPO> baseInfoPOList = getInsuranceBaseInfoMapper().listByIds(ids);

        //分别新建福利档案基础信息相关的社保、公积金、其他福利档案列表
        List<InsuranceArchivesSocialSchemePO> socialList = new ArrayList<>();
        List<InsuranceArchivesFundSchemePO> fundList = new ArrayList<>();
        List<InsuranceArchivesOtherSchemePO> otherList = new ArrayList<>();
        //分别新建福利档案基础信息相关的社保、公积金、其他福利档案可以进行减员的人员列表
        List<Long> toStopSocialEmployeeIdList = new ArrayList<>();
        List<Long> toStopFundEmployeeIdList = new ArrayList<>();
        List<Long> toStopOtherEmployeeIdList = new ArrayList<>();
        //分别新建福利档案基础信息相关的社保、公积金、其他福利档案不可以进行减员的人员列表
        List<Long> noStopSocialEmployeeIdList = new ArrayList<>();
        List<Long> noStopFundEmployeeIdList = new ArrayList<>();
        List<Long> noStopOtherEmployeeIdList = new ArrayList<>();
        //新建最终可以进行减员的人员列表
        List<Long> toStopEmployeeIdList = new ArrayList<>();
        //新建最终不可以进行减员的人员列表
        List<Long> noStopEmployeeIds = new ArrayList<>();
        //获取待处理的员工id列表
        List<Long> employeeIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getEmployeeId).collect(Collectors.toList());
        //设置最后缴纳月的比较月份
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM");
        String todayMonth = simpleDateFormat.format(new Date());
        //分别获取福利档案基础信息相关的社保、公积金、其他福利档案id列表
        List<Long> socialIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getSocialArchivesId).collect(Collectors.toList());
        List<Long> fundIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getFundArchivesId).collect(Collectors.toList());
        List<Long> otherIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getOtherArchivesId).collect(Collectors.toList());
        //获取可进行减员的社保档案相关人员数据
        if (socialIds.size() > 0) {
            //获取社保档案
            socialList = getSocialSchemeMapper().getSocialById(socialIds);
            //筛选可减员的社保档案相关人员信息
            toStopSocialEmployeeIdList = socialList.stream().filter(f->f.getSocialEndTime() != null && f.getSocialEndTime().length() > 0 && (f.getSocialEndTime().compareTo(todayMonth)) <= 0)
                    .map(InsuranceArchivesSocialSchemePO::getEmployeeId).collect(Collectors.toList());
            //获取不可减员的社保档案相关人员信息
            if (toStopSocialEmployeeIdList.size() != baseInfoPOList.size()) {
                noStopSocialEmployeeIdList = (List<Long>) CollectionUtils.subtract(employeeIds, toStopSocialEmployeeIdList);
            }

        }
        if (fundIds.size() > 0) {
            fundList = getFundSchemeMapper().getFundById(fundIds);
            toStopFundEmployeeIdList = fundList.stream().filter(f->f.getFundEndTime() != null && f.getFundEndTime().length() > 0 && (f.getFundEndTime().compareTo(todayMonth)) <= 0)
                    .map(InsuranceArchivesFundSchemePO::getEmployeeId).collect(Collectors.toList());
            if (toStopFundEmployeeIdList.size() != baseInfoPOList.size()) {
                noStopFundEmployeeIdList = (List<Long>) CollectionUtils.subtract(employeeIds, toStopFundEmployeeIdList);
            }
        }
        if (otherIds.size() > 0) {
            otherList = getOtherSchemeMapper().getOtherById(otherIds);
            toStopOtherEmployeeIdList = otherList.stream().filter(f->f.getOtherEndTime() != null && f.getOtherEndTime().length() > 0 && (f.getOtherEndTime().compareTo(todayMonth)) <= 0)
                    .map(InsuranceArchivesOtherSchemePO::getEmployeeId).collect(Collectors.toList());
            if (toStopOtherEmployeeIdList.size() != baseInfoPOList.size()) {
                noStopOtherEmployeeIdList = (List<Long>) CollectionUtils.subtract(employeeIds, toStopOtherEmployeeIdList);
            }
        }
        //获取最终基础信息表中的可减员数据
        if (noStopSocialEmployeeIdList.size() == 0 && noStopFundEmployeeIdList.size() == 0 && noStopOtherEmployeeIdList.size() ==0) {
            //社保、公积金、其他福利档案的可减员的人员信息与入参中的人员信息一致时
            toStopEmployeeIdList = employeeIds;
        } else {
            //社保、公积金、其他福利档案的可减员的人员信息与入参中的人员信息不一致时，取三类档案不可减员的人员并集，作为最终不可减员的人员信息
            noStopEmployeeIds = (List<Long>) CollectionUtils.union(CollectionUtils.union(noStopSocialEmployeeIdList, noStopFundEmployeeIdList), noStopOtherEmployeeIdList);
            //入参人员信息和最终不可减员的人员信息做差集，获得最终可减员的人员信息
            toStopEmployeeIdList = (List<Long>) CollectionUtils.subtract(employeeIds, noStopEmployeeIds);
        }
        //进行减员操作
        if (toStopEmployeeIdList.size() > 0) {
            getInsuranceBaseInfoMapper().updateRunStatusByEmployeeIds(InsuranceArchivesBaseInfoPO.builder()
                    .employeeIds(toStopEmployeeIdList).runStatus(EmployeeStatusEnum.STOP_PAYMENT_FROM_DEL.getValue()).build());
        }

        Map<String, Object> resultMap = new HashMap<>(2);
        String resultMsg = "操作成功";
        String resultType = "success";
        // 批量设为定薪提示

        //输出结果，此处需区分单一减员和批量减员
        if (baseInfoPOList.size() == toStopEmployeeIdList.size()) {
            //减员成功
            if (baseInfoPOList.size() == 1) {
                resultMsg = "减员成功";

            } else {
                resultMsg = "批量减员成功";

            }
        } else {
            //减员失败
            resultType = "fail";
            if (baseInfoPOList.size() == 1) {
                resultMsg = "减员失败，失败原因：数据未正常维护";

            } else {
                resultMsg = "部分或全部失败：【共提交减员数据"
                        + employeeIds.size()
                        +"条，成功" + toStopEmployeeIdList.size()
                        +"条，失败" + noStopEmployeeIds.size()
                        +"条，失败原因：数据未正常维护】";

            }
        }
        resultMap.put("type", resultType);
        resultMap.put("msg", resultMsg);
        return resultMap;
    }

    /**
     * 全量减员
     */
    @Override
    public Map<String, Object> allStayDelToStop() {
        List<InsuranceArchivesBaseInfoPO> allBaseInfoList = getInsuranceBaseInfoMapper().listAll();
        if (allBaseInfoList.size() > 0) {
            Collection<Long> stayDelIds = allBaseInfoList.stream().filter(f->f.getRunStatus().equals(EmployeeStatusEnum.STAY_DEL.getValue()))
                    .map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList());
            if (stayDelIds.size() > 0) {
                return stayDelToStop(stayDelIds);
            } else {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录"));
            }
        } else {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录"));
        }
    }

    /**
     * 批量增员
     */
    @Override
    public Map<String, Object> stayAddToPay(Collection<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录"));
        }
        List<InsuranceArchivesBaseInfoPO> baseInfoPOList = getInsuranceBaseInfoMapper().listByIds(ids);

        //分别新建福利档案基础信息相关的社保、公积金、其他福利档案列表
        List<InsuranceArchivesSocialSchemePO> socialList = new ArrayList<>();
        List<InsuranceArchivesFundSchemePO> fundList = new ArrayList<>();
        List<InsuranceArchivesOtherSchemePO> otherList = new ArrayList<>();
        //分别新建福利档案基础信息相关的社保、公积金、其他福利档案可以进行增员的人员列表
        List<Long> toPaySocialEmployeeIdList = new ArrayList<>();
        List<Long> toPayFundEmployeeIdList = new ArrayList<>();
        List<Long> toPayOtherEmployeeIdList = new ArrayList<>();
        //分别新建福利档案基础信息相关的社保、公积金、其他福利档案不可以进行增员的人员列表
        List<Long> noPaySocialEmployeeIdList = new ArrayList<>();
        List<Long> noPayFundEmployeeIdList = new ArrayList<>();
        List<Long> noPayOtherEmployeeIdList = new ArrayList<>();
        //新建最终可以进行增员的人员列表
        List<Long> toPayEmployeeIdList = new ArrayList<>();
        //新建最终不可以进行增员的人员列表
        List<Long> noPayEmployeeIds = new ArrayList<>();
        //获取待处理的员工id列表
        List<Long> employeeIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getEmployeeId).collect(Collectors.toList());
        //设置最后缴纳月的比较月份
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM");
        String todayMonth = simpleDateFormat.format(new Date());
        //分别获取福利档案基础信息相关的社保、公积金、其他福利档案id列表
        List<Long> socialIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getSocialArchivesId).collect(Collectors.toList());
        List<Long> fundIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getFundArchivesId).collect(Collectors.toList());
        List<Long> otherIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getOtherArchivesId).collect(Collectors.toList());
        //获取可进行增员的社保档案相关人员数据
        if (socialIds.size() > 0) {
            //获取社保档案
            socialList = getSocialSchemeMapper().getSocialById(socialIds);
            //筛选可增员的社保档案相关人员信息
            toPaySocialEmployeeIdList = socialList.stream().filter(f->
            {
                boolean flag = true;
                if (f.getSocialStartTime() == null || f.getSocialStartTime().length() == 0 || f.getSocialSchemeId() == null) {
                    flag = false;
                }
                if (f.getSocialEndTime() != null && f.getSocialEndTime().length() > 0 && (f.getSocialEndTime().compareTo(todayMonth)) <= 0) {
                    flag = false;
                }
                return flag;
            })
                    .map(InsuranceArchivesSocialSchemePO::getEmployeeId).collect(Collectors.toList());
            //获取不可增员的社保档案相关人员信息
            if (toPaySocialEmployeeIdList.size() != baseInfoPOList.size()) {
                noPaySocialEmployeeIdList = (List<Long>) CollectionUtils.subtract(employeeIds, toPaySocialEmployeeIdList);
            }

        }
        if (fundIds.size() > 0) {
            fundList = getFundSchemeMapper().getFundById(fundIds);
            toPayFundEmployeeIdList = fundList.stream().filter(f->
            {
                boolean flag = true;
                if (f.getFundStartTime() == null || f.getFundStartTime().length() == 0 || f.getFundSchemeId() == null) {
                    flag = false;
                }
                if (f.getFundEndTime() != null && f.getFundEndTime().length() > 0 && (f.getFundEndTime().compareTo(todayMonth)) <= 0) {
                    flag = false;
                }
                return flag;
            })
                    .map(InsuranceArchivesFundSchemePO::getEmployeeId).collect(Collectors.toList());
            if (toPayFundEmployeeIdList.size() != baseInfoPOList.size()) {
                noPayFundEmployeeIdList = (List<Long>) CollectionUtils.subtract(employeeIds, toPayFundEmployeeIdList);
            }
        }
        if (otherIds.size() > 0) {
            otherList = getOtherSchemeMapper().getOtherById(otherIds);
            toPayOtherEmployeeIdList = otherList.stream().filter(f->
            {
                boolean flag = true;
                if (f.getOtherStartTime() == null || f.getOtherStartTime().length() == 0 || f.getOtherSchemeId() == null) {
                    flag = false;
                }
                if (f.getOtherEndTime() != null && f.getOtherEndTime().length() > 0 && (f.getOtherEndTime().compareTo(todayMonth)) <= 0) {
                    flag = false;
                }
                return flag;
            })
                    .map(InsuranceArchivesOtherSchemePO::getEmployeeId).collect(Collectors.toList());
            if (toPayOtherEmployeeIdList.size() != baseInfoPOList.size()) {
                noPayOtherEmployeeIdList = (List<Long>) CollectionUtils.subtract(employeeIds, toPayOtherEmployeeIdList);
            }
        }
        //获取最终基础信息表中的可增员数据
        if (noPaySocialEmployeeIdList.size() == 0 && noPayFundEmployeeIdList.size() == 0 && noPayOtherEmployeeIdList.size() ==0) {
            //社保、公积金、其他福利档案的可增员的人员信息与入参中的人员信息一致时
            toPayEmployeeIdList = employeeIds;
        } else {
            //社保、公积金、其他福利档案的可增员的人员信息与入参中的人员信息不一致时，取三类档案可增员的人员并集，作为最终可增员的人员信息
            toPayEmployeeIdList = (List<Long>) CollectionUtils.union(CollectionUtils.union(toPaySocialEmployeeIdList, toPayFundEmployeeIdList), toPayOtherEmployeeIdList);
            //入参人员信息和最终可增员的人员信息做差集，获得最终不可增员的人员信息
            noPayEmployeeIds = (List<Long>) CollectionUtils.subtract(employeeIds, toPayEmployeeIdList);
        }
        //其他的个税扣缴义务人下的在缴员工中存在该员工，在缴员工未进入停缴员工时，不可进行增员

        //进行增员操作
        if (toPayEmployeeIdList.size() > 0) {
            getInsuranceBaseInfoMapper().updateRunStatusByEmployeeIds(InsuranceArchivesBaseInfoPO.builder()
                    .employeeIds(toPayEmployeeIdList).runStatus(EmployeeStatusEnum.PAYING.getValue()).build());
        }

        Map<String, Object> resultMap = new HashMap<>(2);
        String resultMsg = "操作成功";
        String resultType = "success";
        // 批量设为定薪提示

        //输出结果，此处需区分单一增员和批量增员
        if (baseInfoPOList.size() == toPayEmployeeIdList.size()) {
            //增员成功
            if (baseInfoPOList.size() == 1) {
                resultMsg = "增员成功";

            } else {
                resultMsg = "批量增员成功";
            }
        } else {
            //增员失败
            resultType = "fail";
            if (baseInfoPOList.size() == 1) {
                resultMsg = "增员失败，失败原因：数据未正常维护";
            } else {
                resultMsg = "部分或全部失败：【共提交增员数据"
                        + employeeIds.size()
                        +"条，成功" + toPayEmployeeIdList.size()
                        +"条，失败" + noPayEmployeeIds.size()
                        +"条，失败原因：数据未正常维护】";

            }
        }
        resultMap.put("type", resultType);
        resultMap.put("msg", resultMsg);
        return resultMap;
    }

    /**
     * 全量增员
     */
    @Override
    public Map<String, Object> allStayAddToPay() {
        List<InsuranceArchivesBaseInfoPO> allBaseInfoList = getInsuranceBaseInfoMapper().listAll();
        if (allBaseInfoList.size() > 0) {
            Collection<Long> stayAddIds = allBaseInfoList.stream().filter(f->f.getRunStatus().equals(EmployeeStatusEnum.STAY_ADD.getValue()))
                    .map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList());
            if (stayAddIds.size() > 0) {
                return stayAddToPay(stayAddIds);
            } else {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录"));
            }
        } else {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录"));
        }
    }


}