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

package com.engine.salary.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.api.formmode.mybatis.util.SqlProxyHandle;
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.biz.SISchemeBiz;
import com.engine.salary.cmd.sischeme.*;
import com.engine.salary.constant.SalaryDefaultTenantConstant;
import com.engine.salary.encrypt.AESEncryptUtil;
import com.engine.salary.encrypt.EncryptUtil;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.siarchives.param.InsuranceArchivesListParam;
import com.engine.salary.entity.siarchives.param.SIArchiveImportParam;
import com.engine.salary.entity.siarchives.po.*;
import com.engine.salary.entity.sicategory.po.ICategoryPO;
import com.engine.salary.entity.sischeme.dto.InsuranceSchemeListDTO;
import com.engine.salary.entity.sischeme.param.InsuranceSchemeDetailUpdateParam;
import com.engine.salary.entity.sischeme.param.InsuranceSchemeParam;
import com.engine.salary.entity.sischeme.po.InsuranceSchemeDetailPO;
import com.engine.salary.entity.sischeme.po.InsuranceSchemePO;
import com.engine.salary.entity.taxagent.dto.TaxAgentEmployeeDTO;
import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeEmployeeDTO;
import com.engine.salary.entity.taxagent.param.TaxAgentManageRangeSaveParam;
import com.engine.salary.entity.taxagent.param.TaxAgentRangeSaveParam;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.UserStatusEnum;
import com.engine.salary.enums.salarysob.TargetTypeEnum;
import com.engine.salary.enums.siaccount.EmployeeStatusEnum;
import com.engine.salary.enums.sicategory.*;
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.mapper.sicategory.ICategoryMapper;
import com.engine.salary.mapper.sischeme.InsuranceSchemeDetailMapper;
import com.engine.salary.mapper.sischeme.InsuranceSchemeMapper;
import com.engine.salary.mapper.sys.SalarySysConfMapper;
import com.engine.salary.mapper.taxagent.TaxAgentMapper;
import com.engine.salary.service.*;
import com.engine.salary.sys.entity.po.SalarySysConfPO;
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.*;
import com.engine.salary.util.db.MapperProxyFactory;
import com.engine.salary.util.excel.ExcelParseHelper;
import com.engine.salary.util.excel.ExcelSupport;
import com.engine.salary.util.excel.ExcelUtil;
import com.engine.salary.util.page.PageInfo;
import com.engine.salary.util.page.SalaryPageUtil;
import com.engine.salary.util.valid.ValidUtil;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import dm.jdbc.util.IdGenerator;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.BeanUtils;
import weaver.file.ImageFileManager;
import weaver.hrm.User;

import java.io.InputStream;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

import static com.engine.salary.util.excel.ExcelSupport.EXCEL_TYPE_XLSX;

/**
 * @Author weaver_cl
 * @Description:
 * @Date 2022/3/7
 * @Version V1.0
 **/
@Slf4j
public class SISchemeServiceImpl extends Service implements SISchemeService {
    private EncryptUtil encryptUtil = new EncryptUtil();

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

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

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

    private InsuranceSchemeMapper getInsuranceSchemeMapper() {
        return MapperProxyFactory.getProxy(InsuranceSchemeMapper.class);
    }

    private TaxAgentMapper getTaxAgentMapper() {
        return MapperProxyFactory.getProxy(TaxAgentMapper.class);
    }

    private ICategoryMapper getICategoryMapper() {
        return MapperProxyFactory.getProxy(ICategoryMapper.class);
    }

    private SISchemeService getSiSchemeService() {
        return ServiceUtil.getService(SISchemeServiceImpl.class, user);
    }


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

    private InsuranceSchemeDetailMapper getInsuranceSchemeDetailMapper() {
        return MapperProxyFactory.getProxy(InsuranceSchemeDetailMapper.class);
    }

    private SIImportService getSIImportService() {
        return ServiceUtil.getService(SIImportServiceImpl.class, user);
    }

    private SIArchivesBiz siArchivesBiz = new SIArchivesBiz();
    private SISchemeBiz siSchemeBiz = new SISchemeBiz();

    private SalaryEmployeeService getSalaryEmployeeService(User user) {
        return (SalaryEmployeeService) ServiceUtil.getService(SalaryEmployeeServiceImpl.class, user);
    }

    private SalarySysConfMapper getSalarySysConfMapper() {
        return SqlProxyHandle.getProxy(SalarySysConfMapper.class);
    }

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

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

    public TaxAgentManageRangeService getTaxAgentManageRangeService(User user) {
        return ServiceUtil.getService(TaxAgentManageRangeServiceImpl.class, user);
    }

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

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

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

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

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

    @Override
    public List<InsuranceSchemeDetailPO> queryListByInsuranceIdIsPayment(Long insuranceId, Integer isPayment) {
        return new SISchemeBiz().queryListByInsuranceIdIsPayment(insuranceId, isPayment);
    }

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

    @Override
    public Map<Long, String> getSchemeIdNameMap() {
        Map<Long, String> result = new HashMap<>();
        List<InsuranceSchemePO> insuranceSchemePOS = getInsuranceSchemeMapper().listAll();
        if (CollectionUtils.isNotEmpty(insuranceSchemePOS)) {
            result = insuranceSchemePOS.stream().collect(Collectors.toMap(InsuranceSchemePO::getId, InsuranceSchemePO::getSchemeName));
        }
        return result;
    }

    @Override
    public PageInfo<InsuranceSchemeListDTO> list(InsuranceSchemeParam queryParam) {
        SalaryAssert.notNull(queryParam.getWelfareTypeEnum(), SalaryI18nUtil.getI18nLabel(84026, "参数错误"));
        queryParam.setWelfareType(queryParam.getWelfareTypeEnum().getValue());
        if (queryParam.getPaymentTypeEnum() != null) {
            queryParam.setPaymentType(queryParam.getPaymentTypeEnum().getValue());
        }
        Long currentEmployeeId = (long) user.getUID();
        List<InsuranceSchemePO> insuranceSchemePOS;
        Boolean needAuth = getTaxAgentService().isNeedAuth(currentEmployeeId);
        if (needAuth) {
//            insuranceSchemePOS = getInsuranceSchemeMapper().listByWelfareType(queryParam.getWelfareTypeEnum().getValue());
            insuranceSchemePOS = getInsuranceSchemeMapper().list(queryParam);
            Boolean isAdminEnable = getTaxAgentService().isAdminEnable((long) user.getUID());
            if (isAdminEnable) {
                //管理员
                Collection<TaxAgentPO> taxAgentPOS = getTaxAgentService().listAllTaxAgents(currentEmployeeId);
                List<Long> authTaxAgentIds = SalaryEntityUtil.properties(taxAgentPOS, TaxAgentPO::getId, Collectors.toList());
                insuranceSchemePOS = insuranceSchemePOS.stream().filter(po -> {
                    String taxAgentIdsStr = po.getTaxAgentIds();
                    List<Long> taxAgentIds = new ArrayList<>();
                    if (StringUtils.isNotBlank(taxAgentIdsStr)) {
                        taxAgentIds = Arrays.stream(taxAgentIdsStr.split(",")).map(Long::valueOf).collect(Collectors.toList());
                    }
                    return StringUtils.isBlank(po.getSharedType()) || SharedTypeEnum.PUBLIC.getValue().equals(po.getSharedType()) || (SharedTypeEnum.PRIVATE.getValue().equals(po.getSharedType()) && SalaryEntityUtil.judgeIntersection(authTaxAgentIds, taxAgentIds));
                }).collect(Collectors.toList());
            } else {
                //普通用户
                insuranceSchemePOS = new ArrayList<>();
            }
        } else {
//            insuranceSchemePOS = getInsuranceSchemeMapper().listByWelfareType(queryParam.getWelfareTypeEnum().getValue());
            insuranceSchemePOS = getInsuranceSchemeMapper().list(queryParam);
        }

        PageInfo<InsuranceSchemeListDTO> dtoPage = new PageInfo<>(InsuranceSchemeListDTO.class);
        dtoPage.setPageNum(queryParam.getCurrent());
        dtoPage.setPageSize(queryParam.getPageSize());
        dtoPage.setTotal(insuranceSchemePOS.size());
        //分页
        insuranceSchemePOS = SalaryPageUtil.subList(queryParam.getCurrent(), queryParam.getPageSize(), insuranceSchemePOS);
        List<InsuranceSchemeListDTO> collect = insuranceSchemePOS.stream().map(item -> InsuranceSchemeListDTO.builder().id(item.getId()).paymentType(SalaryI18nUtil.getI18nLabel(buildPaymentTypeEnum(item.getPaymentType()).getLabelId(), buildPaymentTypeEnum(item.getPaymentType()).getDefaultLabel())).schemeName(item.getSchemeName()).paymentArea(item.getPaymentArea()).paymentScope(buildPaymentScope(item.getId())).remarks(item.getRemarks()).build()).collect(Collectors.toList());
        dtoPage.setList(collect);
        return dtoPage;
    }

    @Override
    public List<InsuranceArchivesEmployeePO> listPageEmployeePOS(InsuranceArchivesListParam param) {
        long currentEmployeeId = user.getUID();
        //排序配置
        OrderRuleVO orderRule = getSalarySysConfService(user).orderRule();
        param.setOrderRule(orderRule);

        Boolean needAuth = getTaxAgentService().isNeedAuth(currentEmployeeId);
        if (needAuth) {
            List<TaxAgentEmployeeDTO> taxAgentEmployeeDTOS = getTaxAgentService().listTaxAgentAndEmployee(currentEmployeeId);
//            Set<Long> employeeIds = SalaryEntityUtil.properties(taxAgentEmployeeDTOS, TaxAgentEmployeeDTO::getEmployeeId);
            Set<Long> taxAgentIds = SalaryEntityUtil.properties(taxAgentEmployeeDTOS, TaxAgentEmployeeDTO::getTaxAgentId);
            List<InsuranceArchivesEmployeePO> list = getSocialSchemeMapper().queryEmployeeList(param);
            return list.stream().filter(f -> taxAgentIds.contains(f.getPaymentOrganization())).collect(Collectors.toList());
        }

        return getSocialSchemeMapper().queryEmployeeList(param);
    }

    @Override
    public List<Map<String, Object>> buildTableData(List<InsuranceArchivesEmployeePO> insuranceArchivesEmployeePOS) {
        List<Map<String, Object>> records = new ArrayList<>();
        List<TaxAgentPO> taxAgentPOS = getTaxAgentMapper().listAll();
        Map<Long, TaxAgentPO> longTaxAgentPOMap = SalaryEntityUtil.convert2Map(taxAgentPOS, TaxAgentPO::getId);
        List<Long> employeeIds = insuranceArchivesEmployeePOS.stream().map(InsuranceArchivesEmployeePO::getEmployeeId).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(employeeIds)) {
            return records;
        }
        List<InsuranceArchivesSocialSchemePO> socialList = new ArrayList<>();
        List<InsuranceArchivesFundSchemePO> fundList = new ArrayList<>();
        List<InsuranceArchivesOtherSchemePO> otherList = new ArrayList<>();

        for (int i = 0; i < employeeIds.size(); i += 1000) {
            int end = i + 1000;
            if (i + 1000 >= employeeIds.size()) {
                end = employeeIds.size();
            }
            List<Long> ids = employeeIds.subList(i, end);
            socialList.addAll(encryptUtil.decryptList(siArchivesBiz.getSocialByEmployeeIds(ids), InsuranceArchivesSocialSchemePO.class));
            fundList.addAll(encryptUtil.decryptList(siArchivesBiz.getFundByEmployeeIds(ids), InsuranceArchivesFundSchemePO.class));
            otherList.addAll(encryptUtil.decryptList(siArchivesBiz.getOtherByEmployeeIds(ids), InsuranceArchivesOtherSchemePO.class));
        }
        Map<String, InsuranceArchivesSocialSchemePO> socialSchemePOMap = SalaryEntityUtil.convert2Map(socialList, k -> k.getPaymentOrganization() + "-" + k.getEmployeeId());
        Map<String, InsuranceArchivesFundSchemePO> fundSchemePOMap = SalaryEntityUtil.convert2Map(fundList, k -> k.getPaymentOrganization() + "-" + k.getEmployeeId());
        Map<String, InsuranceArchivesOtherSchemePO> otherSchemePOMap = SalaryEntityUtil.convert2Map(otherList, k -> k.getPaymentOrganization() + "-" + k.getEmployeeId());

//        Map<Long, InsuranceArchivesSocialSchemePO> socialSchemePOMap = socialList.stream().collect(Collectors.toMap(InsuranceArchivesSocialSchemePO::getEmployeeId, Function.identity()));
//        Map<Long, InsuranceArchivesFundSchemePO> fundSchemePOMap = fundList.stream().collect(Collectors.toMap(InsuranceArchivesFundSchemePO::getEmployeeId, Function.identity()));
//        Map<Long, InsuranceArchivesOtherSchemePO> otherSchemePOMap = otherList.stream().collect(Collectors.toMap(InsuranceArchivesOtherSchemePO::getEmployeeId, Function.identity()));
        insuranceArchivesEmployeePOS.forEach(item -> {
            InsuranceArchivesSocialSchemePO socialItem = socialSchemePOMap.get(item.getPaymentOrganization() + "-" + item.getEmployeeId());
            InsuranceArchivesFundSchemePO fundItem = fundSchemePOMap.get(item.getPaymentOrganization() + "-" + item.getEmployeeId());
            InsuranceArchivesOtherSchemePO otherItem = otherSchemePOMap.get(item.getPaymentOrganization() + "-" + item.getEmployeeId());
            Map<String, Object> map = new HashMap<>();
            map.put("employeeName", item.getUserName());
            map.put("employeeId", item.getEmployeeId());
            map.put("subcompanyName", item.getSubcompanyName());
            map.put("departmentName", item.getDepartmentName());
            map.put("departmentId", item.getDepartmentId());
            map.put("jobNum", item.getJobNum());
            map.put("paymentOrganizationName", longTaxAgentPOMap.get(item.getPaymentOrganization()) != null ? longTaxAgentPOMap.get(item.getPaymentOrganization()).getName() : "");
            map.put("mobile", item.getTelephone());
            map.put("status", item.getUserStatus() == null ? "" : UserStatusEnum.getDefaultLabelByValue(item.getUserStatus()));
            if (socialItem != null) {
                map.put("socialName", getSiSchemeService().querySchemeName(socialItem.getSocialSchemeId()));
                Map<String, Object> socialJson = JSON.parseObject(socialItem.getSocialPaymentBaseString(), new TypeReference<Map<String, Object>>() {
                });
                if (socialJson != null) {
                    map.putAll(socialJson);
                    // SalaryEntityUtil.thousandthConvert(socialJson, map);
                }
                map.put("socialAccount", socialItem.getSocialAccount());
                map.put("socialStartTime", socialItem.getSocialStartTime());
                map.put("socialEndTime", socialItem.getSocialEndTime());
            }
            if (fundItem != null) {
                map.put("fundName", getSiSchemeService().querySchemeName(fundItem.getFundSchemeId()));
                map.put("fundAccount", fundItem.getFundAccount());
                Map<String, Object> fundJson = JSON.parseObject(fundItem.getFundPaymentBaseString(), new TypeReference<Map<String, Object>>() {
                });
                if (fundJson != null) {
                    map.putAll(fundJson);
                    // SalaryEntityUtil.thousandthConvert(fundJson, map);
                }
                map.put("supplementFundAccount", fundItem.getSupplementFundAccount());
                map.put("fundStartTime", fundItem.getFundStartTime());
                map.put("fundEndTime", fundItem.getFundEndTime());

            }
            if (otherItem != null) {
                map.put("otherName", getSiSchemeService().querySchemeName(otherItem.getOtherSchemeId()));
                Map<String, Object> otherJson = JSON.parseObject(otherItem.getOtherPaymentBaseString(), new TypeReference<Map<String, Object>>() {
                });
                if (otherJson != null) {
                    map.putAll(otherJson);
                    //SalaryEntityUtil.thousandthConvert(otherJson, map);
                }
                map.put("otherStartTime", otherItem.getOtherStartTime());
                map.put("otherEndTime", otherItem.getOtherEndTime());
            }
            records.add(map);
        });
        return records;
    }

    @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 = buildTableData(insuranceArchivesEmployeePOS);
        List<WeaTableColumn> columns = buildWeaTableColumns(insuranceArchivesEmployeePOS, (long) user.getUID());

        //工作簿list


        String sheetName;
        //表头
        if (param.getRunStatuses().size() > 0) {
            if (param.getRunStatuses().contains(EmployeeStatusEnum.STAY_ADD.getValue()) && param.getRunStatuses().size() == 1) {
                sheetName = SalaryI18nUtil.getI18nLabel(85368, "社保福利档案导出" + "-" + EmployeeStatusEnum.STAY_ADD.getDefaultLabel());
            } else if (param.getRunStatuses().contains(EmployeeStatusEnum.PAYING.getValue()) && param.getRunStatuses().contains(EmployeeStatusEnum.STAY_DEL.getValue()) && param.getRunStatuses().size() == 2) {
                sheetName = SalaryI18nUtil.getI18nLabel(85368, "社保福利档案导出" + "-" + "在缴员工");
            } else if (param.getRunStatuses().contains(EmployeeStatusEnum.STAY_DEL.getValue()) && param.getRunStatuses().size() == 1) {
                sheetName = SalaryI18nUtil.getI18nLabel(85368, "社保福利档案导出" + "-" + EmployeeStatusEnum.STAY_DEL.getDefaultLabel());
            } else if (param.getRunStatuses().contains(EmployeeStatusEnum.STOP_PAYMENT_FROM_ADD.getValue()) && param.getRunStatuses().contains(EmployeeStatusEnum.STOP_PAYMENT_FROM_DEL.getValue()) && param.getRunStatuses().size() == 2) {
                sheetName = SalaryI18nUtil.getI18nLabel(85368, "社保福利档案导出" + "-" + "停缴员工");
            } else {
                sheetName = SalaryI18nUtil.getI18nLabel(85368, "社保福利档案导出");
            }
        } else {
            sheetName = SalaryI18nUtil.getI18nLabel(85368, "社保福利档案导出");
        }

        //工作簿数据
        List<List<String>> rows = new LinkedList<>();
        List<String> collect = columns.stream().map(WeaTableColumn::getText).collect(Collectors.toList());
        rows.add(collect);
        for (Map<String, Object> recordData : records) {
            List<String> row = new LinkedList<>();
            for (WeaTableColumn column : columns) {
                try {
                    Object o = recordData.get(column.getColumn());
                    row.add(o.toString());
                } catch (Exception e) {
                    row.add("");
                }
            }
            rows.add(row);
        }
//        return salaryBatchService.simpleExportExcel(ExportExcelInfo.builder()
//                .bizId(exportMap.get("biz"))
//                .flag(true)
//                .userId(employeeId)
//                .eteamsId(eteamsId)
//                .tenantKey(tenantKey)
//                .operator(operator)
//                .module(exportMap.get("module"))
//                .fileName(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 94629, "社保福利档案") + SalaryDateUtil.getFormatLocalDateTime(LocalDateTime.now()))
//                .handlerName("insuranceArchivesExportHandler")
//                .dataType(SalaryI18nUtil.getI18nLabel(tenantKey, employeeId, 99915, "档案"))
//                .function(exportMap.get("function")).build(), sheetList);
        //获取excel
        return ExcelUtil.genWorkbook(rows, sheetName);
    }


    public PaymentTypeEnum buildPaymentTypeEnum(Integer value) {
        return SalaryEnumUtil.enumMatchByValue(value, PaymentTypeEnum.values(), PaymentTypeEnum.class);
    }


    /**
     * 组装社保福利方案列表页【缴纳范围】
     * 1、到福利方案明细表查询该方案id下面有哪些福利
     * 2、去重（福利是分个人和公司的，明细表中查询出来的福利id会重复）
     * 3、根据查询出来的福利id，去福利表里面查询福利的名称
     * 4、组装，以“、”分割
     *
     * @param id 福利方案主表id
     * @return result
     */
    public String buildPaymentScope(Long id) {
        List<String> collect = queryInsuranceSchemeDetailList(id).stream().map(InsuranceSchemeDetailPO::getInsuranceId).distinct().collect(Collectors.toList()).stream().map(this::queryInsuranceName).collect(Collectors.toList());
        return StringUtils.join(collect, "、");
    }

    public Collection<InsuranceSchemeDetailPO> queryInsuranceSchemeDetailList(Long id) {
        List<InsuranceSchemeDetailPO> insuranceSchemeDetailPOS = getInsuranceSchemeDetailMapper().queryInsuranceSchemeDetailList(id, IsPaymentEnum.YES.getValue());
        return encryptUtil.decryptList(insuranceSchemeDetailPOS, InsuranceSchemeDetailPO.class);
    }

    public String queryInsuranceName(Long id) {
        ICategoryPO insuranceCategoryPO = getICategoryMapper().getById(id);
        return insuranceCategoryPO == null ? "" : Objects.isNull(insuranceCategoryPO.getInsuranceName()) ? "" : insuranceCategoryPO.getInsuranceName();
    }


    @Override
    public String querySchemeName(Long schemeId) {
        if (schemeId == null) {
            return "";
        }
        InsuranceSchemePO insuranceSchemePO = getInsuranceSchemeMapper().getById(schemeId);
        if (insuranceSchemePO == null) {
            return "";
        } else {
            return insuranceSchemePO.getSchemeName();
        }
    }


    @Override
    public List<WeaTableColumn> buildWeaTableColumns(List<InsuranceArchivesEmployeePO> insuranceArchivesEmployeePOS, Long employeeId) {
        Map<Integer, Map<String, String>> titleMap = buildColumnTitle(insuranceArchivesEmployeePOS, employeeId);
        List<WeaTableColumn> list = new ArrayList<>();
        WeaTableColumn nameColumn = new WeaTableColumn("100px", SalaryI18nUtil.getI18nLabel(85429, "姓名"), "employeeName");
        nameColumn.setFixed("left");
        list.add(nameColumn);
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(93910, "个税扣缴义务人"), "paymentOrganizationName"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(0, "分部"), "subcompanyName"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(86185, "部门"), "departmentName"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(86186, "手机号"), "mobile"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(86187, "员工状态"), "status"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(1933, "工号"), "jobNum"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91323, "社保方案名称"), "socialName"));
        titleMap.get(WelfareTypeEnum.SOCIAL_SECURITY.getValue()).forEach((k, v) -> list.add(new WeaTableColumn("150px", v, k)));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91324, "社保账号"), "socialAccount"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91319, "社保起始缴纳月"), "socialStartTime"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91320, "社保最后缴纳月"), "socialEndTime"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称"), "fundName"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91486, "公积金账号"), "fundAccount"));
        titleMap.get(WelfareTypeEnum.ACCUMULATION_FUND.getValue()).forEach((k, v) -> list.add(new WeaTableColumn("150px", v, k)));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91487, "补充公积金账号"), "supplementFundAccount"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91483, "公积金起始缴纳月"), "fundStartTime"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91484, "公积金最后缴纳月"), "fundEndTime"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称"), "otherName"));
        titleMap.get(WelfareTypeEnum.OTHER.getValue()).forEach((k, v) -> list.add(new WeaTableColumn("150px", v, k)));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91490, "其他福利起始缴纳月"), "otherStartTime"));
        list.add(new WeaTableColumn("150px", SalaryI18nUtil.getI18nLabel(91494, "其他福利最后缴纳月"), "otherEndTime"));
        return list;
    }


    public Map<Integer, Map<String, String>> buildColumnTitle(List<InsuranceArchivesEmployeePO> insuranceArchivesEmployeePOS, Long employeeId) {
        Map<Integer, Map<String, String>> result = new HashMap<>();
        Set<String> socialSet = new HashSet<>();
        Set<String> fundSet = new HashSet<>();
        Set<String> otherSet = new HashSet<>();
        insuranceArchivesEmployeePOS.forEach(item -> {
            List<InsuranceArchivesSocialSchemePO> socialByEmployeeId = siArchivesBiz.getSocialByEmployeeIds(new ArrayList<Long>() {{
                add(item.getEmployeeId());
            }});
            encryptUtil.decryptList(socialByEmployeeId, InsuranceArchivesSocialSchemePO.class);
            InsuranceArchivesSocialSchemePO socialItem = null;
            if (socialByEmployeeId.size() > 0) {
                socialItem = socialByEmployeeId.get(0);
            }
            InsuranceArchivesFundSchemePO fundItem = null;

            List<InsuranceArchivesFundSchemePO> fundByEmployeeId = siArchivesBiz.getFundByEmployeeIds(new ArrayList<Long>() {{
                add(item.getEmployeeId());
            }});
            encryptUtil.decryptList(fundByEmployeeId, InsuranceArchivesFundSchemePO.class);

            if (fundByEmployeeId.size() > 0) {
                fundItem = fundByEmployeeId.get(0);
            }
            InsuranceArchivesOtherSchemePO otherItem = null;

            List<InsuranceArchivesOtherSchemePO> otherByEmployeeId = siArchivesBiz.getOtherByEmployeeIds(new ArrayList<Long>() {{
                add(item.getEmployeeId());
            }});
            encryptUtil.decryptList(otherByEmployeeId, InsuranceArchivesOtherSchemePO.class);
            if (otherByEmployeeId.size() > 0) {
                otherItem = otherByEmployeeId.get(0);
            }

            if (socialItem != null) {
                Map<String, Object> socialJson = JSON.parseObject(socialItem.getSocialPaymentBaseString(), new TypeReference<Map<String, Object>>() {
                });
                if (socialJson != null) {
                    socialJson.forEach((k, v) -> socialSet.add(k));
                }
            }
            if (fundItem != null) {
                Map<String, Object> fundJson = JSON.parseObject(fundItem.getFundPaymentBaseString(), new TypeReference<Map<String, Object>>() {
                });
                if (fundJson != null) {
                    fundJson.forEach((k, v) -> fundSet.add(k));
                }
            }
            if (otherItem != null) {
                Map<String, Object> otherJson = JSON.parseObject(otherItem.getOtherPaymentBaseString(), new TypeReference<Map<String, Object>>() {
                });
                if (otherJson != null) {
                    otherJson.forEach((k, v) -> otherSet.add(k));
                }
            }
        });
        Map<String, String> socialMap = new HashMap<>();
        Map<Long, ICategoryPO> socialCollect = new HashMap<>();
        Map<Long, ICategoryPO> customSocial = getICategoryMapper().listByWelfareType(WelfareTypeEnum.SOCIAL_SECURITY.getValue(), null).stream().collect(Collectors.toMap(ICategoryPO::getId, Function.identity()));

        Map<Long, ICategoryPO> sysSocial = getICategoryMapper().listByWelfareType(WelfareTypeEnum.SOCIAL_SECURITY.getValue(), DataTypeEnum.SYSTEM.getValue()).stream().collect(Collectors.toMap(ICategoryPO::getId, Function.identity()));
        socialCollect.putAll(customSocial);
        socialCollect.putAll(sysSocial);
        socialSet.forEach(item -> {
            if (socialCollect.containsKey(Long.valueOf(item))) {
                socialMap.put(item, socialCollect.get(Long.valueOf(item)).getInsuranceName() + SalaryI18nUtil.getI18nLabel(100293, "申报基数"));
            }
        });
        Map<String, String> fundMap = new HashMap<>();
        Map<Long, ICategoryPO> fundCollect = new HashMap<>();
        Map<Long, ICategoryPO> customFund = getICategoryMapper().listByWelfareType(WelfareTypeEnum.ACCUMULATION_FUND.getValue(), null).stream().collect(Collectors.toMap(ICategoryPO::getId, Function.identity()));
        Map<Long, ICategoryPO> sysFund = getICategoryMapper().listByWelfareType(WelfareTypeEnum.ACCUMULATION_FUND.getValue(), DataTypeEnum.SYSTEM.getValue()).stream().collect(Collectors.toMap(ICategoryPO::getId, Function.identity()));
        fundCollect.putAll(customFund);
        fundCollect.putAll(sysFund);
        fundSet.forEach(item -> {
            if (fundCollect.containsKey(Long.valueOf(item))) {
                fundMap.put(item, fundCollect.get(Long.valueOf(item)).getInsuranceName() + SalaryI18nUtil.getI18nLabel(100293, "申报基数"));
            }
        });
        Map<String, String> otherMap = new HashMap<>();
        Map<Long, ICategoryPO> otherCollect = new HashMap<>();
        Map<Long, ICategoryPO> customOther = getICategoryMapper().listByWelfareType(WelfareTypeEnum.OTHER.getValue(), null).stream().collect(Collectors.toMap(ICategoryPO::getId, Function.identity()));
        Map<Long, ICategoryPO> sysOther = getICategoryMapper().listByWelfareType(WelfareTypeEnum.OTHER.getValue(), DataTypeEnum.SYSTEM.getValue()).stream().collect(Collectors.toMap(ICategoryPO::getId, Function.identity()));
        otherCollect.putAll(customOther);
        otherCollect.putAll(sysOther);
        otherSet.forEach(item -> {
            if (otherCollect.containsKey(Long.valueOf(item))) {
                otherMap.put(item, otherCollect.get(Long.valueOf(item)).getInsuranceName() + SalaryI18nUtil.getI18nLabel(100293, "申报基数"));
            }
        });

        // map根据key排序
        LinkedHashMap<String, String> socialMapWithAscKey = socialMap.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue,
                        LinkedHashMap::new));
        LinkedHashMap<String, String> fundMapWithAscKey = fundMap.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue,
                        LinkedHashMap::new));
        LinkedHashMap<String, String> otherMapWithAscKey = otherMap.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue,
                        LinkedHashMap::new));

        result.put(WelfareTypeEnum.SOCIAL_SECURITY.getValue(), socialMapWithAscKey);
        result.put(WelfareTypeEnum.ACCUMULATION_FUND.getValue(), fundMapWithAscKey);
        result.put(WelfareTypeEnum.OTHER.getValue(), otherMapWithAscKey);
        return result;
    }

    /**
     * 导入的数据插入到数据库中
     */
    @Override
    public Map<String, Object> preview(SIArchiveImportParam param) {
        ValidUtil.doValidator(param);
        InputStream fileInputStream = null;
        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(param.getImageId()));
            Sheet sheet = ExcelSupport.parseFile(fileInputStream, 0, EXCEL_TYPE_XLSX);
            Map<String, Object> apidatas = new HashMap<String, Object>();
            apidatas.put("headers", ExcelSupport.getSheetHeader(sheet, 0));
            apidatas.put("list", ExcelParseHelper.parse2List(sheet, 1));
            return apidatas;
        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }
    }

    /**
     * 导入的数据插入到数据库中
     */
    public Map<String, Object> batchImportEbatch(SIArchiveImportParam param) {
        ValidUtil.doValidator(param);
        param.setProcess(false);

        if (StringUtils.isBlank(param.getRunStatus())) {
            throw new SalaryRunTimeException("福利档案执行状态未在导入条件设置中添加！");
        }
//        List<ExcelSheet> excelSheets = message.getBatchFile().getExcelSheets();
        // 租户key
//        String tenantKey = message.getTenantKey().toLowerCase();EditSIArchiveAction
        //操作员id
        Long creator = (long) user.getUID();
        //获取所有福利类型的id-name结合
        Map<String, Long> schemeNameIdMap = schemeNameIdMap();
        Map<Long, String> welfareMap = welfareMap();
        // 获取所有个税扣缴义务人的名称和id的map
        Map<String, Long> paymentNameIdMap;
        //分权
        Boolean openDevolution = getTaxAgentService().isOpenDevolution();
        if (openDevolution) {
            paymentNameIdMap = getTaxAgentService().listAllTaxAgentsAsAdmin((long) user.getUID()).stream().collect(Collectors.toMap(TaxAgentPO::getName, TaxAgentPO::getId));
        } else {
            paymentNameIdMap = getTaxAgentService().listAll().stream().collect(Collectors.toMap(TaxAgentPO::getName, TaxAgentPO::getId));
        }

        //获取所以个税扣缴义务人树型
        List<TaxAgentManageRangeEmployeeDTO> taxAgentManageRangeEmployeeTree = getTaxAgentService().listTaxAgentAndEmployeeTree();

        // 获取所有人员信息
        List<DataCollectionEmployee> employeeByIds = getSalaryEmployeeService(user).listEmployee();
        int total = 0;

        int index = 0;
        int successCount = 0;
        int errorCount = 0;

        // 待导入数据
        List<InsuranceArchivesAccountPO> insuranceArchivesAccountPOS = new ArrayList<>();

        // 待导入数据
        InputStream fileInputStream = null;
        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(param.getImageId()));
            Sheet sheet = ExcelSupport.parseFile(fileInputStream, 0, EXCEL_TYPE_XLSX);
            // 表头
            List<String> headers = ExcelSupport.getSheetHeader(sheet, 0);
            // 错误sheet数据
            List<Map<String, Object>> errorData = new LinkedList<>();
            // 错误提示
            List<Map<String, String>> excelComments = new LinkedList<>();

            // 处理数值
            List<Map<String, Object>> data = ExcelParseHelper.parse2Map(sheet, 1);
            total = data.size();

            //当前sheel的单行记录
            Map<String, Object> map;
            for (int i = 0; i < data.size(); i++) {
                index += 1;
                map = data.get(i);
                boolean isError;
                List<Map<String, Object>> singleAccount = new ArrayList<>();
                for (int j = 0; j < headers.size(); j++) {
                    //组装单条数据基础数据
                    String key = headers.get(j);
                    if (key == null) {
                        continue;
                    }
                    Map<String, Object> cellData = new HashMap<>();
                    cellData.put(key.toString(), Optional.ofNullable(map.get(key.toString())).orElse("").toString());
                    cellData.put("index", j);
                    singleAccount.add(cellData);
                }

                isError = singleAccountCheck(singleAccount, welfareMap, insuranceArchivesAccountPOS, employeeByIds, excelComments, errorCount + 1, schemeNameIdMap, paymentNameIdMap, creator, i + 2, openDevolution, taxAgentManageRangeEmployeeTree, param);
                if (isError) {
                    errorCount += 1;
                    // 添加错误数据
                    errorData.add(map);
                } else {
                    successCount += 1;
                }
//                salaryBatchService.sendImportRate(message.getBizId(), total, index);
            }

            // 如果sheet包含错误数据
//            if (CollectionUtils.isNotEmpty(errorData)) {
//                salaryBatchService.createErrorExcelSheet(headers, errorData, excelSheet.getName(), excelComments, errorExcelSheets);
//            }

            // 数据入库处理
            handleImportData(insuranceArchivesAccountPOS, param);

            // 发送导入回调信息
//        salaryBatchService.sendImportCallBackInfo(message, successCount, errorCount, errorExcelSheets);

            Map<String, Object> apidatas = new HashMap<String, Object>();
            apidatas.put("successCount", successCount);
            apidatas.put("errorCount", errorCount);
            apidatas.put("errorData", excelComments);
            return apidatas;
        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }
    }


    public Map<String, Long> schemeNameIdMap() {
        Map<String, Long> schemeMap = new HashMap<>();
        List<InsuranceSchemePO> schemeList = getInsuranceSchemeMapper().listAll();
        if (CollectionUtils.isNotEmpty(schemeList)) {
            schemeMap = schemeList.stream().collect(Collectors.toMap(InsuranceSchemePO::getSchemeName, InsuranceSchemePO::getId));
        }
        return schemeMap;
    }

    public Map<Long, String> welfareMap() {
        return getICategoryMapper().listAll().stream().collect(Collectors.toMap(ICategoryPO::getId, ICategoryPO::getInsuranceName));
    }

    private String userStateExchange(String userState) {
        UserStatusEnum[] values = UserStatusEnum.values();
        for (UserStatusEnum value : values) {
            if (value.getValue().equals(Integer.valueOf(userState))) {
                return value.getDefaultLabel() + "";
            }
        }
        return userState;
    }

    public boolean singleAccountCheck(List<Map<String, Object>> singleAccount, Map<Long, String> welfareMap,
                                      List<InsuranceArchivesAccountPO> insuranceArchivesAccountPOS, List<DataCollectionEmployee> employeeByIds,
                                      List<Map<String, String>> excelComments, int i, Map<String, Long> schemeNameIdMap,
                                      Map<String, Long> paymentNameIdMap, Long creator, int index, Boolean openDevolution,
                                      List<TaxAgentManageRangeEmployeeDTO> taxAgentManageRangeEmployeeTree, SIArchiveImportParam param) {
        boolean isError = false;
        String runStatus = param.getRunStatus();

//        String userName = (String) singleAccount.get(0).get(SalaryI18nUtil.getI18nLabel(85429, "姓名"));
//        String deparmentName = (String) singleAccount.get(1).get(SalaryI18nUtil.getI18nLabel(86185, "部门"));
//        String mobile = (String) singleAccount.get(2).get(SalaryI18nUtil.getI18nLabel(86186, "手机号"));
//        String userStatus = (String) singleAccount.get(3).get(SalaryI18nUtil.getI18nLabel(86187, "员工状态"));
//        String workcode = (String) singleAccount.get(4).get(SalaryI18nUtil.getI18nLabel(86317, "工号"));

        Map<String, Object> userNameMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(85429, "姓名"));
        Map<String, Object> deparmentNameMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(86185, "部门"));
        Map<String, Object> mobileMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(86186, "手机号"));
        Map<String, Object> userStatusMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(86187, "员工状态"));
        Map<String, Object> workcodeMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(86317, "工号"));
        Map<String, Object> employeeIdMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(86187, "员工id"));


        String userName = (String) userNameMap.get(SalaryI18nUtil.getI18nLabel(85429, "姓名"));
        String deparmentName = (String) deparmentNameMap.get(SalaryI18nUtil.getI18nLabel(86185, "部门"));
        String mobile = (String) mobileMap.get(SalaryI18nUtil.getI18nLabel(86186, "手机号"));
        String userStatus = (String) userStatusMap.get(SalaryI18nUtil.getI18nLabel(86187, "员工状态"));
        String workcode = (String) workcodeMap.get(SalaryI18nUtil.getI18nLabel(86317, "工号"));
        String toAddEmployeeId;
        if (employeeIdMap.isEmpty()) {
            toAddEmployeeId = null;
        } else {
            toAddEmployeeId = employeeIdMap.get(SalaryI18nUtil.getI18nLabel(86187, "员工id")).toString();
        }

        Long addEmployeeId = StringUtils.isNotBlank(toAddEmployeeId) ? Long.valueOf(toAddEmployeeId) : null;

        //查询对于人员信息导入筛选的全局配置
        SalarySysConfPO salarySysConfPO = getSalarySysConfMapper().getOneByCode("matchEmployeeMode");
        String confValue = (salarySysConfPO != null && salarySysConfPO.getConfValue() != null && !"".equals(salarySysConfPO.getConfValue())) ? salarySysConfPO.getConfValue() : "0";

        String rowIndex = "第" + index + "行";
        List<DataCollectionEmployee> employees = new ArrayList<>();
        //当新增数据中包含员工id信息时，直接根据员工id获取员工信息
        if (addEmployeeId == null) {
            //仅在全局人员筛选配置为“0”时，才对用户名、部门名称、手机号有要求
            if (StringUtils.isBlank(userName) && StringUtils.isBlank(deparmentName) && StringUtils.isBlank(mobile) && "0".equals(confValue)) {
                Map<String, String> errorMessageMap = Maps.newHashMap();
                errorMessageMap.put("message", rowIndex + " 用户名、部门名称、手机号" + SalaryI18nUtil.getI18nLabel(100303, "不能同时为空"));
                excelComments.add(errorMessageMap);
                isError = true;
            }
            //筛选导入人员信息可以在人力资源池中匹配到的人员信息
            employees = getSalaryEmployeeService(user).matchImportEmployee(employeeByIds, userName, deparmentName, mobile, workcode, null);
        } else {
            employees = employeeByIds.stream().filter(f -> f.getEmployeeId().equals(addEmployeeId)).collect(Collectors.toList());
        }


        if (CollectionUtils.isEmpty(employees)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + "员工信息不存在");
            excelComments.add(errorMessageMap);
            isError = true;
            return isError;
        } else {
            //含在职和离职，选在职数据
            if (employees.size() > 1) {
                employees = employees.stream()
                        .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                        .collect(Collectors.toList());
                if (employees.size() != 1) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100304, "员工信息不存在或者存在多个员工"));
                    excelComments.add(errorMessageMap);
                    isError = true;
                    return isError;
                }
            }
        }

        Long employeeId = employees.get(0).getEmployeeId();
        InsuranceArchivesAccountPO insuranceArchivesAccountPO = new InsuranceArchivesAccountPO();
        InsuranceArchivesSocialSchemePO insuranceArchivesSocialSchemePO = null;
        InsuranceArchivesFundSchemePO insuranceArchivesFundSchemePO = null;
        InsuranceArchivesOtherSchemePO insuranceArchivesOtherSchemePO = null;

        Map<String, Object> socialMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91323, "社保方案名称"));
        Map<String, Object> paymentMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(86184, "个税扣缴义务人"));
        Map<String, Object> fundMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称"));
        Map<String, Object> otherMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称"));
        Map<String, Object> socialStartTimeMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91319, "社保起始缴纳月"));
        Map<String, Object> socialEndTimeMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91320, "社保最后缴纳月"));
        Map<String, Object> fundStartTimeMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91483, "公积金起始缴纳月"));
        Map<String, Object> fundEndTimeMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91484, "公积金最后缴纳月"));
        Map<String, Object> otherStartTimeMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91490, "其他福利起始缴纳月"));
        Map<String, Object> otherEndTimeMap = findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91494, "其他福利最后缴纳月"));
        if (StringUtils.isBlank((String) socialMap.get(SalaryI18nUtil.getI18nLabel(91323, "社保方案名称"))) && StringUtils.isBlank((String) fundMap.get(SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称"))) && StringUtils.isBlank((String) otherMap.get(SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称")))) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100312, "社保,公积金,其他福利方案名称不可同时为空"));
            excelComments.add(errorMessageMap);
            isError = true;
        }

        //根据导入接口附带的runStatus来区分待增员导入和正在缴纳导入
        if (StringUtils.isNotBlank(runStatus) && runStatus.equals(EmployeeStatusEnum.PAYING.getValue())) {
            if (StringUtils.isBlank((String) socialStartTimeMap.get(SalaryI18nUtil.getI18nLabel(91319, "社保起始缴纳月")))
                    && StringUtils.isBlank((String) fundStartTimeMap.get(SalaryI18nUtil.getI18nLabel(91483, "公积金起始缴纳月")))
                    && StringUtils.isBlank((String) otherStartTimeMap.get(SalaryI18nUtil.getI18nLabel(91490, "其他福利起始缴纳月")))
            ) {
                Map<String, String> errorMessageMap = Maps.newHashMap();
                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100312, "社保,公积金,其他福利方案起始缴纳月不可同时为空"));
                excelComments.add(errorMessageMap);
                isError = true;
            }
        }
        //社保缴纳组织=个税扣缴义务人
        String paymentOrg = (String) paymentMap.get("个税扣缴义务人");
        if (StringUtils.isBlank(paymentOrg)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100579, "个税扣缴义务人不允许为空"));
            excelComments.add(errorMessageMap);
            isError = true;
        } else if (!paymentNameIdMap.containsKey(paymentOrg)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100312, "社保缴纳组织应和个税扣缴义务人名称一致，社保缴纳组织不存在或不在权限范围内"));
            excelComments.add(errorMessageMap);
            isError = true;
        }

        if (!isError) {
            Long paymentOrgId = paymentNameIdMap.get(paymentOrg);
            TaxAgentManageRangeEmployeeDTO taxAgentManageRangeEmployeeDTO = taxAgentManageRangeEmployeeTree.stream().filter(tax -> tax.getTaxAgentId().equals(paymentOrgId)).findFirst().get();
            Optional<Long> o = taxAgentManageRangeEmployeeDTO.getEmployeeList().stream().map(TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee::getEmployeeId).filter(e -> e.equals(employeeId)).findFirst();
            if (!o.isPresent()) {
                if (param.isProcess()) {
                    //流程中自动将人员添加进个税扣缴义务人中
                    TaxAgentManageRangeSaveParam.TaxAgentSubAdminRangeTargetParam taxAgentSubAdminRangeTargetParam = new TaxAgentManageRangeSaveParam.TaxAgentSubAdminRangeTargetParam();
                    taxAgentSubAdminRangeTargetParam.setTargetId(employeeId);
                    taxAgentSubAdminRangeTargetParam.setTargetType(TargetTypeEnum.EMPLOYEE);

                    TaxAgentRangeSaveParam taxAgentRangeSaveParam = new TaxAgentRangeSaveParam();
                    taxAgentRangeSaveParam.setTaxAgentId(paymentOrgId);
                    taxAgentRangeSaveParam.setIncludeType(1);
                    taxAgentRangeSaveParam.setEmployeeStatus(Arrays.asList("0", "1", "2", "3", "4", "5", "6"));
                    taxAgentRangeSaveParam.setTargetParams(Collections.singletonList(taxAgentSubAdminRangeTargetParam));
                    taxAgentRangeSaveParam.setSync(true);
                    param.setTaxAgentRanges(Collections.singletonList(taxAgentRangeSaveParam));
                } else {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100312, "该条数据不在个税扣缴义务人人员范围内，不可导入"));
                    excelComments.add(errorMessageMap);
                    isError = true;
                }

            }

        }


        String socialStartMonth = (String) socialStartTimeMap.get(SalaryI18nUtil.getI18nLabel(91319, "社保起始缴纳月"));
        if (StringUtils.isNotBlank(socialStartMonth) && socialStartMonth.length() > 7) {
            socialStartMonth = socialStartMonth.substring(0, 7);
        }
        if (StringUtils.isNotBlank(socialStartMonth) && !SalaryDateUtil.checkYearMonth(socialStartMonth)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100315, "社保起始缴纳时间格式错误,正确格式为YYYY-MM或者yyyy-MM-dd"));
            excelComments.add(errorMessageMap);
            isError = true;
        }

        String socialEndMonth = (String) socialEndTimeMap.get(SalaryI18nUtil.getI18nLabel(91320, "社保最后缴纳月"));
        if (StringUtils.isNotBlank(socialEndMonth) && socialEndMonth.length() > 7) {
            socialEndMonth = socialEndMonth.substring(0, 7);
        }
        if (StringUtils.isNotBlank(socialEndMonth) && !SalaryDateUtil.checkYearMonth(socialEndMonth)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100316, "社保最后缴纳时间格式错误,正确格式为YYYY-MM或者yyyy-MM-dd"));
            excelComments.add(errorMessageMap);
            isError = true;
        }

        String fundStartMonth = (String) fundStartTimeMap.get(SalaryI18nUtil.getI18nLabel(91483, "公积金起始缴纳月"));
        if (StringUtils.isNotBlank(fundStartMonth) && fundStartMonth.length() > 7) {
            fundStartMonth = fundStartMonth.substring(0, 7);
        }
        if (StringUtils.isNotBlank(fundStartMonth) && !SalaryDateUtil.checkYearMonth(fundStartMonth)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100317, "公积金起始缴纳时间格式错误,正确格式为YYYY-MM或者yyyy-MM-dd"));
            excelComments.add(errorMessageMap);
            isError = true;
        }

        String fundEndMonth = (String) fundEndTimeMap.get(SalaryI18nUtil.getI18nLabel(91484, "公积金最后缴纳月"));
        if (StringUtils.isNotBlank(fundEndMonth) && fundEndMonth.length() > 7) {
            fundEndMonth = fundEndMonth.substring(0, 7);
        }
        if (StringUtils.isNotBlank(fundEndMonth) && !SalaryDateUtil.checkYearMonth(fundEndMonth)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100319, "公积金最后缴纳时间格式错误,正确格式为YYYY-MM或者yyyy-MM-dd"));
            excelComments.add(errorMessageMap);
            isError = true;
        }

        String otherStartMonth = (String) otherStartTimeMap.get(SalaryI18nUtil.getI18nLabel(91490, "其他福利起始缴纳月"));
        if (StringUtils.isNotBlank(otherStartMonth) && otherStartMonth.length() > 7) {
            otherStartMonth = otherStartMonth.substring(0, 7);
        }
        if (StringUtils.isNotBlank(otherStartMonth) && !SalaryDateUtil.checkYearMonth(otherStartMonth)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100320, "其他福利起始缴纳时间格式错误,正确格式为YYYY-MM或者yyyy-MM-dd"));
            excelComments.add(errorMessageMap);
            isError = true;
        }

        String otherEndMonth = (String) otherEndTimeMap.get(SalaryI18nUtil.getI18nLabel(91494, "其他福利最后缴纳月"));
        if (StringUtils.isNotBlank(otherEndMonth) && otherEndMonth.length() > 7) {
            otherEndMonth = otherEndMonth.substring(0, 7);
        }
        if (StringUtils.isNotBlank(otherEndMonth) && !SalaryDateUtil.checkYearMonth(otherEndMonth)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100321, "其他福利最后缴纳时间格式错误,正确格式为YYYY-MM或者yyyy-MM-dd"));
            excelComments.add(errorMessageMap);
            isError = true;
        }
        if (StringUtils.isNotBlank((String) socialMap.get(SalaryI18nUtil.getI18nLabel(91323, "社保方案名称"))) && schemeNameIdMap.get((String) socialMap.get(SalaryI18nUtil.getI18nLabel(91323, "社保方案名称"))) == null) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100322, "社保方案不存在"));
            excelComments.add(errorMessageMap);
            isError = true;
        } else if (StringUtils.isNotBlank((String) socialMap.get(SalaryI18nUtil.getI18nLabel(91323, "社保方案名称")))
                && schemeNameIdMap.get((String) socialMap.get(SalaryI18nUtil.getI18nLabel(91323, "社保方案名称"))) != null
                && !getInsuranceSchemeMapper().getById(schemeNameIdMap.get((String) socialMap.get(SalaryI18nUtil.getI18nLabel(91323, "社保方案名称")))).getWelfareType().equals(WelfareTypeEnum.SOCIAL_SECURITY.getValue())) {

            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100322, "社保方案不属于社保福利类型"));
            excelComments.add(errorMessageMap);
            isError = true;

        } else if (StringUtils.isNotBlank((String) socialMap.get(SalaryI18nUtil.getI18nLabel(91323, "社保方案名称"))) && StringUtils.isBlank(socialStartMonth)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100322, "社保方案已设置，但未设置社保起始缴纳时间！"));
            excelComments.add(errorMessageMap);
            isError = true;
        } else {
            insuranceArchivesSocialSchemePO = buildSocialPO(employeeId, welfareMap, singleAccount, schemeNameIdMap, paymentNameIdMap, creator);
        }
        if (StringUtils.isNotBlank((String) fundMap.get(SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称"))) && schemeNameIdMap.get((String) fundMap.get(SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称"))) == null) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100323, "公积金方案不存在"));
            excelComments.add(errorMessageMap);
            isError = true;
        } else if (StringUtils.isNotBlank((String) fundMap.get(SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称")))
                && schemeNameIdMap.get((String) fundMap.get(SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称"))) != null
                && !getInsuranceSchemeMapper().getById(schemeNameIdMap.get((String) fundMap.get(SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称")))).getWelfareType().equals(WelfareTypeEnum.ACCUMULATION_FUND.getValue())) {

            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100322, "公积金方案不属于公积金福利类型"));
            excelComments.add(errorMessageMap);
            isError = true;

        } else if (StringUtils.isNotBlank((String) fundMap.get(SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称"))) && StringUtils.isBlank(fundStartMonth)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100322, "公积金方案已设置，但未设置公积金起始缴纳时间！"));
            excelComments.add(errorMessageMap);
            isError = true;
        } else {
            insuranceArchivesFundSchemePO = buildFundPO(employeeId, welfareMap, singleAccount, schemeNameIdMap, paymentNameIdMap, creator);
        }
        if (StringUtils.isNotBlank((String) otherMap.get(SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称"))) && schemeNameIdMap.get((String) otherMap.get(SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称"))) == null) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100324, "其他福利方案不存在"));
            excelComments.add(errorMessageMap);
            isError = true;
        } else if (StringUtils.isNotBlank((String) otherMap.get(SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称")))
                && schemeNameIdMap.get((String) otherMap.get(SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称"))) != null
                && !getInsuranceSchemeMapper().getById(schemeNameIdMap.get((String) otherMap.get(SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称")))).getWelfareType().equals(WelfareTypeEnum.OTHER.getValue())) {

            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100322, "其他福利方案不属于其他福利类型"));
            excelComments.add(errorMessageMap);
            isError = true;
        } else if (StringUtils.isNotBlank((String) otherMap.get(SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称"))) && StringUtils.isBlank(otherStartMonth)) {
            Map<String, String> errorMessageMap = Maps.newHashMap();
            errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100322, "其他福利方案已设置，但未设置其他福利起始缴纳时间！"));
            excelComments.add(errorMessageMap);
            isError = true;
        } else {
            insuranceArchivesOtherSchemePO = buildOtherPO(employeeId, welfareMap, singleAccount, schemeNameIdMap, paymentNameIdMap, creator);
        }
        /**************校验申报基数**************/
        for (Map.Entry<Long, String> entry : welfareMap.entrySet()) {
            String keyName = entry.getValue() + SalaryI18nUtil.getI18nLabel(100293, "申报基数");
            String numberVlue = findElement(singleAccount, keyName).get(keyName) == null ? "" : findElement(singleAccount, keyName).get(keyName).toString();
            if (!"".equals(numberVlue) && !NumberUtils.isParsable(numberVlue)) {
                Map<String, String> errorMessageMap = Maps.newHashMap();
                errorMessageMap.put("message", rowIndex + keyName + SalaryI18nUtil.getI18nLabel(100581, "请输入数字"));
                excelComments.add(errorMessageMap);
                isError = true;
            }
        }
        //生成福利档案基础信息数据
        InsuranceArchivesBaseInfoPO insuranceArchivesBaseInfoPO = buildBaseInfoPO(employeeId, singleAccount, paymentNameIdMap, creator, runStatus, employees.get(0).isExtEmp());
        if (!isError) {
            insuranceArchivesAccountPO.setSocial(insuranceArchivesSocialSchemePO);
            insuranceArchivesAccountPO.setFund(insuranceArchivesFundSchemePO);
            insuranceArchivesAccountPO.setOther(insuranceArchivesOtherSchemePO);
            insuranceArchivesAccountPO.setBaseInfo(insuranceArchivesBaseInfoPO);
            //校验福利基数是否符合上下限要求，
            Boolean socialCheckBase = siArchivesBiz.checkWelBaseLimit(insuranceArchivesSocialSchemePO.getSocialSchemeId(), insuranceArchivesSocialSchemePO.getSocialPaymentBaseString());

            Boolean fundCheckBase = siArchivesBiz.checkWelBaseLimit(insuranceArchivesFundSchemePO.getFundSchemeId(), insuranceArchivesFundSchemePO.getFundPaymentBaseString());

            Boolean otherCheckBase = siArchivesBiz.checkWelBaseLimit(insuranceArchivesOtherSchemePO.getOtherSchemeId(), insuranceArchivesOtherSchemePO.getOtherPaymentBaseString());

            if (socialCheckBase && fundCheckBase && otherCheckBase) {
                insuranceArchivesAccountPOS.add(insuranceArchivesAccountPO);
            } else {
                String checkMessage = "该条数据中";
                if (!socialCheckBase) {
                    checkMessage = checkMessage + "社保福利基数、";
                }
                if (!fundCheckBase) {
                    checkMessage = checkMessage + "公积金福利基数、";
                }
                if (!otherCheckBase) {
                    checkMessage = checkMessage + "其他福利基数、";
                }
                checkMessage = checkMessage.substring(0, checkMessage.length() - 1);

                Map<String, String> errorMessageMap = Maps.newHashMap();
                errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(100312, checkMessage + "数值超出相关福利方案的基数上下限要求，不可导入！"));
                excelComments.add(errorMessageMap);
                isError = true;
            }

        }
        return isError;
    }


    public Map<String, Object> findElement(List<Map<String, Object>> singleAccount, String target) {
        for (Map<String, Object> e : singleAccount) {
            if (e.containsKey(target)) {
                return e;
            }
        }
        return new HashMap<>();
    }


    public InsuranceArchivesSocialSchemePO buildSocialPO(Long employeeId, Map<Long, String> welfareMap, List<Map<String, Object>> singleAccount, Map<String, Long> schemeNameIdMap, Map<String, Long> paymentNameIdMap, Long creator) {

        if (employeeId == null) {
            return null;
        }
        Long paymentOrg = paymentNameIdMap.get((String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91325, "个税扣缴义务人")).get(SalaryI18nUtil.getI18nLabel(91325, "个税扣缴义务人")));
        List<InsuranceArchivesSocialSchemePO> oldSocialSchemeInfos = getSocialSchemeMapper().getSocialByEmployeeIdAndPayOrg(InsuranceArchivesEmployeePO
                .builder()
                .employeeId(employeeId)
                .paymentOrganization(paymentOrg)
                .build());
        InsuranceArchivesSocialSchemePO oldSocialSchemePO = new InsuranceArchivesSocialSchemePO();
        InsuranceArchivesSocialSchemePO insuranceArchivesSocialSchemePO = new InsuranceArchivesSocialSchemePO();

        //设置社保账号、起始缴纳月、最后缴纳月
        String socialAccount = (String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91324, "社保账号")).get(SalaryI18nUtil.getI18nLabel(91324, "社保账号"));
        Long socialSchemeId = schemeNameIdMap.get((String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91323, "社保方案名称")).get(SalaryI18nUtil.getI18nLabel(91323, "社保方案名称")));
        HashMap<String, String> oldSocialBaseMap = new HashMap<>();
        if (oldSocialSchemeInfos.size() > 0) {
            oldSocialSchemePO = oldSocialSchemeInfos.get(0);
            encryptUtil.decrypt(oldSocialSchemePO, InsuranceArchivesSocialSchemePO.class);
            BeanUtils.copyProperties(oldSocialSchemePO, insuranceArchivesSocialSchemePO);
            //社保基数
            oldSocialBaseMap = JSON.parseObject(oldSocialSchemePO.getSocialPaymentBaseString(), new HashMap<String, String>().getClass());
        }

        insuranceArchivesSocialSchemePO.setId(IdGenerator.generate());
        if (StringUtils.isNotBlank(socialAccount)) {
            insuranceArchivesSocialSchemePO.setSocialAccount(socialAccount);
        }
        if (socialSchemeId != null) {
            insuranceArchivesSocialSchemePO.setSocialSchemeId(socialSchemeId);
        }
        String socialStartDate = (String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91319, "社保起始缴纳月")).get(SalaryI18nUtil.getI18nLabel(91319, "社保起始缴纳月"));
        if (StringUtils.isNotBlank(socialStartDate) && socialStartDate.length() >= 7) {
            socialStartDate = socialStartDate.substring(0, 7);
            insuranceArchivesSocialSchemePO.setSocialStartTime(socialStartDate);
        }

        String socialEndDate = (String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91320, "社保最后缴纳月")).get(SalaryI18nUtil.getI18nLabel(91320, "社保最后缴纳月"));
        if (StringUtils.isNotBlank(socialEndDate) && socialEndDate.length() >= 7) {
            socialEndDate = socialEndDate.substring(0, 7);
            insuranceArchivesSocialSchemePO.setSocialEndTime(socialEndDate);
        }

        insuranceArchivesSocialSchemePO.setTenantKey("");
        insuranceArchivesSocialSchemePO.setWelfareType(WelfareTypeEnum.SOCIAL_SECURITY.getValue());
        insuranceArchivesSocialSchemePO.setUpdateTime(new Date());
        insuranceArchivesSocialSchemePO.setPaymentOrganization(paymentOrg);
        insuranceArchivesSocialSchemePO.setNonPayment(NonPaymentEnum.YES.getValue());
        insuranceArchivesSocialSchemePO.setCreator(creator);
        insuranceArchivesSocialSchemePO.setCreateTime(new Date());
        insuranceArchivesSocialSchemePO.setUpdateTime(new Date());
        insuranceArchivesSocialSchemePO.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue());
        insuranceArchivesSocialSchemePO.setEmployeeId(employeeId);
        insuranceArchivesSocialSchemePO.setUnderTake(UndertakerEnum.SCOPE_PERSON.getValue());
        List<InsuranceSchemeDetailPO> insuranceSchemeDetailPOS = getInsuranceSchemeDetailMapper().queryListBySchemeId(insuranceArchivesSocialSchemePO.getSocialSchemeId());
        encryptUtil.decryptList(insuranceSchemeDetailPOS, InsuranceSchemeDetailPO.class);
        if (CollectionUtils.isNotEmpty(insuranceSchemeDetailPOS)) {
            List<Long> insuranceIds = insuranceSchemeDetailPOS.stream().map(InsuranceSchemeDetailPO::getInsuranceId).collect(Collectors.toList());
            HashMap<String, String> socialPaymentBase = new HashMap<>();
            for (Long insuranceId : insuranceIds) {
                if (StringUtils.isBlank(welfareMap.get(insuranceId))) {
                    continue;
                }
                if (findElement(singleAccount, welfareMap.get(insuranceId) + SalaryI18nUtil.getI18nLabel(100293, "申报基数")) != null) {
                    String itemValue = (String) findElement(singleAccount, welfareMap.get(insuranceId) + SalaryI18nUtil.getI18nLabel(100293, "申报基数")).get(welfareMap.get(insuranceId) + SalaryI18nUtil.getI18nLabel(100293, "申报基数"));
                    if (StringUtils.isNotBlank(itemValue)) {
                        socialPaymentBase.put(String.valueOf(insuranceId), itemValue);
                    } else if (oldSocialBaseMap != null && StringUtils.isNotBlank(oldSocialBaseMap.get(String.valueOf(insuranceId)))) {
                        socialPaymentBase.put(String.valueOf(insuranceId), oldSocialBaseMap.get(String.valueOf(insuranceId)));
                    }
                }
            }
            insuranceArchivesSocialSchemePO.setSocialPaymentBaseString(JSON.toJSONString(socialPaymentBase));
        }
        return insuranceArchivesSocialSchemePO;
    }


    public InsuranceArchivesFundSchemePO buildFundPO(Long employeeId, Map<Long, String> welfareMap, List<Map<String, Object>> singleAccount, Map<String, Long> schemeNameIdMap, Map<String, Long> paymentNameIdMap, Long creator) {

        if (employeeId == null) {
            return null;
        }
        Long paymentOrg = paymentNameIdMap.get((String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91325, "个税扣缴义务人")).get(SalaryI18nUtil.getI18nLabel(91325, "个税扣缴义务人")));
        List<InsuranceArchivesFundSchemePO> oldFundSchemeInfos = getFundSchemeMapper().getFundByEmployeeIdAndPayOrg(InsuranceArchivesEmployeePO
                .builder()
                .employeeId(employeeId)
                .paymentOrganization(paymentOrg)
                .build());
        InsuranceArchivesFundSchemePO oldFundSchemePO = new InsuranceArchivesFundSchemePO();
        InsuranceArchivesFundSchemePO insuranceArchivesFundSchemePO = new InsuranceArchivesFundSchemePO();

        //设置公积金账号、起始缴纳月、最后缴纳月
        String fundAccount = (String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91486, "公积金账号")).get(SalaryI18nUtil.getI18nLabel(91486, "公积金账号"));
        String supplementFundAccount = (String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91487, "补充公积金账号")).get(SalaryI18nUtil.getI18nLabel(91487, "补充公积金账号"));
        Long fundSchemeId = schemeNameIdMap.get((String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称")).get(SalaryI18nUtil.getI18nLabel(91485, "公积金方案名称")));
        HashMap<String, String> oldFundBaseMap = new HashMap<>();
        if (oldFundSchemeInfos.size() > 0) {
            oldFundSchemePO = oldFundSchemeInfos.get(0);
            encryptUtil.decrypt(oldFundSchemePO, InsuranceArchivesFundSchemePO.class);
            BeanUtils.copyProperties(oldFundSchemePO, insuranceArchivesFundSchemePO);
            //社保基数
            oldFundBaseMap = JSON.parseObject(oldFundSchemePO.getFundPaymentBaseString(), new HashMap<String, String>().getClass());
        }

        insuranceArchivesFundSchemePO.setId(IdGenerator.generate());
        insuranceArchivesFundSchemePO.setCreator(creator);
        insuranceArchivesFundSchemePO.setTenantKey("");
        insuranceArchivesFundSchemePO.setCreateTime(new Date());
        insuranceArchivesFundSchemePO.setUpdateTime(new Date());
        if (fundSchemeId != null) {
            insuranceArchivesFundSchemePO.setFundSchemeId(fundSchemeId);
        }
        if (StringUtils.isNotBlank(fundAccount)) {
            insuranceArchivesFundSchemePO.setFundAccount(fundAccount);
        }
        if (StringUtils.isNotBlank(supplementFundAccount)) {
            insuranceArchivesFundSchemePO.setSupplementFundAccount(supplementFundAccount);
        }
        String fundStartDate = (String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91483, "公积金起始缴纳月")).get(SalaryI18nUtil.getI18nLabel(91483, "公积金起始缴纳月"));
        if (StringUtils.isNotBlank(fundStartDate) && fundStartDate.length() >= 7) {
            fundStartDate = fundStartDate.substring(0, 7);
            insuranceArchivesFundSchemePO.setFundStartTime(fundStartDate);
        }

        String fundEndDate = (String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91484, "公积金最后缴纳月")).get(SalaryI18nUtil.getI18nLabel(91484, "公积金最后缴纳月"));
        if (StringUtils.isNotBlank(fundEndDate) && fundEndDate.length() >= 7) {
            fundEndDate = fundEndDate.substring(0, 7);
            insuranceArchivesFundSchemePO.setFundEndTime(fundEndDate);
        }

        insuranceArchivesFundSchemePO.setWelfareType(WelfareTypeEnum.ACCUMULATION_FUND.getValue());
        insuranceArchivesFundSchemePO.setPaymentOrganization(paymentOrg);
        insuranceArchivesFundSchemePO.setNonPayment(NonPaymentEnum.YES.getValue());
        insuranceArchivesFundSchemePO.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue());
        insuranceArchivesFundSchemePO.setUnderTake(UndertakerEnum.SCOPE_PERSON.getValue());
        insuranceArchivesFundSchemePO.setEmployeeId(employeeId);

        List<InsuranceSchemeDetailPO> insuranceSchemeDetailPOS = getInsuranceSchemeDetailMapper().queryListBySchemeId(insuranceArchivesFundSchemePO.getFundSchemeId());
        encryptUtil.decryptList(insuranceSchemeDetailPOS, InsuranceSchemeDetailPO.class);
        if (CollectionUtils.isNotEmpty(insuranceSchemeDetailPOS)) {
            List<Long> insuranceIds = insuranceSchemeDetailPOS.stream().map(InsuranceSchemeDetailPO::getInsuranceId).collect(Collectors.toList());
            HashMap<String, String> socialPaymentBase = new HashMap<>();
            for (Long insuranceId : insuranceIds) {
                if (StringUtils.isBlank(welfareMap.get(insuranceId))) {
                    continue;
                }
                if (findElement(singleAccount, welfareMap.get(insuranceId) + SalaryI18nUtil.getI18nLabel(100293, "申报基数")) != null) {
                    String itemValue = (String) findElement(singleAccount, welfareMap.get(insuranceId) + SalaryI18nUtil.getI18nLabel(100293, "申报基数")).get(welfareMap.get(insuranceId) + SalaryI18nUtil.getI18nLabel(100293, "申报基数"));
                    if (StringUtils.isNotBlank(itemValue)) {
                        socialPaymentBase.put(String.valueOf(insuranceId), itemValue);
                    } else if (oldFundBaseMap != null && StringUtils.isNotBlank(oldFundBaseMap.get(String.valueOf(insuranceId)))) {
                        socialPaymentBase.put(String.valueOf(insuranceId), oldFundBaseMap.get(String.valueOf(insuranceId)));
                    }

                }
            }
            insuranceArchivesFundSchemePO.setFundPaymentBaseString(JSON.toJSONString(socialPaymentBase));
        }
        return insuranceArchivesFundSchemePO;
    }


    public InsuranceArchivesOtherSchemePO buildOtherPO(Long employeeId, Map<Long, String> welfareMap, List<Map<String, Object>> singleAccount, Map<String, Long> schemeNameIdMap, Map<String, Long> paymentNameIdMap, Long creator) {

        if (employeeId == null) {
            return null;
        }Long paymentOrg = paymentNameIdMap.get((String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91325, "个税扣缴义务人")).get(SalaryI18nUtil.getI18nLabel(91325, "个税扣缴义务人")));
        List<InsuranceArchivesOtherSchemePO> oldOtherSchemeInfos = getOtherSchemeMapper().getOtherByEmployeeIdAndPayOrg(InsuranceArchivesEmployeePO
                .builder()
                .employeeId(employeeId)
                .paymentOrganization(paymentOrg)
                .build());
        InsuranceArchivesOtherSchemePO oldOtherSchemePO = new InsuranceArchivesOtherSchemePO();
        InsuranceArchivesOtherSchemePO insuranceArchivesOtherSchemePO = new InsuranceArchivesOtherSchemePO();

        //设置其他福利方案、起始缴纳月、最后缴纳月
        Long otherSchemeId = schemeNameIdMap.get((String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称")).get(SalaryI18nUtil.getI18nLabel(91496, "其他福利方案名称")));
        HashMap<String, String> oldOtherBaseMap = new HashMap<>();
        if (oldOtherSchemeInfos.size() > 0) {
            oldOtherSchemePO = oldOtherSchemeInfos.get(0);
            encryptUtil.decrypt(oldOtherSchemePO, InsuranceArchivesOtherSchemePO.class);
            BeanUtils.copyProperties(oldOtherSchemePO, insuranceArchivesOtherSchemePO);
            //社保基数
            oldOtherBaseMap = JSON.parseObject(oldOtherSchemePO.getOtherPaymentBaseString(), new HashMap<String, String>().getClass());
        }

        insuranceArchivesOtherSchemePO.setId(IdGenerator.generate());
        insuranceArchivesOtherSchemePO.setCreator(creator);
        insuranceArchivesOtherSchemePO.setTenantKey("");
        insuranceArchivesOtherSchemePO.setCreateTime(new Date());
        insuranceArchivesOtherSchemePO.setUpdateTime(new Date());
        if (otherSchemeId != null) {
            insuranceArchivesOtherSchemePO.setOtherSchemeId(otherSchemeId);
        }
        String otherStartDate = (String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91490, "其他福利起始缴纳月")).get(SalaryI18nUtil.getI18nLabel(91490, "其他福利起始缴纳月"));
        if (StringUtils.isNotBlank(otherStartDate) && otherStartDate.length() >= 7) {
            otherStartDate = otherStartDate.substring(0, 7);
            insuranceArchivesOtherSchemePO.setOtherStartTime(otherStartDate);
        }

        String otherEndDate = (String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91494, "其他福利最后缴纳月")).get(SalaryI18nUtil.getI18nLabel(91494, "其他福利最后缴纳月"));
        if (StringUtils.isNotBlank(otherEndDate) && otherEndDate.length() >= 7) {
            otherEndDate = otherEndDate.substring(0, 7);
            insuranceArchivesOtherSchemePO.setOtherEndTime(otherEndDate);
        }

        insuranceArchivesOtherSchemePO.setPaymentOrganization(paymentOrg);
        insuranceArchivesOtherSchemePO.setWelfareType(WelfareTypeEnum.OTHER.getValue());
        insuranceArchivesOtherSchemePO.setNonPayment(NonPaymentEnum.YES.getValue());
        insuranceArchivesOtherSchemePO.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue());
        insuranceArchivesOtherSchemePO.setUnderTake(UndertakerEnum.SCOPE_PERSON.getValue());
        insuranceArchivesOtherSchemePO.setEmployeeId(employeeId);
        List<InsuranceSchemeDetailPO> insuranceSchemeDetailPOS = getInsuranceSchemeDetailMapper().queryListBySchemeId(insuranceArchivesOtherSchemePO.getOtherSchemeId());
        encryptUtil.decryptList(insuranceSchemeDetailPOS, InsuranceSchemeDetailPO.class);
        if (CollectionUtils.isNotEmpty(insuranceSchemeDetailPOS)) {
            List<Long> insuranceIds = insuranceSchemeDetailPOS.stream().map(InsuranceSchemeDetailPO::getInsuranceId).collect(Collectors.toList());
            HashMap<String, String> socialPaymentBase = new HashMap<>();
            for (Long insuranceId : insuranceIds) {
                if (StringUtils.isBlank(welfareMap.get(insuranceId))) {
                    continue;
                }
                if (findElement(singleAccount, welfareMap.get(insuranceId) + SalaryI18nUtil.getI18nLabel(100293, "申报基数")) != null) {
                    String itemValue = (String) findElement(singleAccount, welfareMap.get(insuranceId) + SalaryI18nUtil.getI18nLabel(100293, "申报基数")).get(welfareMap.get(insuranceId) + SalaryI18nUtil.getI18nLabel(100293, "申报基数"));
                    if (StringUtils.isNotBlank(itemValue)) {
                        socialPaymentBase.put(String.valueOf(insuranceId), itemValue);
                    } else if (oldOtherBaseMap != null && StringUtils.isNotBlank(oldOtherBaseMap.get(String.valueOf(insuranceId)))) {
                        socialPaymentBase.put(String.valueOf(insuranceId), oldOtherBaseMap.get(String.valueOf(insuranceId)));
                    }

                }
            }
            insuranceArchivesOtherSchemePO.setOtherPaymentBaseString(JSON.toJSONString(socialPaymentBase));
        }
        return insuranceArchivesOtherSchemePO;
    }

    public InsuranceArchivesBaseInfoPO buildBaseInfoPO(Long employeeId, List<Map<String, Object>> singleAccount, Map<String, Long> paymentNameIdMap, Long creator, String runStatus, Boolean isExtEmp) {
        if (employeeId == null) {
            return null;
        }
        InsuranceArchivesBaseInfoPO insuranceArchivesBaseInfoPO = new InsuranceArchivesBaseInfoPO();
        insuranceArchivesBaseInfoPO.setEmployeeId(employeeId);
        insuranceArchivesBaseInfoPO.setId(IdGenerator.generate());
        insuranceArchivesBaseInfoPO.setCreateTime(new Date());
        insuranceArchivesBaseInfoPO.setDeleteType(0);
        insuranceArchivesBaseInfoPO.setCreator(creator);
        insuranceArchivesBaseInfoPO.setRunStatus(runStatus);
        insuranceArchivesBaseInfoPO.setUpdateTime(new Date());
        insuranceArchivesBaseInfoPO.setTenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY);
        insuranceArchivesBaseInfoPO.setPaymentOrganization(paymentNameIdMap.get((String) findElement(singleAccount, SalaryI18nUtil.getI18nLabel(91497, "个税扣缴义务人")).get(SalaryI18nUtil.getI18nLabel(91497, "个税扣缴义务人"))));
        if (isExtEmp) {
            insuranceArchivesBaseInfoPO.setEmployeeType(1);
        }

        return insuranceArchivesBaseInfoPO;
    }

    public void handleImportData(List<InsuranceArchivesAccountPO> insuranceArchivesAccountPOS, SIArchiveImportParam param) {
        //导入社保档案
        List<InsuranceArchivesSocialSchemePO> socialSchemePOS = insuranceArchivesAccountPOS.stream().filter(Objects::nonNull).map(InsuranceArchivesAccountPO::getSocial).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(socialSchemePOS)) {

            //去除员工id+个税扣缴义务人下重复的数据
            socialSchemePOS = socialSchemePOS.stream()
                    .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getPaymentOrganization() + "-" + f.getEmployeeId()))), ArrayList::new));

            //生成福利档案基数调整历史记录
            List<InsuranceArchivesBaseHistoryPO> adjustSocialHistoryPOList = siArchivesBiz.dealSocialBaseAdjustInfoList(socialSchemePOS, (long) user.getUID());

            //根据人员id和个税扣缴义务人id删除对应旧档案
            socialSchemePOS.forEach(getSocialSchemeMapper()::deleteByEmployeeIdAndPayOrg);

            //新建新档案
            List<InsuranceArchivesSocialSchemePO> insuranceArchivesSocialSchemePOS = encryptUtil.encryptList(socialSchemePOS, InsuranceArchivesSocialSchemePO.class);
            List<List<InsuranceArchivesSocialSchemePO>> partition = Lists.partition(insuranceArchivesSocialSchemePOS, 100);
            partition.forEach(getSocialSchemeMapper()::batchSave);

            //新建福利档案基数调整历史记录
            siArchivesBiz.batchInsertAdjustHistory(adjustSocialHistoryPOList, user.getUID());
        }
        //导入公积金档案
        List<InsuranceArchivesFundSchemePO> fundSchemePOS = insuranceArchivesAccountPOS.stream().filter(Objects::nonNull).map(InsuranceArchivesAccountPO::getFund).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(fundSchemePOS)) {

            //去除员工id+个税扣缴义务人下重复的数据
            fundSchemePOS = fundSchemePOS.stream()
                    .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getPaymentOrganization() + "-" + f.getEmployeeId()))), ArrayList::new));

            //生成福利档案基数调整历史记录
            List<InsuranceArchivesBaseHistoryPO> adjustFundHistoryPOList = siArchivesBiz.dealFundBaseAdjustInfoList(fundSchemePOS, (long) user.getUID());
            //根据人员id和个税扣缴义务人id删除对应档案
            fundSchemePOS.forEach(getFundSchemeMapper()::deleteByEmployeeIdAndPayOrg);
            //新建新档案
            List<InsuranceArchivesFundSchemePO> insuranceArchivesFundSchemePOS = encryptUtil.encryptList(fundSchemePOS, InsuranceArchivesFundSchemePO.class);
            List<List<InsuranceArchivesFundSchemePO>> partition = Lists.partition(insuranceArchivesFundSchemePOS, 100);
            partition.forEach(getFundSchemeMapper()::batchSave);
            //新建福利档案基数调整历史记录
            siArchivesBiz.batchInsertAdjustHistory(adjustFundHistoryPOList, user.getUID());
        }
        //导入其他福利档案
        List<InsuranceArchivesOtherSchemePO> otherSchemePOS = insuranceArchivesAccountPOS.stream().filter(Objects::nonNull).map(InsuranceArchivesAccountPO::getOther).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(otherSchemePOS)) {

            //去除员工id+个税扣缴义务人下重复的数据
            otherSchemePOS = otherSchemePOS.stream()
                    .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getPaymentOrganization() + "-" + f.getEmployeeId()))), ArrayList::new));

            //生成福利档案基数调整历史记录
            List<InsuranceArchivesBaseHistoryPO> adjustOtherHistoryPOList = siArchivesBiz.dealOtherBaseAdjustInfoList(otherSchemePOS, (long) user.getUID());

            //根据人员id和个税扣缴义务人id删除对应档案
            otherSchemePOS.forEach(getOtherSchemeMapper()::deleteByEmployeeIdAndPayOrg);
            //新建新档案
            List<InsuranceArchivesOtherSchemePO> insuranceArchivesOtherSchemePOS = encryptUtil.encryptList(otherSchemePOS, InsuranceArchivesOtherSchemePO.class);
            List<List<InsuranceArchivesOtherSchemePO>> partition = Lists.partition(insuranceArchivesOtherSchemePOS, 100);
            partition.forEach(getOtherSchemeMapper()::batchSave);
            //新建福利档案基数调整历史记录
            siArchivesBiz.batchInsertAdjustHistory(adjustOtherHistoryPOList, user.getUID());
        }
        //导入福利档案基础信息
        List<InsuranceArchivesBaseInfoPO> baseInfoPOS = insuranceArchivesAccountPOS.stream().filter(Objects::nonNull).map(InsuranceArchivesAccountPO::getBaseInfo).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(baseInfoPOS)) {
//            baseInfoPOS = baseInfoPOS.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(InsuranceArchivesBaseInfoPO::getEmployeeId))), ArrayList::new));
            //去除员工id+个税扣缴义务人下重复的数据
            baseInfoPOS = baseInfoPOS.stream()
                    .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getPaymentOrganization() + "-" + f.getEmployeeId()))), ArrayList::new));
            //根据人员id和个税扣缴义务人id删除对应档案
            baseInfoPOS.forEach(getInsuranceBaseInfoMapper()::deleteByEmployeeIdAndPayOrg);
            //分批批量删除
            List<Long> baseInfoEmployeeIds = baseInfoPOS.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> moreBaseInfoPOS = new ArrayList<>();
            List<List<Long>> partitionInfo = Lists.partition((List<Long>) baseInfoEmployeeIds, 1000);
            partitionInfo.forEach(part -> moreBaseInfoPOS.addAll(
                    getInsuranceBaseInfoMapper().getInsuranceBaseInfoListByInsuranceDetail(part)));
            List<InsuranceArchivesBaseInfoPO> newInsuranceArchivesBaseInfoList = new ArrayList<>();
            //设置社保、公积金、其他福利档案id
            for (InsuranceArchivesBaseInfoPO po : baseInfoPOS) {
                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);
        }
        //新增人员范围（会自动生成人员档案）
        if (CollectionUtils.isNotEmpty(param.getTaxAgentRanges())) {
            param.getTaxAgentRanges().forEach(getTaxAgentManageRangeService(user)::save);
        }
    }


    /**
     * 导出档案导入所需要的模板，可根据开关选择是否导出现有的档案数据
     *
     * @param param 是否导出带档案数据的模板
     */
    public XSSFWorkbook exportTemplate(InsuranceArchivesListParam param) {
        return getSIImportService().exportTemplate(param);

    }


    /**
     * 校验待新增的社保福利档案数据
     */
    @Override
    public Map<String, Object> checkSIArchiveAdd(SIArchiveImportParam param) {
        param.setAddData(false);
        return processAddSIArchive(param);
    }

    /**
     * 新增社保福利档案
     */
    @Override
    public Map<String, Object> addSIArchive(SIArchiveImportParam param) {
        param.setAddData(true);
        return processAddSIArchive(param);
    }

    private Map<String, Object> processAddSIArchive(SIArchiveImportParam param) {

        ValidUtil.doValidator(param);
        param.setProcess(true);

        if (StringUtils.isBlank(param.getRunStatus())) {
            throw new SalaryRunTimeException("福利档案执行状态未在导入条件设置中添加！");
        }
//        List<ExcelSheet> excelSheets = message.getBatchFile().getExcelSheets();
        // 租户key
//        String tenantKey = message.getTenantKey().toLowerCase();
        //操作员id
        Long creator = (long) user.getUID();
        //获取所有福利类型的id-name结合
        Map<String, Long> schemeNameIdMap = schemeNameIdMap();
        Map<Long, String> welfareMap = welfareMap();
        // 获取所有个税扣缴义务人的名称和id的map
        Map<String, Long> paymentNameIdMap;

        //分权
//        Boolean openDevolution = getTaxAgentService().isOpenDevolution();
        // 流程处理，默认不开启分权
        Boolean openDevolution = false;
        if (openDevolution) {
            paymentNameIdMap = getTaxAgentService().listAllTaxAgentsAsAdmin((long) user.getUID()).stream().collect(Collectors.toMap(TaxAgentPO::getName, TaxAgentPO::getId));
        } else {

            paymentNameIdMap = getTaxAgentService().listAll().stream().collect(Collectors.toMap(TaxAgentPO::getName, TaxAgentPO::getId));
        }

        //获取所有个税扣缴义务人树型
        List<TaxAgentManageRangeEmployeeDTO> taxAgentManageRangeEmployeeTree = getTaxAgentService().listTaxAgentAndEmployeeTree();

        // 获取所有人员信息
        List<DataCollectionEmployee> employeeByIds = getSalaryEmployeeService(user).listEmployee();
        int total = 0;

        int index = 0;
        int successCount = 0;
        int errorCount = 0;

        // 待导入数据
        List<InsuranceArchivesAccountPO> insuranceArchivesAccountPOS = new ArrayList<>();

        // 待导入数据
        InputStream fileInputStream = null;
        try {
            // 表头
            List<String> headers = new ArrayList<>();
            if (param.getImportDatas().size() > 0) {
                Map<String, Object> getHeadersMap = param.getImportDatas().get(0);
                for (Map.Entry<String, Object> entry : getHeadersMap.entrySet()) {
                    headers.add(entry.getKey());
                }
            } else {
                throw new SalaryRunTimeException("新增福利档案数据为空！");
            }

            // 错误sheet数据
            List<Map<String, Object>> errorData = new LinkedList<>();
            // 错误提示
            List<Map<String, String>> excelComments = new LinkedList<>();

            // 处理数值
            List<Map<String, Object>> data = param.getImportDatas();
            total = data.size();

            //当前sheel的单行记录
            Map<String, Object> map;
            for (int i = 0; i < data.size(); i++) {
                index += 1;
                map = data.get(i);
                boolean isError;
                List<Map<String, Object>> singleAccount = new ArrayList<>();
                for (int j = 0; j < headers.size(); j++) {
                    //组装单条数据基础数据
                    String key = headers.get(j);
                    if (key == null) {
                        continue;
                    }
                    Map<String, Object> cellData = new HashMap<>();
                    cellData.put(key.toString(), Optional.ofNullable(map.get(key.toString())).orElse("").toString());
                    cellData.put("index", j);
                    singleAccount.add(cellData);
                }

                isError = singleAccountCheck(singleAccount, welfareMap, insuranceArchivesAccountPOS, employeeByIds, excelComments, errorCount + 1, schemeNameIdMap, paymentNameIdMap, creator, i + 2, openDevolution, taxAgentManageRangeEmployeeTree, param);
                if (isError) {
                    errorCount += 1;
                    // 添加错误数据
                    errorData.add(map);
                } else {
                    successCount += 1;
                }
//                salaryBatchService.sendImportRate(message.getBizId(), total, index);
            }

            // 如果sheet包含错误数据
//            if (CollectionUtils.isNotEmpty(errorData)) {
//                salaryBatchService.createErrorExcelSheet(headers, errorData, excelSheet.getName(), excelComments, errorExcelSheets);
//            }

            // 数据入库处理
            if (param.isAddData()) {
                handleImportData(insuranceArchivesAccountPOS, param);
            }
            // 发送导入回调信息
//        salaryBatchService.sendImportCallBackInfo(message, successCount, errorCount, errorExcelSheets);

            Map<String, Object> apidatas = new HashMap<String, Object>();
            apidatas.put("successCount", successCount);
            apidatas.put("errorCount", errorCount);
            apidatas.put("errorData", excelComments);
            return apidatas;
        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }
    }

    @Override
    public List<String> updateSchemeDetail(List<InsuranceSchemeDetailUpdateParam> schemeDetailList) {
        List<String> errorInfo = new ArrayList<>();
        if (schemeDetailList.size() > 0) {
            log.info("待处理方明明细数量:{}", schemeDetailList.size());
            List<InsuranceSchemeDetailUpdateParam> toDealSchemeDetailList = schemeDetailList.stream().filter(f -> f.getPrimaryId() != null).collect(Collectors.toList());
            log.info("未设置方案id的方明明细无法处理，数量:{}", schemeDetailList.size() - toDealSchemeDetailList.size());

            //按照方案id分组
            Map<Long, List<InsuranceSchemeDetailUpdateParam>> schemeDetailMap = toDealSchemeDetailList
                    .stream().collect(Collectors.groupingBy(InsuranceSchemeDetailUpdateParam::getPrimaryId));

            schemeDetailMap.forEach((k, v) -> {
                updateSchemeDetailByPrimaryId(k, v, errorInfo);
            });

        }
        return errorInfo;
    }

    public List<String> updateSchemeDetailByPrimaryId(Long primaryId, List<InsuranceSchemeDetailUpdateParam> schemeDetailList, List<String> errorInfo) {
        try {
            Map<String, InsuranceSchemeDetailUpdateParam> schemeDetailUpdateMap = new HashMap<>();
            schemeDetailList.forEach(f -> {
                schemeDetailUpdateMap.put(f.getInsuranceId() + "-" + f.getPaymentScope(), f);
            });
            List<InsuranceSchemeDetailPO> schemeDetailPOS = siSchemeBiz.listByPrimaryId(primaryId);
            //替换修改字段
            if (schemeDetailPOS.size() > 0) {
                schemeDetailPOS.forEach(f -> {
                    if (schemeDetailUpdateMap.get(f.getInsuranceId() + "-" + f.getPaymentScope()) != null) {
                        InsuranceSchemeDetailUpdateParam schemeDetailUpdateParam = schemeDetailUpdateMap.get(f.getInsuranceId() + "-" + f.getPaymentScope());
                        BeanUtils.copyProperties(schemeDetailUpdateParam, f);
                        f.setUpdateTime(new Date());
                    }
                });
                encryptUtil.encryptList(schemeDetailPOS, InsuranceSchemeDetailPO.class);
                schemeDetailPOS.forEach(getInsuranceSchemeDetailMapper()::updateAll);

            } else {
                errorInfo.add("方案id:" + primaryId + "," + "表中不存在方案明细数据");
            }
        } catch (Exception e) {
            errorInfo.add("方案id:" + primaryId + "," + e.getMessage());
        }
        return errorInfo;
    }

}