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

package com.engine.salary.service.impl;

import cn.hutool.core.util.NumberUtil;
import com.alibaba.fastjson.JSONObject;
import com.api.formmode.mybatis.util.SqlProxyHandle;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.hrmelog.entity.dto.LoggerContext;
import com.engine.salary.biz.OtherDeductionBiz;
import com.engine.salary.config.SalaryElogConfig;
import com.engine.salary.constant.SalaryDefaultTenantConstant;
import com.engine.salary.encrypt.EncryptUtil;
import com.engine.salary.entity.datacollection.AddUpDeduction;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.datacollection.dto.*;
import com.engine.salary.entity.datacollection.param.*;
import com.engine.salary.entity.datacollection.po.*;
import com.engine.salary.entity.salaryacct.po.SalaryAcctEmployeePO;
import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeEmployeeDTO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.OperateTypeEnum;
import com.engine.salary.enums.UserStatusEnum;
import com.engine.salary.enums.datacollection.DataCollectionEmployeeTypeEnum;
import com.engine.salary.enums.datacollection.TaxFreeTypeEnum;
import com.engine.salary.enums.salarysob.IncomeCategoryEnum;
import com.engine.salary.enums.sicategory.DeleteTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.datacollection.*;
import com.engine.salary.mapper.sys.SalarySysConfMapper;
import com.engine.salary.service.AddUpDeductionService;
import com.engine.salary.service.OtherDeductionService;
import com.engine.salary.service.SalaryEmployeeService;
import com.engine.salary.service.TaxAgentService;
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.SalaryDateUtil;
import com.engine.salary.util.SalaryEntityUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.db.IdGenerator;
import com.engine.salary.util.db.MapperProxyFactory;
import com.engine.salary.util.excel.ExcelComment;
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 org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.BeanUtils;
import weaver.file.ImageFileManager;
import weaver.general.Util;
import weaver.hrm.User;

import java.io.InputStream;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.util.*;
import java.util.stream.Collectors;

import static com.engine.salary.constant.SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY;
import static com.engine.salary.util.excel.ExcelSupport.EXCEL_TYPE_XLSX;

public class OtherDeductionServiceImpl extends Service implements OtherDeductionService {
    private EncryptUtil encryptUtil = new EncryptUtil();

    private OtherDeductionMapper getOtherDeductionMapper() {
        return MapperProxyFactory.getProxy(OtherDeductionMapper.class);
    }

    private OtherDeductionBiz getOtherDeductionBiz() {
        return new OtherDeductionBiz();
    }

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

    private AddUpDeductionService getAddUpDeductionService(User user) {
        return ServiceUtil.getService(AddUpDeductionServiceImpl.class, user);
    }

    private SalaryEmployeeService getSalaryEmployeeService(User user) {
        return 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 FreeIncomeMapper getFreeIncomeMapper() {
        return MapperProxyFactory.getProxy(FreeIncomeMapper.class);
    }

    private HealthInsuranceMapper getHealthInsuranceMapper() {
        return MapperProxyFactory.getProxy(HealthInsuranceMapper.class);
    }

    private EndowmentInsuranceMapper getEndowmentInsuranceMapper() {
        return MapperProxyFactory.getProxy(EndowmentInsuranceMapper.class);
    }

    private GrantDonationMapper getGrantDonationMapper() {
        return MapperProxyFactory.getProxy(GrantDonationMapper.class);
    }

    private DerateDeductionMapper getDerateDeductionMapper() {
        return MapperProxyFactory.getProxy(DerateDeductionMapper.class);
    }


    private OtherDerateDeductionMapper getOtherDerateDeductionMapper() {
        return MapperProxyFactory.getProxy(OtherDerateDeductionMapper.class);
    }

    private PersonalPensionMapper getPersonalPensionMapper() {
        return MapperProxyFactory.getProxy(PersonalPensionMapper.class);
    }


    @Override
    public OtherDeductionPO getById(Long id) {
        return getOtherDeductionMapper().getById(id);
    }


    @Override
    public PageInfo<OtherDeductionListDTO> listPage(OtherDeductionQueryParam queryParam) {
        //申报月份
        List<String> declareMonth = queryParam.getDeclareMonth();
        if (CollectionUtils.isNotEmpty(declareMonth)) {
            queryParam.setDeclareMonth(declareMonth.stream().filter(StringUtils::isNotBlank).map(e -> e + "-01 00:00:00").collect(Collectors.toList()));
            queryParam.setDeclareMonthDate(declareMonth.stream().filter(StringUtils::isNotBlank).map(e -> e + "-01 00:00:00").map(SalaryDateUtil::dateStrToLocalTime).collect(Collectors.toList()));
        }

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

        long employeeId = user.getUID();

        Boolean needAuth = getTaxAgentService(user).isNeedAuth(employeeId);
        if (needAuth) {
            List<Long> taxAgentIdsAsAdmin = getTaxAgentService(user).listAllTaxAgentsAsAdmin(employeeId).stream().map(TaxAgentPO::getId).collect(Collectors.toList());
            if (CollectionUtils.isEmpty(taxAgentIdsAsAdmin)) {
                return new PageInfo<>(OtherDeductionListDTO.class);
            }
            queryParam.setTaxAgentIds(taxAgentIdsAsAdmin);
        }
        List<OtherDeductionListDTO> list = getOtherDeductionMapper().list(queryParam);
        PageInfo<OtherDeductionListDTO> page = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(),
                list, OtherDeductionListDTO.class);
        encryptUtil.decryptList(page.getList(), OtherDeductionListDTO.class);
        return page;
    }

    @Override
    public PageInfo<OtherDeductionRecordDTO> recordListPage(OtherDeductionQueryParam queryParam) {
        long employeeId = user.getUID();

        //申报月份
        List<String> declareMonth = queryParam.getDeclareMonth();
        if (CollectionUtils.isNotEmpty(declareMonth)) {
            queryParam.setDeclareMonth(declareMonth.stream().map(e -> e + "-01 00:00:00").collect(Collectors.toList()));
            queryParam.setDeclareMonthDate(declareMonth.stream().map(e -> e + "-01 00:00:00").map(SalaryDateUtil::dateStrToLocalTime).collect(Collectors.toList()));
        }

        Boolean needAuth = getTaxAgentService(user).isNeedAuth(employeeId);
        if (needAuth) {
            List<Long> taxAgentIdsAsAdmin = getTaxAgentService(user).listAllTaxAgentsAsAdmin(employeeId).stream().map(TaxAgentPO::getId).collect(Collectors.toList());
            if (CollectionUtils.isEmpty(taxAgentIdsAsAdmin)) {
                return new PageInfo<>(OtherDeductionRecordDTO.class);
            }
            queryParam.setTaxAgentIds(taxAgentIdsAsAdmin);
        }
        List<OtherDeductionRecordDTO> list = getOtherDeductionMapper().recordList(queryParam);
        PageInfo<OtherDeductionRecordDTO> page = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(),
                list, OtherDeductionRecordDTO.class);
        encryptUtil.decryptList(page.getList(), OtherDeductionRecordDTO.class);
        return page;
    }


    @Override
    public Map<String, Object> preview(OtherDeductionImportParam importParam) {
        Map<String, Object> apidatas = new HashMap<String, Object>();

        //excel文件id
        String imageId = Util.null2String(importParam.getImageId());
        Validate.notBlank(imageId, "imageId为空");

        InputStream fileInputStream = null;
        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));
            Sheet sheet = ExcelSupport.parseFile(fileInputStream, 0, EXCEL_TYPE_XLSX);
            apidatas.put("headers", ExcelSupport.getSheetHeader(sheet, 0));
            apidatas.put("list", ExcelParseHelper.parse2List(sheet, 1, 0));
            return apidatas;
        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }
    }


    public Map<String, Object> importData(OtherDeductionImportParam importParam) {

        Boolean openDevolution = getTaxAgentService(user).isOpenDevolution();

        long currentEmployeeId = user.getUID();
        Map<String, Object> apidatas = new HashMap<String, Object>();
        OtherDeductionBiz OtherDeductionBiz = new OtherDeductionBiz();

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

        //检验参数
        checkImportParam(importParam);

        //excel文件id
        String imageId = Util.null2String(importParam.getImageId());
        Validate.notBlank(imageId, "imageId为空");
        //税款所属期
        String declareMonthStr = Util.null2String(importParam.getDeclareMonth());

        InputStream fileInputStream = null;
        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));
            List<OtherDeductionListDTO> OtherDeductions = ExcelParseHelper.parse2Map(fileInputStream, OtherDeductionListDTO.class, 0, 1, 14, "OtherDeductionTemplate.xlsx");

            int total = OtherDeductions.size();
            int index = 0;
            int successCount = 0;
            int errorCount = 0;

            //人员信息
            List<DataCollectionEmployee> employees = getSalaryEmployeeService(user).listEmployee();
            // 获取所有个税扣缴义务人
            Collection<TaxAgentManageRangeEmployeeDTO> taxAgentList = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId);
            //税款所属期
            Date declareMonth = SalaryDateUtil.stringToDate(declareMonthStr + "-01");
            // 获取已经核算的数据
            List<SalaryAcctEmployeePO> salaryAcctEmployees = getAddUpDeductionService(user).getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
            // 查询已有数据
            List<OtherDeductionPO> list = getOtherDeductionMapper().listSome(OtherDeductionPO.builder().declareMonth(declareMonth).build());

            // 错误excel内容
            List<Map> errorData = new ArrayList<>();
            //合规数据
            List<OtherDeductionPO> eligibleData = new ArrayList<>();

            List<TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee> taxAgentEmployees = Lists.newArrayList();
            for (int i = 0; i < OtherDeductions.size(); i++) {
                OtherDeductionListDTO dto = OtherDeductions.get(i);

                Date now = new Date();
                //待插入数据库对象
                OtherDeductionPO po = OtherDeductionPO.builder()
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .createTime(now)
                        .updateTime(now)
                        .creator((long) user.getUID())
                        .declareMonth(declareMonth).build();

                //异常点数量
                int errorSum = 0;

                //行号
                String rowIndex = String.format("第%s行", i + 2);

                //相同的姓名
                String userName = dto.getUsername();
                String deparmentName = dto.getDepartmentName();
                String mobile = dto.getMobile();
                String workcode = dto.getJobNum();
                String idNo = dto.getIdNo();
                List<Long> employeeSameIds = new ArrayList<>();

                //筛选导入人员信息可以在人力资源池中匹配到的人员信息
                List<DataCollectionEmployee> emps = getSalaryEmployeeService(user).matchImportEmployee(confValue, employees, userName, deparmentName, mobile, workcode, idNo, null);
                //含在职和离职，选在职数据
                if (CollectionUtils.isNotEmpty(emps) && emps.size() > 1) {
                    employeeSameIds = emps.stream()
                            .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }
                if (CollectionUtils.isNotEmpty(emps) && emps.size() == 1) {
                    employeeSameIds = emps.stream()
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }

                //当人员信息导入筛选的全局配置为"0"时，姓名才是必填项
                if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
                    //姓名 不能为空
                    //错误消息对象
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "姓名不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else if (CollectionUtils.isEmpty(employeeSameIds) || employeeSameIds.size() > 1) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0) : null;
                    if (employeeId != null && employeeId > 0) {
                        po.setEmployeeId(employeeId);
                    } else {
                        //姓名错误，系统内不存在该姓名
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                String taxAgentName = dto.getTaxAgentName();
                if (StringUtils.isBlank(taxAgentName)) {
                    //个税扣缴义务人不能为空
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "个税扣缴义务人不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Optional<TaxAgentManageRangeEmployeeDTO> optionalTemp = taxAgentList.stream().filter(m -> m.getTaxAgentName().equals(taxAgentName)).findFirst();
                    if (optionalTemp.isPresent()) {
                        po.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                        taxAgentEmployees = optionalTemp.get().getEmployeeList();
                    } else {
                        //个税扣缴义务人不存在
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "个税扣缴义务人不存在或不在权限范围内");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }

                //免税收入
                String freeIncome = dto.getFreeIncome();
                po.setFreeIncome(freeIncome);
                //减免税额
                String derateDeduction = dto.getDerateDeduction();
                po.setDerateDeduction(derateDeduction);
                //商业健康保险
                String businessHealthyInsurance = dto.getBusinessHealthyInsurance();
                po.setBusinessHealthyInsurance(businessHealthyInsurance);
                //税延养老保险
                String taxDelayEndowmentInsurance = dto.getTaxDelayEndowmentInsurance();
                po.setTaxDelayEndowmentInsurance(taxDelayEndowmentInsurance);
                //其他
                String otherDeduction = dto.getOtherDeduction();
                po.setOtherDeduction(otherDeduction);
                //准予扣除的捐赠额
                String deductionAllowedDonation = dto.getDeductionAllowedDonation();
                po.setDeductionAllowedDonation(deductionAllowedDonation);
                //个人养老金
                String privatePension = dto.getPrivatePension();
                po.setPrivatePension(privatePension);


                // 判断是否有核算过
                if (CollectionUtils.isNotEmpty(salaryAcctEmployees)) {
                    OtherDeductionPO finalPo = po;
                    Optional<SalaryAcctEmployeePO> optionalAcctEmp = salaryAcctEmployees.stream().filter(f -> f.getEmployeeId().equals(finalPo.getEmployeeId()) && f.getTaxAgentId().equals(finalPo.getTaxAgentId())).findFirst();
                    boolean isExist = list.stream().anyMatch(f -> f.getEmployeeId().equals(finalPo.getEmployeeId()) && f.getTaxAgentId().equals(finalPo.getTaxAgentId()));
                    if (optionalAcctEmp.isPresent() && isExist) {
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "该年月这条数据已经核算过，不可导入");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                if (errorSum == 0) {
                    successCount += 1;
                    // 合格数据
                    eligibleData.add(po);
                } else {
                    errorCount += 1;
                    // 添加错误数据
                }
            }

            //入库
            OtherDeductionBiz.handleImportData(eligibleData, user);

            apidatas.put("successCount", successCount);
            apidatas.put("errorCount", errorCount);
            apidatas.put("errorData", errorData);

        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }
        return apidatas;
    }

    @Override
    public Map<String, Object> importDetailData(OtherDeductionImportParam importParam) {

        long currentEmployeeId = user.getUID();
        Map<String, Object> apidatas = new HashMap<String, Object>();
        OtherDeductionBiz OtherDeductionBiz = new OtherDeductionBiz();

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

        //检验参数
        checkImportParam(importParam);

        //excel文件id
        String imageId = Util.null2String(importParam.getImageId());
        Validate.notBlank(imageId, "imageId为空");
        //税款所属期
        String declareMonthStr = Util.null2String(importParam.getDeclareMonth());

        //人员信息
        List<DataCollectionEmployee> employees = getSalaryEmployeeService(user).listEmployee();
        // 获取所有个税扣缴义务人
        Collection<TaxAgentManageRangeEmployeeDTO> taxAgentList = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId);
        //税款所属期
        Date declareMonth = SalaryDateUtil.stringToDate(declareMonthStr + "-01");
        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAddUpDeductionService(user).getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        // 查询已有数据
        List<OtherDeductionPO> list = getOtherDeductionMapper().listSome(OtherDeductionPO.builder().declareMonth(declareMonth).build());

        InputStream fileInputStream = null;

        List<OtherDeductionPO> eligibleData = new ArrayList<>();

        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));

            int successCount = 0;
            int errorCount = 0;

            // 错误excel内容
            List<Map> errorData = new ArrayList<>();

            //免税收入
            List<FreeIncomeListDTO> freeIncomeList = ExcelParseHelper.parse2Map(fileInputStream, FreeIncomeListDTO.class, 0, 1, 10, "OtherDeductionTemplate.xlsx");
            for (int i = 0; i < freeIncomeList.size(); i++) {
                FreeIncomeListDTO dto = freeIncomeList.get(i);

                Date now = new Date();
                //待插入数据库对象
                OtherDeductionPO po = OtherDeductionPO.builder()
                        .declareMonth(declareMonth)
                        .freeIncomeList(new ArrayList<>())
                        .derateDeductionList(new ArrayList<>())
                        .endowmentInsuranceList(new ArrayList<>())
                        .grantDonationList(new ArrayList<>())
                        .healthInsuranceList(new ArrayList<>())
                        .otherDerateDeductionList(new ArrayList<>())
                        .personalPensionList(new ArrayList<>())
                        .createTime(now)
                        .updateTime(now)
                        .creator((long) user.getUID())
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                FreeIncomePO freeIncomePO = FreeIncomePO.builder()
                        .taxYearMonth(declareMonth)
                        .fileStatus(1)
                        .creator((long) user.getUID())
                        .createTime(now)
                        .updateTime(now)
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                //异常点数量
                int errorSum = 0;

                //行号
                String rowIndex = String.format("第%s行", i + 2);

                //相同的姓名
                String userName = dto.getUsername();
                String deparmentName = dto.getDepartmentName();
                String mobile = dto.getMobile();
                String workcode = dto.getJobNum();
                String idNo = dto.getIdNo();
                List<Long> employeeSameIds = new ArrayList<>();

                //筛选导入人员信息可以在人力资源池中匹配到的人员信息
                List<DataCollectionEmployee> emps = getSalaryEmployeeService(user).matchImportEmployee(confValue, employees, userName, deparmentName, mobile, workcode, idNo, null);
                //含在职和离职，选在职数据
                if (CollectionUtils.isNotEmpty(emps) && emps.size() > 1) {
                    employeeSameIds = emps.stream()
                            .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }
                if (CollectionUtils.isNotEmpty(emps) && emps.size() == 1) {
                    employeeSameIds = emps.stream()
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }

                //当人员信息导入筛选的全局配置为"0"时，姓名才是必填项
                if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
                    //姓名 不能为空
                    //错误消息对象
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "姓名不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else if (CollectionUtils.isEmpty(employeeSameIds) || employeeSameIds.size() > 1) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0) : null;
                    if (employeeId != null && employeeId > 0) {
                        po.setEmployeeId(employeeId);
                        freeIncomePO.setEmployeeId(employeeId);
                        freeIncomePO.setEmployeeType(DataCollectionEmployeeTypeEnum.ORGANIZATION.getValue());
                    } else {
                        //姓名错误，系统内不存在该姓名
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                String taxAgentName = dto.getTaxAgentName();
                if (StringUtils.isBlank(taxAgentName)) {
                    //个税扣缴义务人不能为空
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "个税扣缴义务人不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Optional<TaxAgentManageRangeEmployeeDTO> optionalTemp = taxAgentList.stream().filter(m -> m.getTaxAgentName().equals(taxAgentName)).findFirst();
                    if (optionalTemp.isPresent()) {
                        po.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                        freeIncomePO.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                    } else {
                        //个税扣缴义务人不存在
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "个税扣缴义务人不存在或不在权限范围内");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }

                IncomeCategoryEnum incomeCategoryEnum = IncomeCategoryEnum.parseByDefaultLabel(dto.getIncomeCategoryName());
                if (incomeCategoryEnum == null) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "所得项目不存在！");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    freeIncomePO.setIncomeCategory(incomeCategoryEnum.getValue());
                }

                //免税收入
                String freeIncome = dto.getFreeItem();
                String freeProperty = dto.getFreeProperty();
                String freeAmount = dto.getFreeAmount();
                freeIncomePO.setFreeItem(freeIncome);
                freeIncomePO.setFreeProperty(freeProperty);
                freeIncomePO.setFreeAmount(freeAmount);


                if (errorSum == 0) {
                    successCount += 1;
                    String key = po.getTaxAgentId() + "-" + po.getEmployeeId();
                    Map<String, OtherDeductionPO> deductionPOMap = SalaryEntityUtil.convert2Map(eligibleData, e -> e.getTaxAgentId() + "-" + e.getEmployeeId());
                    if (deductionPOMap.containsKey(key)) {
                        deductionPOMap.get(key).getFreeIncomeList().add(freeIncomePO);
                    } else {
                        po.getFreeIncomeList().add(freeIncomePO);
                        eligibleData.add(po);
                    }

                } else {
                    errorCount += 1;
                    // 添加错误数据
                }
            }

            HashMap<Object, Object> dataMap = new HashMap<>();
            dataMap.put("successCount", successCount);
            dataMap.put("errorCount", errorCount);
            dataMap.put("errorData", errorData);
            apidatas.put("freeIncome", dataMap);

        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }

        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));

            int successCount = 0;
            int errorCount = 0;

            // 错误excel内容
            List<Map> errorData = new ArrayList<>();

            List<HealthInsuranceListDTO> dtoList = ExcelParseHelper.parse2Map(fileInputStream, HealthInsuranceListDTO.class, 1, 1, 12, "OtherDeductionTemplate.xlsx");
            for (int i = 0; i < dtoList.size(); i++) {
                HealthInsuranceListDTO dto = dtoList.get(i);

                Date now = new Date();
                //待插入数据库对象
                OtherDeductionPO mainPo = OtherDeductionPO.builder()
                        .declareMonth(declareMonth)
                        .freeIncomeList(new ArrayList<>())
                        .derateDeductionList(new ArrayList<>())
                        .endowmentInsuranceList(new ArrayList<>())
                        .grantDonationList(new ArrayList<>())
                        .healthInsuranceList(new ArrayList<>())
                        .otherDerateDeductionList(new ArrayList<>())
                        .personalPensionList(new ArrayList<>())
                        .createTime(now)
                        .updateTime(now)
                        .creator((long) user.getUID())
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                HealthInsurancePO po = HealthInsurancePO.builder()
                        .taxYearMonth(declareMonth)
                        .fileStatus(1)
                        .creator((long) user.getUID())
                        .createTime(now)
                        .updateTime(now)
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                //异常点数量
                int errorSum = 0;

                //行号
                String rowIndex = String.format("第%s行", i + 2);

                //相同的姓名
                String userName = dto.getUsername();
                String deparmentName = dto.getDepartmentName();
                String mobile = dto.getMobile();
                String workcode = dto.getJobNum();
                String idNo = dto.getIdNo();
                List<Long> employeeSameIds = new ArrayList<>();

                //筛选导入人员信息可以在人力资源池中匹配到的人员信息
                List<DataCollectionEmployee> emps = getSalaryEmployeeService(user).matchImportEmployee(confValue, employees, userName, deparmentName, mobile, workcode, idNo, null);
                //含在职和离职，选在职数据
                if (CollectionUtils.isNotEmpty(emps) && emps.size() > 1) {
                    employeeSameIds = emps.stream()
                            .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }
                if (CollectionUtils.isNotEmpty(emps) && emps.size() == 1) {
                    employeeSameIds = emps.stream()
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }

                //当人员信息导入筛选的全局配置为"0"时，姓名才是必填项
                if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
                    //姓名 不能为空
                    //错误消息对象
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "姓名不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else if (CollectionUtils.isEmpty(employeeSameIds) || employeeSameIds.size() > 1) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0) : null;
                    if (employeeId != null && employeeId > 0) {
                        mainPo.setEmployeeId(employeeId);
                        po.setEmployeeId(employeeId);
                        po.setEmployeeType(DataCollectionEmployeeTypeEnum.ORGANIZATION.getValue());
                    } else {
                        //姓名错误，系统内不存在该姓名
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                String taxAgentName = dto.getTaxAgentName();
                if (StringUtils.isBlank(taxAgentName)) {
                    //个税扣缴义务人不能为空
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "个税扣缴义务人不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Optional<TaxAgentManageRangeEmployeeDTO> optionalTemp = taxAgentList.stream().filter(m -> m.getTaxAgentName().equals(taxAgentName)).findFirst();
                    if (optionalTemp.isPresent()) {
                        mainPo.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                        po.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                    } else {
                        //个税扣缴义务人不存在
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "个税扣缴义务人不存在或不在权限范围内");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }

                IncomeCategoryEnum incomeCategoryEnum = IncomeCategoryEnum.parseByDefaultLabel(dto.getIncomeCategoryName());
                if (incomeCategoryEnum == null) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "所得项目不存在！");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    po.setIncomeCategory(incomeCategoryEnum.getValue());
                }

                po.setIdentificationNumber(dto.getIdentificationNumber());
                po.setEffectiveDate(dto.getEffectiveDate());
                po.setYearPremium(dto.getYearPremium());
                po.setMonthPremium(dto.getMonthPremium());
                po.setCurrentDeduction(dto.getCurrentDeduction());

                if (errorSum == 0) {
                    successCount += 1;
                    String key = mainPo.getTaxAgentId() + "-" + mainPo.getEmployeeId();
                    Map<String, OtherDeductionPO> deductionPOMap = SalaryEntityUtil.convert2Map(eligibleData, e -> e.getTaxAgentId() + "-" + e.getEmployeeId());
                    if (deductionPOMap.containsKey(key)) {
                        deductionPOMap.get(key).getHealthInsuranceList().add(po);
                    } else {
                        mainPo.getHealthInsuranceList().add(po);
                        eligibleData.add(mainPo);
                    }

                } else {
                    errorCount += 1;
                }
            }

            HashMap<Object, Object> dataMap = new HashMap<>();
            dataMap.put("successCount", successCount);
            dataMap.put("errorCount", errorCount);
            dataMap.put("errorData", errorData);
            apidatas.put("derateDeduction", dataMap);

        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }

        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));

            int successCount = 0;
            int errorCount = 0;

            // 错误excel内容
            List<Map> errorData = new ArrayList<>();

            List<EndowmentInsuranceListDTO> derateDeductionList = ExcelParseHelper.parse2Map(fileInputStream, EndowmentInsuranceListDTO.class, 2, 1, 13, "OtherDeductionTemplate.xlsx");
            for (int i = 0; i < derateDeductionList.size(); i++) {
                EndowmentInsuranceListDTO dto = derateDeductionList.get(i);

                Date now = new Date();
                //待插入数据库对象
                OtherDeductionPO mainPo = OtherDeductionPO.builder()
                        .declareMonth(declareMonth)
                        .freeIncomeList(new ArrayList<>())
                        .derateDeductionList(new ArrayList<>())
                        .endowmentInsuranceList(new ArrayList<>())
                        .grantDonationList(new ArrayList<>())
                        .healthInsuranceList(new ArrayList<>())
                        .otherDerateDeductionList(new ArrayList<>())
                        .personalPensionList(new ArrayList<>())
                        .createTime(now)
                        .updateTime(now)
                        .creator((long) user.getUID())
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                EndowmentInsurancePO po = EndowmentInsurancePO.builder()
                        .taxYearMonth(declareMonth)
                        .fileStatus(1)
                        .creator((long) user.getUID())
                        .createTime(now)
                        .updateTime(now)
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                //异常点数量
                int errorSum = 0;

                //行号
                String rowIndex = String.format("第%s行", i + 2);

                //相同的姓名
                String userName = dto.getUsername();
                String deparmentName = dto.getDepartmentName();
                String mobile = dto.getMobile();
                String workcode = dto.getJobNum();
                String idNo = dto.getIdNo();
                List<Long> employeeSameIds = new ArrayList<>();

                //筛选导入人员信息可以在人力资源池中匹配到的人员信息
                List<DataCollectionEmployee> emps = getSalaryEmployeeService(user).matchImportEmployee(confValue, employees, userName, deparmentName, mobile, workcode, idNo, null);
                //含在职和离职，选在职数据
                if (CollectionUtils.isNotEmpty(emps) && emps.size() > 1) {
                    employeeSameIds = emps.stream()
                            .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }
                if (CollectionUtils.isNotEmpty(emps) && emps.size() == 1) {
                    employeeSameIds = emps.stream()
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }

                //当人员信息导入筛选的全局配置为"0"时，姓名才是必填项
                if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
                    //姓名 不能为空
                    //错误消息对象
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "姓名不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else if (CollectionUtils.isEmpty(employeeSameIds) || employeeSameIds.size() > 1) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0) : null;
                    if (employeeId != null && employeeId > 0) {
                        mainPo.setEmployeeId(employeeId);
                        po.setEmployeeId(employeeId);
                        po.setEmployeeType(DataCollectionEmployeeTypeEnum.ORGANIZATION.getValue());
                    } else {
                        //姓名错误，系统内不存在该姓名
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                String taxAgentName = dto.getTaxAgentName();
                if (StringUtils.isBlank(taxAgentName)) {
                    //个税扣缴义务人不能为空
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "个税扣缴义务人不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Optional<TaxAgentManageRangeEmployeeDTO> optionalTemp = taxAgentList.stream().filter(m -> m.getTaxAgentName().equals(taxAgentName)).findFirst();
                    if (optionalTemp.isPresent()) {
                        mainPo.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                        po.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                    } else {
                        //个税扣缴义务人不存在
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "个税扣缴义务人不存在或不在权限范围内");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }

                IncomeCategoryEnum incomeCategoryEnum = IncomeCategoryEnum.parseByDefaultLabel(dto.getIncomeCategoryName());
                if (incomeCategoryEnum == null) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "所得项目不存在！");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    po.setIncomeCategory(incomeCategoryEnum.getValue());
                }

                po.setAccountNumber(dto.getAccountNumber());
                po.setCheckCode(dto.getCheckCode());
                po.setYearPremium(dto.getYearPremium());
                po.setMonthPremium(dto.getMonthPremium());
                po.setCurrentDeduction(dto.getCurrentDeduction());

                if (errorSum == 0) {
                    successCount += 1;
                    String key = mainPo.getTaxAgentId() + "-" + mainPo.getEmployeeId();
                    Map<String, OtherDeductionPO> deductionPOMap = SalaryEntityUtil.convert2Map(eligibleData, e -> e.getTaxAgentId() + "-" + e.getEmployeeId());
                    if (deductionPOMap.containsKey(key)) {
                        deductionPOMap.get(key).getEndowmentInsuranceList().add(po);
                    } else {
                        mainPo.getEndowmentInsuranceList().add(po);
                        eligibleData.add(mainPo);
                    }

                } else {
                    errorCount += 1;
                    // 添加错误数据
                }
            }

            HashMap<Object, Object> dataMap = new HashMap<>();
            dataMap.put("successCount", successCount);
            dataMap.put("errorCount", errorCount);
            dataMap.put("errorData", errorData);
            apidatas.put("derateDeduction", dataMap);

        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }


        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));

            int successCount = 0;
            int errorCount = 0;

            // 错误excel内容
            List<Map> errorData = new ArrayList<>();

            List<GrantDonationListDTO> dtoList = ExcelParseHelper.parse2Map(fileInputStream, GrantDonationListDTO.class, 3, 1, 14, "OtherDeductionTemplate.xlsx");
            for (int i = 0; i < dtoList.size(); i++) {
                GrantDonationListDTO dto = dtoList.get(i);

                Date now = new Date();
                //待插入数据库对象
                OtherDeductionPO mainPo = OtherDeductionPO.builder()
                        .declareMonth(declareMonth)
                        .freeIncomeList(new ArrayList<>())
                        .derateDeductionList(new ArrayList<>())
                        .endowmentInsuranceList(new ArrayList<>())
                        .grantDonationList(new ArrayList<>())
                        .healthInsuranceList(new ArrayList<>())
                        .otherDerateDeductionList(new ArrayList<>())
                        .personalPensionList(new ArrayList<>())
                        .createTime(now)
                        .updateTime(now)
                        .creator((long) user.getUID())
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                GrantDonationPO po = GrantDonationPO.builder()
                        .taxYearMonth(declareMonth)
                        .fileStatus(1)
                        .creator((long) user.getUID())
                        .createTime(now)
                        .updateTime(now)
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                //异常点数量
                int errorSum = 0;

                //行号
                String rowIndex = String.format("第%s行", i + 2);

                //相同的姓名
                String userName = dto.getUsername();
                String deparmentName = dto.getDepartmentName();
                String mobile = dto.getMobile();
                String workcode = dto.getJobNum();
                String idNo = dto.getIdNo();
                List<Long> employeeSameIds = new ArrayList<>();

                //筛选导入人员信息可以在人力资源池中匹配到的人员信息
                List<DataCollectionEmployee> emps = getSalaryEmployeeService(user).matchImportEmployee(confValue, employees, userName, deparmentName, mobile, workcode, idNo, null);
                //含在职和离职，选在职数据
                if (CollectionUtils.isNotEmpty(emps) && emps.size() > 1) {
                    employeeSameIds = emps.stream()
                            .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }
                if (CollectionUtils.isNotEmpty(emps) && emps.size() == 1) {
                    employeeSameIds = emps.stream()
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }

                //当人员信息导入筛选的全局配置为"0"时，姓名才是必填项
                if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
                    //姓名 不能为空
                    //错误消息对象
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "姓名不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else if (CollectionUtils.isEmpty(employeeSameIds) || employeeSameIds.size() > 1) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0) : null;
                    if (employeeId != null && employeeId > 0) {
                        mainPo.setEmployeeId(employeeId);
                        po.setEmployeeId(employeeId);
                        po.setEmployeeType(DataCollectionEmployeeTypeEnum.ORGANIZATION.getValue());
                    } else {
                        //姓名错误，系统内不存在该姓名
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                String taxAgentName = dto.getTaxAgentName();
                if (StringUtils.isBlank(taxAgentName)) {
                    //个税扣缴义务人不能为空
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "个税扣缴义务人不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Optional<TaxAgentManageRangeEmployeeDTO> optionalTemp = taxAgentList.stream().filter(m -> m.getTaxAgentName().equals(taxAgentName)).findFirst();
                    if (optionalTemp.isPresent()) {
                        mainPo.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                        po.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                    } else {
                        //个税扣缴义务人不存在
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "个税扣缴义务人不存在或不在权限范围内");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }

                IncomeCategoryEnum incomeCategoryEnum = IncomeCategoryEnum.parseByDefaultLabel(dto.getIncomeCategoryName());
                if (incomeCategoryEnum == null) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "所得项目不存在！");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    po.setIncomeCategory(incomeCategoryEnum.getValue());
                }

                po.setRecipientName(dto.getRecipientName());
                po.setTaxCode(dto.getTaxCode());
                po.setDonationNumber(dto.getDonationNumber());
                po.setDonateDate(dto.getDonateDate());
                po.setDonateAmount(dto.getDonateAmount());
                po.setDeductionProportion(dto.getDeductionProportion());
                po.setActualDeduction(dto.getActualDeduction());

                if (errorSum == 0) {
                    successCount += 1;
                    String key = mainPo.getTaxAgentId() + "-" + mainPo.getEmployeeId();
                    Map<String, OtherDeductionPO> deductionPOMap = SalaryEntityUtil.convert2Map(eligibleData, e -> e.getTaxAgentId() + "-" + e.getEmployeeId());
                    if (deductionPOMap.containsKey(key)) {
                        deductionPOMap.get(key).getGrantDonationList().add(po);
                    } else {
                        mainPo.getGrantDonationList().add(po);
                        eligibleData.add(mainPo);
                    }

                } else {
                    errorCount += 1;
                }
            }

            HashMap<Object, Object> dataMap = new HashMap<>();
            dataMap.put("successCount", successCount);
            dataMap.put("errorCount", errorCount);
            dataMap.put("errorData", errorData);
            apidatas.put("derateDeduction", dataMap);

        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }


        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));

            int successCount = 0;
            int errorCount = 0;

            // 错误excel内容
            List<Map> errorData = new ArrayList<>();

            List<DerateDeductionListDTO> derateDeductionList = ExcelParseHelper.parse2Map(fileInputStream, DerateDeductionListDTO.class, 4, 1, 10, "OtherDeductionTemplate.xlsx");
            for (int i = 0; i < derateDeductionList.size(); i++) {
                DerateDeductionListDTO dto = derateDeductionList.get(i);

                Date now = new Date();
                //待插入数据库对象
                OtherDeductionPO mainPo = OtherDeductionPO.builder()
                        .declareMonth(declareMonth)
                        .freeIncomeList(new ArrayList<>())
                        .derateDeductionList(new ArrayList<>())
                        .endowmentInsuranceList(new ArrayList<>())
                        .grantDonationList(new ArrayList<>())
                        .healthInsuranceList(new ArrayList<>())
                        .otherDerateDeductionList(new ArrayList<>())
                        .personalPensionList(new ArrayList<>())
                        .createTime(now)
                        .updateTime(now)
                        .creator((long) user.getUID())
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                DerateDeductionPO po = DerateDeductionPO.builder()
                        .taxYearMonth(declareMonth)
                        .fileStatus(1)
                        .creator((long) user.getUID())
                        .createTime(now)
                        .updateTime(now)
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                //异常点数量
                int errorSum = 0;

                //行号
                String rowIndex = String.format("第%s行", i + 2);

                //相同的姓名
                String userName = dto.getUsername();
                String deparmentName = dto.getDepartmentName();
                String mobile = dto.getMobile();
                String workcode = dto.getJobNum();
                String idNo = dto.getIdNo();
                List<Long> employeeSameIds = new ArrayList<>();

                //筛选导入人员信息可以在人力资源池中匹配到的人员信息
                List<DataCollectionEmployee> emps = getSalaryEmployeeService(user).matchImportEmployee(confValue, employees, userName, deparmentName, mobile, workcode, idNo, null);
                //含在职和离职，选在职数据
                if (CollectionUtils.isNotEmpty(emps) && emps.size() > 1) {
                    employeeSameIds = emps.stream()
                            .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }
                if (CollectionUtils.isNotEmpty(emps) && emps.size() == 1) {
                    employeeSameIds = emps.stream()
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }

                //当人员信息导入筛选的全局配置为"0"时，姓名才是必填项
                if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
                    //姓名 不能为空
                    //错误消息对象
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "姓名不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else if (CollectionUtils.isEmpty(employeeSameIds) || employeeSameIds.size() > 1) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0) : null;
                    if (employeeId != null && employeeId > 0) {
                        mainPo.setEmployeeId(employeeId);
                        po.setEmployeeId(employeeId);
                        po.setEmployeeType(DataCollectionEmployeeTypeEnum.ORGANIZATION.getValue());
                    } else {
                        //姓名错误，系统内不存在该姓名
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                String taxAgentName = dto.getTaxAgentName();
                if (StringUtils.isBlank(taxAgentName)) {
                    //个税扣缴义务人不能为空
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "个税扣缴义务人不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Optional<TaxAgentManageRangeEmployeeDTO> optionalTemp = taxAgentList.stream().filter(m -> m.getTaxAgentName().equals(taxAgentName)).findFirst();
                    if (optionalTemp.isPresent()) {
                        mainPo.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                        po.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                    } else {
                        //个税扣缴义务人不存在
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "个税扣缴义务人不存在或不在权限范围内");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }

                IncomeCategoryEnum incomeCategoryEnum = IncomeCategoryEnum.parseByDefaultLabel(dto.getIncomeCategoryName());
                if (incomeCategoryEnum == null) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "所得项目不存在！");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    po.setIncomeCategory(incomeCategoryEnum.getValue());
                }

                po.setDerateAmount(dto.getDerateAmount());
                po.setDerateItem(dto.getDerateItem());
                po.setDerateProperty(dto.getDerateProperty());

                if (errorSum == 0) {
                    successCount += 1;
                    String key = mainPo.getTaxAgentId() + "-" + mainPo.getEmployeeId();
                    Map<String, OtherDeductionPO> deductionPOMap = SalaryEntityUtil.convert2Map(eligibleData, e -> e.getTaxAgentId() + "-" + e.getEmployeeId());
                    if (deductionPOMap.containsKey(key)) {
                        deductionPOMap.get(key).getDerateDeductionList().add(po);
                    } else {
                        mainPo.getDerateDeductionList().add(po);
                        eligibleData.add(mainPo);
                    }

                } else {
                    errorCount += 1;
                    // 添加错误数据
                }
            }

            HashMap<Object, Object> dataMap = new HashMap<>();
            dataMap.put("successCount", successCount);
            dataMap.put("errorCount", errorCount);
            dataMap.put("errorData", errorData);
            apidatas.put("derateDeduction", dataMap);

        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }

        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));

            int successCount = 0;
            int errorCount = 0;

            // 错误excel内容
            List<Map> errorData = new ArrayList<>();

            List<OtherDerateDeductionListDTO> dtoList = ExcelParseHelper.parse2Map(fileInputStream, OtherDerateDeductionListDTO.class, 5, 1, 9, "OtherDeductionTemplate.xlsx");
            for (int i = 0; i < dtoList.size(); i++) {
                OtherDerateDeductionListDTO dto = dtoList.get(i);

                Date now = new Date();
                //待插入数据库对象
                OtherDeductionPO mainPo = OtherDeductionPO.builder()
                        .declareMonth(declareMonth)
                        .freeIncomeList(new ArrayList<>())
                        .derateDeductionList(new ArrayList<>())
                        .endowmentInsuranceList(new ArrayList<>())
                        .grantDonationList(new ArrayList<>())
                        .healthInsuranceList(new ArrayList<>())
                        .otherDerateDeductionList(new ArrayList<>())
                        .personalPensionList(new ArrayList<>())
                        .createTime(now)
                        .updateTime(now)
                        .creator((long) user.getUID())
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                OtherDerateDeductionPO po = OtherDerateDeductionPO.builder()
                        .taxYearMonth(declareMonth)
                        .fileStatus(1)
                        .creator((long) user.getUID())
                        .createTime(now)
                        .updateTime(now)
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                //异常点数量
                int errorSum = 0;

                //行号
                String rowIndex = String.format("第%s行", i + 2);

                //相同的姓名
                String userName = dto.getUsername();
                String deparmentName = dto.getDepartmentName();
                String mobile = dto.getMobile();
                String workcode = dto.getJobNum();
                String idNo = dto.getIdNo();
                List<Long> employeeSameIds = new ArrayList<>();

                //筛选导入人员信息可以在人力资源池中匹配到的人员信息
                List<DataCollectionEmployee> emps = getSalaryEmployeeService(user).matchImportEmployee(confValue, employees, userName, deparmentName, mobile, workcode, idNo, null);
                //含在职和离职，选在职数据
                if (CollectionUtils.isNotEmpty(emps) && emps.size() > 1) {
                    employeeSameIds = emps.stream()
                            .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }
                if (CollectionUtils.isNotEmpty(emps) && emps.size() == 1) {
                    employeeSameIds = emps.stream()
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }

                //当人员信息导入筛选的全局配置为"0"时，姓名才是必填项
                if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
                    //姓名 不能为空
                    //错误消息对象
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "姓名不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else if (CollectionUtils.isEmpty(employeeSameIds) || employeeSameIds.size() > 1) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0) : null;
                    if (employeeId != null && employeeId > 0) {
                        mainPo.setEmployeeId(employeeId);
                        po.setEmployeeId(employeeId);
                        po.setEmployeeType(DataCollectionEmployeeTypeEnum.ORGANIZATION.getValue());
                    } else {
                        //姓名错误，系统内不存在该姓名
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                String taxAgentName = dto.getTaxAgentName();
                if (StringUtils.isBlank(taxAgentName)) {
                    //个税扣缴义务人不能为空
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "个税扣缴义务人不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Optional<TaxAgentManageRangeEmployeeDTO> optionalTemp = taxAgentList.stream().filter(m -> m.getTaxAgentName().equals(taxAgentName)).findFirst();
                    if (optionalTemp.isPresent()) {
                        mainPo.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                        po.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                    } else {
                        //个税扣缴义务人不存在
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "个税扣缴义务人不存在或不在权限范围内");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }

                IncomeCategoryEnum incomeCategoryEnum = IncomeCategoryEnum.parseByDefaultLabel(dto.getIncomeCategoryName());
                if (incomeCategoryEnum == null) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "所得项目不存在！");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    po.setIncomeCategory(incomeCategoryEnum.getValue());
                }

                po.setOtherDeduction(dto.getOtherDeduction());
                po.setRemark(dto.getRemark());


                if (errorSum == 0) {
                    successCount += 1;
                    String key = mainPo.getTaxAgentId() + "-" + mainPo.getEmployeeId();
                    Map<String, OtherDeductionPO> deductionPOMap = SalaryEntityUtil.convert2Map(eligibleData, e -> e.getTaxAgentId() + "-" + e.getEmployeeId());
                    if (deductionPOMap.containsKey(key)) {
                        deductionPOMap.get(key).getOtherDerateDeductionList().add(po);
                    } else {
                        mainPo.getOtherDerateDeductionList().add(po);
                        eligibleData.add(mainPo);
                    }

                } else {
                    errorCount += 1;
                }
            }

            HashMap<Object, Object> dataMap = new HashMap<>();
            dataMap.put("successCount", successCount);
            dataMap.put("errorCount", errorCount);
            dataMap.put("errorData", errorData);
            apidatas.put("derateDeduction", dataMap);

        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }


        try {
            fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));

            int successCount = 0;
            int errorCount = 0;

            // 错误excel内容
            List<Map> errorData = new ArrayList<>();

            List<PersonalPensionListDTO> dtoList = ExcelParseHelper.parse2Map(fileInputStream, PersonalPensionListDTO.class, 6, 1, 10, "OtherDeductionTemplate.xlsx");
            for (int i = 0; i < dtoList.size(); i++) {
                PersonalPensionListDTO dto = dtoList.get(i);

                Date now = new Date();
                //待插入数据库对象
                OtherDeductionPO mainPo = OtherDeductionPO.builder()
                        .declareMonth(declareMonth)
                        .freeIncomeList(new ArrayList<>())
                        .derateDeductionList(new ArrayList<>())
                        .endowmentInsuranceList(new ArrayList<>())
                        .grantDonationList(new ArrayList<>())
                        .healthInsuranceList(new ArrayList<>())
                        .otherDerateDeductionList(new ArrayList<>())
                        .personalPensionList(new ArrayList<>())
                        .createTime(now)
                        .updateTime(now)
                        .creator((long) user.getUID())
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                PersonalPensionPO po = PersonalPensionPO.builder()
                        .taxYearMonth(declareMonth)
                        .fileStatus(1)
                        .creator((long) user.getUID())
                        .createTime(now)
                        .updateTime(now)
                        .tenantKey(DEFAULT_TENANT_KEY)
                        .build();

                //异常点数量
                int errorSum = 0;

                //行号
                String rowIndex = String.format("第%s行", i + 2);

                //相同的姓名
                String userName = dto.getUsername();
                String deparmentName = dto.getDepartmentName();
                String mobile = dto.getMobile();
                String workcode = dto.getJobNum();
                String idNo = dto.getIdNo();
                List<Long> employeeSameIds = new ArrayList<>();

                //筛选导入人员信息可以在人力资源池中匹配到的人员信息
                List<DataCollectionEmployee> emps = getSalaryEmployeeService(user).matchImportEmployee(confValue, employees, userName, deparmentName, mobile, workcode, idNo, null);
                //含在职和离职，选在职数据
                if (CollectionUtils.isNotEmpty(emps) && emps.size() > 1) {
                    employeeSameIds = emps.stream()
                            .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }
                if (CollectionUtils.isNotEmpty(emps) && emps.size() == 1) {
                    employeeSameIds = emps.stream()
                            .map(DataCollectionEmployee::getEmployeeId)
                            .collect(Collectors.toList());
                }

                //当人员信息导入筛选的全局配置为"0"时，姓名才是必填项
                if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
                    //姓名 不能为空
                    //错误消息对象
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "姓名不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else if (CollectionUtils.isEmpty(employeeSameIds) || employeeSameIds.size() > 1) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0) : null;
                    if (employeeId != null && employeeId > 0) {
                        mainPo.setEmployeeId(employeeId);
                        po.setEmployeeId(employeeId);
                        po.setEmployeeType(DataCollectionEmployeeTypeEnum.ORGANIZATION.getValue());
                    } else {
                        //姓名错误，系统内不存在该姓名
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                String taxAgentName = dto.getTaxAgentName();
                if (StringUtils.isBlank(taxAgentName)) {
                    //个税扣缴义务人不能为空
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "个税扣缴义务人不能为空");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    Optional<TaxAgentManageRangeEmployeeDTO> optionalTemp = taxAgentList.stream().filter(m -> m.getTaxAgentName().equals(taxAgentName)).findFirst();
                    if (optionalTemp.isPresent()) {
                        mainPo.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                        po.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                    } else {
                        //个税扣缴义务人不存在
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "个税扣缴义务人不存在或不在权限范围内");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }

                IncomeCategoryEnum incomeCategoryEnum = IncomeCategoryEnum.parseByDefaultLabel(dto.getIncomeCategoryName());
                if (incomeCategoryEnum == null) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "所得项目不存在！");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else {
                    po.setIncomeCategory(incomeCategoryEnum.getValue());
                }

                po.setVoucherTypeName(dto.getVoucherTypeName());
                po.setVoucherNo(dto.getVoucherNo());
                po.setPayAmount(dto.getPayAmount());


                if (errorSum == 0) {
                    successCount += 1;
                    String key = mainPo.getTaxAgentId() + "-" + mainPo.getEmployeeId();
                    Map<String, OtherDeductionPO> deductionPOMap = SalaryEntityUtil.convert2Map(eligibleData, e -> e.getTaxAgentId() + "-" + e.getEmployeeId());
                    if (deductionPOMap.containsKey(key)) {
                        deductionPOMap.get(key).getPersonalPensionList().add(po);
                    } else {
                        mainPo.getPersonalPensionList().add(po);
                        eligibleData.add(mainPo);
                    }
                } else {
                    errorCount += 1;
                }
            }

            HashMap<Object, Object> dataMap = new HashMap<>();
            dataMap.put("successCount", successCount);
            dataMap.put("errorCount", errorCount);
            dataMap.put("errorData", errorData);
            apidatas.put("derateDeduction", dataMap);

        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }

        eligibleData.forEach(po -> {
            //列表转为属性数据
            po.handleList();

            //清除旧数据
            OtherDeductionPO otherDeductionPO = getOtherDeductionMapper().getByTaxAgentIdAndEmployeeIdAndDeclareMonth(po.getTaxAgentId(), po.getEmployeeId(), po.getDeclareMonth());
            if (otherDeductionPO != null) {
                getOtherDeductionMapper().delete(otherDeductionPO);
                getFreeIncomeMapper().deleteByMainId(otherDeductionPO.getId());
                getHealthInsuranceMapper().deleteByMainId(otherDeductionPO.getId());
                getEndowmentInsuranceMapper().deleteByMainId(otherDeductionPO.getId());
                getGrantDonationMapper().deleteByMainId(otherDeductionPO.getId());
                getDerateDeductionMapper().deleteByMainId(otherDeductionPO.getId());
                getOtherDerateDeductionMapper().deleteByMainId(otherDeductionPO.getId());
                getPersonalPensionMapper().deleteByMainId(otherDeductionPO.getId());
            }

            //更新主表
            getOtherDeductionMapper().insertIgnoreNull(po);

            //更新各项明细
            po.getFreeIncomeList().forEach(l -> {
                l.setId(IdGenerator.generate());
                l.setMainId(po.getId());
                getFreeIncomeMapper().insertIgnoreNull(l);
            });
            po.getHealthInsuranceList().forEach(l -> {
                l.setId(IdGenerator.generate());
                l.setMainId(po.getId());
                getHealthInsuranceMapper().insertIgnoreNull(l);
            });
            po.getEndowmentInsuranceList().forEach(l -> {
                l.setId(IdGenerator.generate());
                l.setMainId(po.getId());
                getEndowmentInsuranceMapper().insertIgnoreNull(l);
            });
            po.getGrantDonationList().forEach(l -> {
                l.setId(IdGenerator.generate());
                l.setMainId(po.getId());
                getGrantDonationMapper().insertIgnoreNull(l);
            });
            po.getDerateDeductionList().forEach(l -> {
                l.setId(IdGenerator.generate());
                l.setMainId(po.getId());
                getDerateDeductionMapper().insertIgnoreNull(l);
            });
            po.getOtherDerateDeductionList().forEach(l -> {
                l.setId(IdGenerator.generate());
                l.setMainId(po.getId());
                getOtherDerateDeductionMapper().insertIgnoreNull(l);
            });
            po.getPersonalPensionList().forEach(l -> {
                l.setId(IdGenerator.generate());
                l.setMainId(po.getId());
                getPersonalPensionMapper().insertIgnoreNull(l);
            });

            syncMain(po.getId(), Arrays.asList(TaxFreeTypeEnum.FREE_INCOME,
                    TaxFreeTypeEnum.HEALTH_INSURANCE,
                    TaxFreeTypeEnum.ENDOWMENT_INSURANCE,
                    TaxFreeTypeEnum.GRANT_DONATION,
                    TaxFreeTypeEnum.DERATE_DEDUCTION,
                    TaxFreeTypeEnum.OTHER_DERATE_DEDUCTION,
                    TaxFreeTypeEnum.PERSONAL_PENSION));
        });

        return apidatas;
    }

    /**
     * 处理导入数据
     *
     * @param pos
     */
    public void handleImportData(List<OtherDeductionPO> pos) {
        if (CollectionUtils.isEmpty(pos)) {
            return;
        }
        OtherDeductionBiz otherDeductionBiz = new OtherDeductionBiz();
        OtherDeductionPO po = pos.get(0);
        // 多条相同人的则以第一条为准，如果逆序排列（用于重复的则以最后一条为准）Collections.reverse(pos);
        // 去重（通过记录的唯一条件(申报月份，人员id，个税扣缴义务人id)拼接）
        List<OtherDeductionPO> finalPos = pos.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getEmployeeId() + "-" + f.getTaxAgentId()))), ArrayList::new));
        // 查询已有数据
        List<OtherDeductionPO> list = otherDeductionBiz.listSome(OtherDeductionPO.builder().declareMonth(po.getDeclareMonth()).build());
        // 待修改的 本地已存在则更新【交集】
        List<OtherDeductionPO> updateList = list.stream().map(m -> {
            Optional<OtherDeductionPO> optional = finalPos.stream().filter(p -> (p.getEmployeeId() + "-" + p.getTaxAgentId()).equals(m.getEmployeeId() + "-" + m.getTaxAgentId())).findFirst();
            OtherDeductionPO temp = null;
            if (optional.isPresent()) {
                temp = optional.get();
                // 换成本地库的id
                temp.setId(m.getId());
            }
            return temp;
        }).filter(Objects::nonNull).collect(Collectors.toList());
        // 待新增的 导入比本地多，则新增【差集(导入 - local)】
        List<OtherDeductionPO> saveList = finalPos.stream().map(m -> {
            Optional<OtherDeductionPO> optional = list.stream().filter(p -> (p.getEmployeeId() + "-" + p.getTaxAgentId()).equals(m.getEmployeeId() + "-" + m.getTaxAgentId())).findFirst();
            OtherDeductionPO temp = null;
            if (!optional.isPresent()) {
                temp = m;
            }
            return temp;
        }).filter(Objects::nonNull).collect(Collectors.toList());

        // 修改
        if (CollectionUtils.isNotEmpty(updateList)) {
            otherDeductionBiz.batchUpdate(updateList);
        }
        // 保存
        if (CollectionUtils.isNotEmpty(saveList)) {
            otherDeductionBiz.batchSave(saveList);
        }
        // 记录日志
        // 根据月份、人员id查出保存的数据
        List<Long> empIds = saveList.stream().map(OtherDeductionPO::getEmployeeId).collect(Collectors.toList());
        List<OtherDeductionPO> insertList = otherDeductionBiz.listSome(OtherDeductionPO.builder().declareMonth(po.getDeclareMonth()).employeeIds(empIds).build());
        Map<String, OtherDeductionPO> insertMap = SalaryEntityUtil.convert2Map(insertList, p -> p.getTaxAgentId() + "-" + SalaryDateUtil.getFormatYearMonth(p.getDeclareMonth()) + "-" + p.getEmployeeId());
        saveList.forEach(save -> {
            OtherDeductionPO otherDeductionPO = insertMap.get(save.getTaxAgentId() + "-" + SalaryDateUtil.getFormatYearMonth(save.getDeclareMonth()) + "-" + save.getEmployeeId());
            if (otherDeductionPO != null) {
                updateList.add(otherDeductionPO);
            }
        });

        if (CollectionUtils.isNotEmpty(updateList)) {
            LoggerContext loggerContext = new LoggerContext<>();
            loggerContext.setUser(user);
            if (updateList.size() == 1) {
                loggerContext.setTargetId(updateList.get(0).getId().toString());
            }
            loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(0, "其他免税扣除"));
            loggerContext.setOperateType(OperateTypeEnum.ADD.getValue());
            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "新增"));
            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "新增其他免税扣除"));
            loggerContext.setNewValueList(updateList);
            SalaryElogConfig.otherDeductionLoggerTemplate.write(loggerContext);
        }
    }

    private void checkImportParam(OtherDeductionImportParam importParam) {
        //excel文件id
        String imageId = Util.null2String(importParam.getImageId());
        //税款所属期
        String declareMonthStr = Util.null2String(importParam.getDeclareMonth());

        if (StringUtils.isBlank(imageId)) {
            throw new SalaryRunTimeException("文件不存在");
        }
        if (StringUtils.isBlank(declareMonthStr)) {
            throw new SalaryRunTimeException("税款所属期为空");
        }
    }


    /**
     * 导出
     *
     * @param param
     * @return
     */
    public XSSFWorkbook export(OtherDeductionQueryParam param) {

        //获取操作按钮资源
        List<List<Object>> rowList = getExcelRowList(param, true);

        // 记录日志
        String name = SalaryI18nUtil.getI18nLabel(0, "导出");
        LoggerContext<OtherDeductionPO> loggerContext = new LoggerContext<>();
        loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(0, "其他免税扣除"));
        loggerContext.setOperateType(OperateTypeEnum.EXCEL_EXPORT.getValue());
        loggerContext.setOperateTypeName(name);
        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "其他免税扣除") + "-" + name);
        loggerContext.setUser(user);
        SalaryElogConfig.otherDeductionLoggerTemplate.write(loggerContext);

        //获取excel
        return ExcelUtil.genWorkbookV2WithDefaultPattern(rowList, "其他免税扣除", 2);
    }


    /**
     * 获取excel数据行
     *
     * @return 导出数据行集合
     */
    private List<List<Object>> getExcelRowList(OtherDeductionQueryParam param, boolean hasData) {
        long employeeId = user.getUID();
        //excel标题
        List<Object> title = Arrays.asList("姓名", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "入职日期", "免税收入", "商业健康保险", "税延养老保险", "准予扣除的捐赠额", "减免税额", "其他", "个人养老金");
        List<List<Object>> rowList = new ArrayList<>();
        rowList.add(title);

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

            List<OtherDeductionListDTO> list = getOtherDeductionMapper().list(param);
            encryptUtil.decryptList(list, OtherDeductionListDTO.class);
            SalaryI18nUtil.i18nList(list);
            // 开启分权并且不是薪酬模块总管理员
            if (getTaxAgentService(user).isOpenDevolution() && !getTaxAgentService(user).isChief(employeeId)) {
                List<Long> taxAgentIdsAsAdmin = getTaxAgentService(user).listAllTaxAgentsAsAdmin(employeeId).stream().map(TaxAgentPO::getId).collect(Collectors.toList());
                list = list.stream().filter(f ->
                        // 作为管理员
                        taxAgentIdsAsAdmin.contains(f.getTaxAgentId())
                ).collect(Collectors.toList());
            }

            final List<List<Object>> dataRowList = Optional.ofNullable(list)
                    .map(List::stream)
                    .map(operatorStream -> operatorStream.map(dto -> {
                        List<Object> cellList = new ArrayList<>();
                        cellList.add(Util.null2String(dto.getUsername()));
                        cellList.add(Util.null2String(dto.getTaxAgentName()));
                        cellList.add(Util.null2String(dto.getDepartmentName()));
                        cellList.add(Util.null2String(dto.getMobile()));
                        cellList.add(Util.null2String(dto.getJobNum()));
                        cellList.add(Util.null2String(dto.getIdNo()));
                        cellList.add(Util.null2String(dto.getHiredate()));
                        cellList.add(NumberUtil.isNumber(dto.getFreeIncome()) ? new BigDecimal(dto.getFreeIncome()) : Util.null2String(dto.getFreeIncome()));
                        cellList.add(NumberUtil.isNumber(dto.getDerateDeduction()) ? new BigDecimal(dto.getDerateDeduction()) : Util.null2String(dto.getDerateDeduction()));
                        cellList.add(NumberUtil.isNumber(dto.getBusinessHealthyInsurance()) ? new BigDecimal(dto.getBusinessHealthyInsurance()) : Util.null2String(dto.getBusinessHealthyInsurance()));
                        cellList.add(NumberUtil.isNumber(dto.getTaxDelayEndowmentInsurance()) ? new BigDecimal(dto.getTaxDelayEndowmentInsurance()) : Util.null2String(dto.getTaxDelayEndowmentInsurance()));
                        cellList.add(NumberUtil.isNumber(dto.getOtherDeduction()) ? new BigDecimal(dto.getOtherDeduction()) : Util.null2String(dto.getOtherDeduction()));
                        cellList.add(NumberUtil.isNumber(dto.getDeductionAllowedDonation()) ? new BigDecimal(dto.getDeductionAllowedDonation()) : Util.null2String(dto.getDeductionAllowedDonation()));
                        cellList.add(NumberUtil.isNumber(dto.getPrivatePension()) ? new BigDecimal(dto.getPrivatePension()) : Util.null2String(dto.getPrivatePension()));
                        return cellList;
                    }).collect(Collectors.toList()))
                    .orElse(Collections.emptyList());

            rowList.addAll(dataRowList);
        }

        return rowList;
    }


    /**
     * 导出详情列表
     *
     * @param param
     * @return
     */
    public XSSFWorkbook exportDetail(OtherDeductionQueryParam param) {

        OtherDeductionBiz biz = new OtherDeductionBiz();

        Long id = param.getOtherTaxExemptDeductionId();
        if (id == null) {
            throw new SalaryRunTimeException("id不能为空");
        }

        OtherDeductionPO po = biz.getById(id);
        if (po == null) {
            throw new SalaryRunTimeException(String.format("其他免税扣除不存在" + "[id:%s]", id));
        }

        List<DataCollectionEmployee> employeeList = getSalaryEmployeeService(user).getEmployeeByIds(Collections.singletonList(po.getEmployeeId()));
        if (CollectionUtils.isEmpty(employeeList)) {
            throw new SalaryRunTimeException("员工信息不存在");
        }

        //构建参数
        param.setEmployeeId(po.getEmployeeId());
        //申报月份
        List<String> declareMonth = param.getDeclareMonth();
        if (CollectionUtils.isNotEmpty(declareMonth)) {
            param.setDeclareMonth(declareMonth.stream().map(e -> e + "-01 00:00:00").collect(Collectors.toList()));
            param.setDeclareMonthDate(declareMonth.stream().map(e -> e + "-01 00:00:00").map(SalaryDateUtil::dateStrToLocalTime).collect(Collectors.toList()));
        }


        //获取操作按钮资源
        List<List<Object>> rowList = getExcelRowDetailList(param);

        //获取excel
        return ExcelUtil.genWorkbookWithDefaultPattern(rowList, "其他免税扣除明细", 2);
    }


    /**
     * 导出详情
     *
     * @param param
     * @return
     */
    private List<List<Object>> getExcelRowDetailList(OtherDeductionQueryParam param) {
        //excel标题
        List<Object> title = Arrays.asList("姓名", "申报月份", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "入职日期", "免税收入", "商业健康保险", "税延养老保险", "准予扣除的捐赠额", "减免税额", "其他", "个人养老金");

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM");
        //查询详细信息
        List<OtherDeductionRecordDTO> list = getOtherDeductionMapper().recordList(param);
        encryptUtil.decryptList(list, OtherDeductionRecordDTO.class);
        final List<List<Object>> dataRowList = Optional.ofNullable(list)
                .map(List::stream)
                .map(operatorStream -> operatorStream.map(dto -> {
                    List<Object> cellList = new ArrayList<>();
                    cellList.add(Util.null2String(dto.getUsername()));
                    cellList.add(Util.null2String(dto.getDeclareMonth() == null ? "" : formatter.format(dto.getDeclareMonth())));
                    cellList.add(Util.null2String(dto.getTaxAgentName()));
                    cellList.add(Util.null2String(dto.getDepartmentName()));
                    cellList.add(Util.null2String(dto.getMobile()));
                    cellList.add(Util.null2String(dto.getJobNum()));
                    cellList.add(NumberUtil.isNumber(dto.getFreeIncome()) ? new BigDecimal(dto.getFreeIncome()) : Util.null2String(dto.getFreeIncome()));
                    cellList.add(NumberUtil.isNumber(dto.getDerateDeduction()) ? new BigDecimal(dto.getDerateDeduction()) : Util.null2String(dto.getDerateDeduction()));
                    cellList.add(NumberUtil.isNumber(dto.getBusinessHealthyInsurance()) ? new BigDecimal(dto.getBusinessHealthyInsurance()) : Util.null2String(dto.getBusinessHealthyInsurance()));
                    cellList.add(NumberUtil.isNumber(dto.getTaxDelayEndowmentInsurance()) ? new BigDecimal(dto.getTaxDelayEndowmentInsurance()) : Util.null2String(dto.getTaxDelayEndowmentInsurance()));
                    cellList.add(NumberUtil.isNumber(dto.getOtherDeduction()) ? new BigDecimal(dto.getOtherDeduction()) : Util.null2String(dto.getOtherDeduction()));
                    cellList.add(NumberUtil.isNumber(dto.getDeductionAllowedDonation()) ? new BigDecimal(dto.getDeductionAllowedDonation()) : Util.null2String(dto.getDeductionAllowedDonation()));
                    cellList.add(NumberUtil.isNumber(dto.getPrivatePension()) ? new BigDecimal(dto.getPrivatePension()) : Util.null2String(dto.getPrivatePension()));
                    return cellList;
                }).collect(Collectors.toList()))
                .orElse(Collections.emptyList());

        List<List<Object>> rowList = new ArrayList<>();
        rowList.add(title);
        rowList.addAll(dataRowList);
        return rowList;
    }


    @Override
    public List<OtherDeductionPO> getOtherDeductionList(YearMonth declareMonth, List<Long> employeeIds, Long taxAgentId) {
        if (declareMonth == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100342, "参数有误：申报月份必传"));
        }
        OtherDeductionBiz OtherDeductionBiz = new OtherDeductionBiz();
        return OtherDeductionBiz.listSome(OtherDeductionPO.builder().declareMonth(SalaryDateUtil.toDateStartOfMonth(declareMonth)).employeeIds(employeeIds).taxAgentId(taxAgentId).build());
    }

    @Override
    public void editData(OtherDeductionParam otherDeductionParam) {
        String declareMonthStr = otherDeductionParam.getDeclareMonth();
        OtherDeductionBiz OtherDeductionBiz = new OtherDeductionBiz();

        Long currentEmployeeId = (long) user.getUID();
        // 获取所有个税扣缴义务人
        Collection<TaxAgentManageRangeEmployeeDTO> taxAgentList = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId);
        OtherDeductionPO byId = OtherDeductionBiz.getById(otherDeductionParam.getId());
        if (byId == null) {
            throw new SalaryRunTimeException("该数据不存在！");
        }
        Long taxAgentId = byId.getTaxAgentId();
        boolean canEdit = taxAgentList.stream().anyMatch(t -> Objects.equals(t.getTaxAgentId(), taxAgentId));
        if (!canEdit) {
            //没有编辑权限
            throw new SalaryRunTimeException("该个税扣缴义务人无权限编辑此数据！");
        }
        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAddUpDeductionService(user).getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        // 判断是否有核算过
        if (CollectionUtils.isNotEmpty(salaryAcctEmployees)) {
            Optional<SalaryAcctEmployeePO> optionalAcctEmp = salaryAcctEmployees.stream().filter(f -> f.getEmployeeId().equals(otherDeductionParam.getEmployeeId()) && f.getTaxAgentId().equals(otherDeductionParam.getTaxAgentId())).findFirst();
            if (optionalAcctEmp.isPresent()) {
                throw new SalaryRunTimeException("该年月这条数据已经核算过,不可进行编辑！");
            }
        }
        ArrayList<OtherDeductionPO> updateList = new ArrayList<>();
        OtherDeductionPO build = OtherDeductionPO.builder()
                .id(otherDeductionParam.getId())
                .freeIncome(otherDeductionParam.getFreeIncome())
                .derateDeduction(otherDeductionParam.getDerateDeduction())
                .businessHealthyInsurance(otherDeductionParam.getBusinessHealthyInsurance())
                .taxDelayEndowmentInsurance(otherDeductionParam.getTaxDelayEndowmentInsurance())
                .otherDeduction(otherDeductionParam.getOtherDeduction())
                .deductionAllowedDonation(otherDeductionParam.getDeductionAllowedDonation())
                .privatePension(otherDeductionParam.getPrivatePension())
                .updateTime(new Date())
                .build();
        updateList.add(build);
        OtherDeductionBiz.batchUpdate(updateList);

        // 记录日志
        OtherDeductionPO newValue = OtherDeductionBiz.getById(build.getId());
        String name = SalaryI18nUtil.getI18nLabel(0, "编辑");
        LoggerContext<AddUpDeduction> loggerContext = new LoggerContext<>();
        loggerContext.setTargetId(newValue.getId().toString());
        loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(0, "其他免税扣除") + "-" + newValue.getId());
        loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
        loggerContext.setOperateTypeName(name);
        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "其他免税扣除") + "-" + SalaryI18nUtil
                .getI18nLabel(0, "编辑"));
        loggerContext.setOldValues(byId);
        loggerContext.setNewValues(newValue);
        loggerContext.setUser(user);
        SalaryElogConfig.otherDeductionLoggerTemplate.write(loggerContext);
    }

    @Override
    public void createData(OtherDeductionParam otherDeductionParam) {
        long currentEmployeeId = user.getUID();
        Boolean openDevolution = getTaxAgentService(user).isOpenDevolution();
        OtherDeductionBiz OtherDeductionBiz = new OtherDeductionBiz();
        //查询对于人员信息导入筛选的全局配置
        SalarySysConfPO salarySysConfPO = getSalarySysConfMapper().getOneByCode("matchEmployeeMode");
        String confValue = (salarySysConfPO != null && salarySysConfPO.getConfValue() != null && !"".equals(salarySysConfPO.getConfValue())) ? salarySysConfPO.getConfValue() : "0";

        //税款所属期
        String declareMonthStr = Util.null2String(otherDeductionParam.getDeclareMonth());
        //人员信息
        List<DataCollectionEmployee> employees = getSalaryEmployeeService(user).listEmployee();
        // 获取所有个税扣缴义务人
        Collection<TaxAgentManageRangeEmployeeDTO> taxAgentList = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId);
        //税款所属期
        Date declareMonth = SalaryDateUtil.stringToDate(declareMonthStr + "-01");
        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAddUpDeductionService(user).getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        // 查询已有数据
        List<OtherDeductionPO> list = getOtherDeductionMapper().listSome(OtherDeductionPO.builder().declareMonth(declareMonth).build());
        //合规数据
        List<OtherDeductionPO> insertData = new ArrayList<>();
        List<TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee> taxAgentEmployees = Lists.newArrayList();
        Date now = new Date();
        //待插入数据库对象
        OtherDeductionPO po = OtherDeductionPO.builder()
                .tenantKey(DEFAULT_TENANT_KEY)
                .createTime(now)
                .updateTime(now)
                .creator((long) user.getUID())
                .declareMonth(declareMonth).build();

        //筛选导入人员信息可以在人力资源池中匹配到的人员信息
        boolean employeeSameId = employees.stream().anyMatch(e -> Objects.equals(e.getEmployeeId(), otherDeductionParam.getEmployeeId()));
        if (!employeeSameId) {
            throw new SalaryRunTimeException("员工信息不存在");
        }
        po.setEmployeeId(otherDeductionParam.getEmployeeId());
        String taxAgentName = otherDeductionParam.getTaxAgentName();
        if (StringUtils.isBlank(taxAgentName)) {
            //个税扣缴义务人不能为空
            throw new SalaryRunTimeException("个税扣缴义务人不能为空");
        } else {
            Optional<TaxAgentManageRangeEmployeeDTO> optionalTemp = taxAgentList.stream().filter(m -> m.getTaxAgentName().equals(taxAgentName)).findFirst();
            if (optionalTemp.isPresent()) {
                po.setTaxAgentId(optionalTemp.get().getTaxAgentId());
                taxAgentEmployees = optionalTemp.get().getEmployeeList();
            } else {
                //个税扣缴义务人不存在或不在权限范围内
                throw new SalaryRunTimeException("个税扣缴义务人不存在或不在权限范围内");
            }
        }
        //免税收入
        String freeIncome = otherDeductionParam.getFreeIncome();
        po.setFreeIncome(freeIncome);
        //减免税额
        String derateDeduction = otherDeductionParam.getDerateDeduction();
        po.setDerateDeduction(derateDeduction);
        //商业健康保险
        String businessHealthyInsurance = otherDeductionParam.getBusinessHealthyInsurance();
        po.setBusinessHealthyInsurance(businessHealthyInsurance);
        //税延养老保险
        String taxDelayEndowmentInsurance = otherDeductionParam.getTaxDelayEndowmentInsurance();
        po.setTaxDelayEndowmentInsurance(taxDelayEndowmentInsurance);
        //其他
        String otherDeduction = otherDeductionParam.getOtherDeduction();
        po.setOtherDeduction(otherDeduction);
        //准予扣除的捐赠额
        String deductionAllowedDonation = otherDeductionParam.getDeductionAllowedDonation();
        po.setDeductionAllowedDonation(deductionAllowedDonation);
        //个人养老金
        String privatePension = otherDeductionParam.getPrivatePension();
        po.setPrivatePension(privatePension);


        // 判断是否有核算过
        if (CollectionUtils.isNotEmpty(salaryAcctEmployees)) {
            OtherDeductionPO finalPo = po;
            Optional<SalaryAcctEmployeePO> optionalAcctEmp = salaryAcctEmployees.stream().filter(f -> f.getEmployeeId().equals(finalPo.getEmployeeId()) && f.getTaxAgentId().equals(finalPo.getTaxAgentId())).findFirst();
            boolean isExist = list.stream().anyMatch(f -> f.getEmployeeId().equals(finalPo.getEmployeeId()) && f.getTaxAgentId().equals(finalPo.getTaxAgentId()));
            if (optionalAcctEmp.isPresent() && isExist) {
                throw new SalaryRunTimeException("该年月这条数据已经核算过,不可导入");
            }
        }
        insertData.add(po);
        //入库
        handleImportData(insertData);
    }

    @Override
    public void deleteSelectData(AddUpDeductionRecordDeleteParam deleteParam) {
        long currentEmployeeId = user.getUID();
        // 获取所有个税扣缴义务人
        Collection<TaxAgentManageRangeEmployeeDTO> taxAgentList = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId);
        OtherDeductionBiz otherDeductionBiz = new OtherDeductionBiz();
        String declareMonthStr = deleteParam.getDeclareMonth();
        List<Long> deleteIds = deleteParam.getIds();
        // 已经核算过的不可操作
        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAddUpDeductionService(user).getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        // 判断是否有核算过
        List<Long> deleteList = new ArrayList<>();
        List<OtherDeductionPO> resultList = new ArrayList<>();
        for (int i = 0; i < deleteIds.size(); i++) {
            Long id = deleteIds.get(i);
            OtherDeductionPO byId = otherDeductionBiz.getById(id);
            if (byId == null) {
                throw new SalaryRunTimeException("数据不存在或已被删除！");
            }
            // 判断是否在个税扣缴义务人范围内
            Optional<TaxAgentManageRangeEmployeeDTO> first = taxAgentList.stream().filter(m -> Objects.equals(m.getTaxAgentId(), byId.getTaxAgentId())).findFirst();
            if (!first.isPresent()) {
                throw new SalaryRunTimeException("个税扣缴义务人不存在或不在权限范围内");
            }
            // 判断用户是否存在
            if (CollectionUtils.isNotEmpty(salaryAcctEmployees)) {
                Optional<SalaryAcctEmployeePO> optionalAcctEmp = salaryAcctEmployees.stream().filter(f -> f.getEmployeeId().equals(byId.getEmployeeId()) && f.getTaxAgentId().equals(byId.getTaxAgentId())).findFirst();
                if (optionalAcctEmp.isPresent()) {
                    throw new SalaryRunTimeException("所选数据在该年月中已经核算过并归档,不可进行删除！");
                }
            }
            deleteList.add(byId.getId());
            resultList.add(byId);
        }
        otherDeductionBiz.batchDeleteByIDS(deleteList);
        // 记录日志
        resultList.stream().forEach(r -> {
            LoggerContext loggerContext = new LoggerContext<>();
            loggerContext.setTargetId(r.getId().toString());
            loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(0, "其他免税扣除") + "-" + r.getId());
            loggerContext.setOperateType(OperateTypeEnum.DELETE.getValue());
            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "删除"));
            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "其他免税扣除") + "-" + SalaryI18nUtil
                    .getI18nLabel(0, "删除"));
            loggerContext.setOldValues(r);
            loggerContext.setUser(user);
            SalaryElogConfig.otherDeductionLoggerTemplate.write(loggerContext);
        });
    }

    @Override
    public void deleteAllData(AddUpDeductionRecordDeleteParam deleteParam) {
        String declareMonthStr = deleteParam.getDeclareMonth();
        long currentEmployeeId = user.getUID();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 获取所有个税扣缴义务人
        Collection<TaxAgentManageRangeEmployeeDTO> taxAgentList = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId);
        List<Long> taxAgentIds = taxAgentList.stream().map(TaxAgentManageRangeEmployeeDTO::getTaxAgentId).collect(Collectors.toList());
        OtherDeductionBiz otherDeductionBiz = new OtherDeductionBiz();
        Date declareMonthDate = null;
        try {
            declareMonthDate = sdf.parse(declareMonthStr + "-01");
        } catch (Exception e) {
            throw new SalaryRunTimeException("日期异常");
        }

        OtherDeductionPO queryParam = null;
        if (deleteParam.getTaxAgentId() != null && (!deleteParam.getTaxAgentId().equals(""))) {
            // 设置了个税扣缴义务人
            Long taxAgentId = SalaryEntityUtil.string2Long(deleteParam.getTaxAgentId());
            boolean canDelete = taxAgentIds.stream().anyMatch(t -> Objects.equals(t, taxAgentId));
            if (!canDelete) {
                throw new SalaryRunTimeException("个税扣缴义务人不存在或不在权限范围内!");
            }
            ArrayList<Long> tai = new ArrayList<>();
            tai.add(taxAgentId);
            queryParam = OtherDeductionPO.builder().declareMonth(declareMonthDate).taxAgentIds(tai).build();
        } else {
            queryParam = OtherDeductionPO.builder().declareMonth(declareMonthDate).taxAgentIds(taxAgentIds).build();
        }
        // 获取所有想要删除的数据
        List<OtherDeductionPO> list = otherDeductionBiz.listSome(queryParam);
        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAddUpDeductionService(user).getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        for (OtherDeductionPO item : list) {
            if (CollectionUtils.isNotEmpty(salaryAcctEmployees)) {
                Optional<SalaryAcctEmployeePO> optionalAcctEmp = salaryAcctEmployees.stream().filter(f -> f.getEmployeeId().equals(item.getEmployeeId()) && f.getTaxAgentId().equals(item.getTaxAgentId())).findFirst();
                if (optionalAcctEmp.isPresent()) {
                    throw new SalaryRunTimeException("有员工在该年月中已经完成核算并归档，不能进行一键清空！");
                }
            }
        }
        List<Long> deleteIds = list.stream().map(OtherDeductionPO::getId).collect(Collectors.toList());
        otherDeductionBiz.batchDeleteByIDS(deleteIds);

        // 记录日志
        Collection<Long> finalTaxAgentIds = queryParam.getTaxAgentIds();
        List<String> taxAgentNames = taxAgentList.stream().filter(t -> finalTaxAgentIds.contains(t.getTaxAgentId()))
                .map(TaxAgentManageRangeEmployeeDTO::getTaxAgentName).collect(Collectors.toList());
        String name = declareMonthStr + " " + StringUtils.join(taxAgentNames, ",");
        LoggerContext<OtherDeductionPO> loggerContext = new LoggerContext<>();
        loggerContext.setTargetName(name);
        loggerContext.setOperateType(OperateTypeEnum.CLEAR.getValue());
        loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "一键清空"));
        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "其他免税扣除") + "-" + SalaryI18nUtil
                .getI18nLabel(0, "一键清空：") + name);
        loggerContext.setUser(user);
        SalaryElogConfig.otherDeductionLoggerTemplate.write(loggerContext);
    }

    @Override
    public OtherDeductionRecordDTO getOtherDeduction(OtherDeductionParam otherDeductionParam) {
        long uid = user.getUID();
        // 获取所有个税扣缴义务人
        Collection<TaxAgentManageRangeEmployeeDTO> taxAgentList = getTaxAgentService(user).listTaxAgentAndEmployeeTree(uid);
        List<String> taxAgentNames = taxAgentList.stream().map(TaxAgentManageRangeEmployeeDTO::getTaxAgentName).collect(Collectors.toList());
        ArrayList<Long> ids = new ArrayList<>();
        ids.add(otherDeductionParam.getId());
        OtherDeductionQueryParam build = OtherDeductionQueryParam.builder().ids(ids).build();
        List<OtherDeductionRecordDTO> list = getOtherDeductionMapper().recordList(build);
        encryptUtil.decryptList(list, OtherDeductionRecordDTO.class);

        if (list == null || list.size() == 0) {
            throw new SalaryRunTimeException("该数据不存在！");
        }
        String taxAgentName = list.get(0).getTaxAgentName();
        if (!taxAgentNames.contains(taxAgentName)) {
            throw new SalaryRunTimeException("您无权查看该数据!");
        }
        return list.get(0);
    }

    @Override
    public String extendToLastMonth(OtherDeductionExtendLastParam param) {
        //查询已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAddUpDeductionService(user).getAccountedEmployeeDataByTaxYearMonth(param.getDeclareMonth());
        Map<String, List<SalaryAcctEmployeePO>> acctInfoMap = salaryAcctEmployees.stream()
                .distinct().collect(Collectors.groupingBy(
                        i -> i.getTaxAgentId() + "" + i.getEmployeeId()));

        // 查找到所有个税扣缴义务人
        Boolean needAuth = getTaxAgentService(user).isNeedAuth((long) user.getUID());
        Collection<TaxAgentPO> taxAgentPOS;
        if (needAuth) {
            taxAgentPOS = getTaxAgentService(user).listAllTaxAgentsAsAdmin((long) user.getUID());
        } else {
            taxAgentPOS = getTaxAgentService(user).listAll();
        }
        List<Long> taxAgentIds = taxAgentPOS.stream().map(TaxAgentPO::getId).collect(Collectors.toList());

        //查询上月数据
        LocalDateTime lastMonth = param.getYearMonthTime().minusMonths(1);
        OtherDeductionQueryParam queryParam = OtherDeductionQueryParam.builder()
                .taxAgentIds(taxAgentIds)
                .declareMonthDate(Collections.singletonList(
                        SalaryDateUtil.toDate(lastMonth))
                ).build();
        List<OtherDeductionListDTO> lastMonthInfo = getOtherDeductionMapper().list(queryParam);

        // 查询当前月id
        queryParam.setDeclareMonthDate(Collections.singletonList(
                SalaryDateUtil.toDate(param.getYearMonthTime())
        ));
        Map<String, Long> updateIdMap = getOtherDeductionMapper()
                .list(queryParam).stream()
                .collect(Collectors.toMap(i -> i.getEmployeeId() + "" + i.getTaxAgentId(), OtherDeductionListDTO::getId));

        List<OtherDeductionPO> insertInfo = new ArrayList<>();
        List<OtherDeductionPO> updatetInfo = new ArrayList<>();
        for (OtherDeductionListDTO dto : lastMonthInfo) {
            OtherDeductionPO po
                    = JSONObject.parseObject(JSONObject.toJSONString(dto), OtherDeductionPO.class);
            po.setDeclareMonth(SalaryDateUtil.toDate(param.getYearMonthTime()));
            po.setUpdateTime(new Date());
            po.setId(null);
            po.setTenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY);
            boolean hasOld = updateIdMap.containsKey(po.getEmployeeId() + "" + po.getTaxAgentId());
            if (hasOld && !acctInfoMap.containsKey(po.getTaxAgentId() + "" + po.getEmployeeId())) {
                //核算过的数据直接跳过不做更改
                po.setId(updateIdMap.get(po.getEmployeeId() + "" + po.getTaxAgentId()));
                updatetInfo.add(po);
            } else if (!hasOld) {
                po.setCreator((long) user.getUID());
                po.setCreateTime(new Date());
                insertInfo.add(po);
            }
        }

        getOtherDeductionBiz().batchSave(insertInfo);
        getOtherDeductionBiz().batchUpdate(updatetInfo);

        //记录日志
        // 根据月份、人员id查出保存的数据
        List<Long> empIds = insertInfo.stream().map(OtherDeductionPO::getEmployeeId).collect(Collectors.toList());
        List<OtherDeductionPO> insertList = getOtherDeductionBiz().listSome(OtherDeductionPO.builder().declareMonth(SalaryDateUtil.stringToDate(param.getDeclareMonth())).employeeIds(empIds).build());
        Map<String, OtherDeductionPO> insertMap = SalaryEntityUtil.convert2Map(insertList, p -> p.getTaxAgentId() + "-" + SalaryDateUtil.getFormatYearMonth(p.getDeclareMonth()) + "-" + p.getEmployeeId());
        insertList.forEach(save -> {
            OtherDeductionPO otherDeductionPO = insertMap.get(save.getTaxAgentId() + "-" + SalaryDateUtil.getFormatYearMonth(save.getDeclareMonth()) + "-" + save.getEmployeeId());
            if (otherDeductionPO != null) {
                updatetInfo.add(otherDeductionPO);
            }
        });

        if (CollectionUtils.isNotEmpty(updatetInfo)) {
            String yearMonthStr = SalaryDateUtil.getFormatYearMonth(lastMonth.toLocalDate());
            LoggerContext loggerContext = new LoggerContext();
            loggerContext.setUser(user);
            loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(0, "沿用上月 " + yearMonthStr));
            loggerContext.setOperateType(OperateTypeEnum.ADD.getValue());
            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "沿用上月其他免税扣除"));
            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "沿用上月 " + yearMonthStr + " 其他免税扣除"));
            loggerContext.setNewValueList(updatetInfo);
            SalaryElogConfig.otherDeductionLoggerTemplate.write(loggerContext);
        }

        return "";
    }

    @Override
    public XSSFWorkbook downloadTemplate(OtherDeductionQueryParam param) {
        // 1.工作簿名称
        String sheetName = SalaryI18nUtil.getI18nLabel(101604, "其他免税扣除导入模板");
        //获取操作按钮资源
        List<List<Object>> rowList = getExcelRowList(param, param.isHasData());

        // 4.注释
        List<ExcelComment> excelComments = Lists.newArrayList();
        excelComments.add(new ExcelComment(0, 0, 3, 2, SalaryI18nUtil.getI18nLabel(100344, "必填")));
        excelComments.add(new ExcelComment(1, 0, 4, 2, SalaryI18nUtil.getI18nLabel(100344, "必填")));
        excelComments.add(new ExcelComment(7, 0, 10, 2, SalaryI18nUtil.getI18nLabel(100344, "输入数字")));
        excelComments.add(new ExcelComment(8, 0, 11, 2, SalaryI18nUtil.getI18nLabel(100344, "输入数字")));
        excelComments.add(new ExcelComment(9, 0, 12, 2, SalaryI18nUtil.getI18nLabel(100344, "输入数字")));
        excelComments.add(new ExcelComment(10, 0, 13, 2, SalaryI18nUtil.getI18nLabel(100344, "输入数字")));
        excelComments.add(new ExcelComment(11, 0, 14, 2, SalaryI18nUtil.getI18nLabel(100344, "输入数字")));

        XSSFWorkbook book = ExcelUtil.genWorkbookV2(rowList, sheetName, excelComments);
        return book;
    }

    @Override
    public XSSFWorkbook downloadDetailTemplate(OtherDeductionQueryParam param) {


        List<FreeIncomeListDTO> freeIncomeList = new ArrayList<>();
        List<HealthInsuranceListDTO> healthInsuranceList = new ArrayList<>();
        List<EndowmentInsuranceListDTO> endowmentInsuranceList = new ArrayList<>();
        List<GrantDonationListDTO> grantDonationList = new ArrayList<>();
        List<DerateDeductionListDTO> derateDeductionList = new ArrayList<>();
        List<OtherDerateDeductionListDTO> otherDerateDeductionList = new ArrayList<>();
        List<PersonalPensionListDTO> personalPensionList = new ArrayList<>();
        if (param.isHasData()) {
            long employeeId = user.getUID();
            //排序配置
            OrderRuleVO orderRule = getSalarySysConfService(user).orderRule();
            param.setOrderRule(orderRule);

            List<OtherDeductionListDTO> list = getOtherDeductionMapper().list(param);
            encryptUtil.decryptList(list, OtherDeductionListDTO.class);
            SalaryI18nUtil.i18nList(list);
            // 开启分权并且不是薪酬模块总管理员
            if (getTaxAgentService(user).isOpenDevolution() && !getTaxAgentService(user).isChief(employeeId)) {
                List<Long> taxAgentIdsAsAdmin = getTaxAgentService(user).listAllTaxAgentsAsAdmin(employeeId).stream().map(TaxAgentPO::getId).collect(Collectors.toList());
                list = list.stream().filter(f ->
                        // 作为管理员
                        taxAgentIdsAsAdmin.contains(f.getTaxAgentId())
                ).collect(Collectors.toList());
            }
            list.forEach(dto -> {
                List<FreeIncomeListDTO> freeIncomeListDTOS = freeIncomePO2DTO(getFreeIncomeMapper().listSome(FreeIncomePO.builder().mainId(dto.getId()).build()));
                freeIncomeList.addAll(freeIncomeListDTOS);
                List<EndowmentInsuranceListDTO> endowmentInsuranceListDTOS = endowmentInsurancePO2DTO(getEndowmentInsuranceMapper().listSome(EndowmentInsurancePO.builder().mainId(dto.getId()).build()));
                endowmentInsuranceList.addAll(endowmentInsuranceListDTOS);
                List<GrantDonationListDTO> grantDonationListDTOS = grantDonationPO2DTO(getGrantDonationMapper().listSome(GrantDonationPO.builder().mainId(dto.getId()).build()));
                grantDonationList.addAll(grantDonationListDTOS);
                List<HealthInsuranceListDTO> healthInsuranceListDTOS = healthInsurancePO2DTO(getHealthInsuranceMapper().listSome(HealthInsurancePO.builder().mainId(dto.getId()).build()));
                healthInsuranceList.addAll(healthInsuranceListDTOS);
                List<OtherDerateDeductionListDTO> otherDerateDeductionListDTOS = otherDerateDeductionPO2DTO(getOtherDerateDeductionMapper().listSome(OtherDerateDeductionPO.builder().mainId(dto.getId()).build()));
                otherDerateDeductionList.addAll(otherDerateDeductionListDTOS);
                List<DerateDeductionListDTO> derateDeductionListDTOS = derateDeductionPO2DTO(getDerateDeductionMapper().listSome(DerateDeductionPO.builder().mainId(dto.getId()).build()));
                derateDeductionList.addAll(derateDeductionListDTOS);
                List<PersonalPensionListDTO> personalPensionListDTOS = personalPensionPO2DTO(getPersonalPensionMapper().listSome(PersonalPensionPO.builder().mainId(dto.getId()).build()));
                personalPensionList.addAll(personalPensionListDTOS);
            });
        }

        Map<String, List<List<Object>>> map = new LinkedHashMap<>();

        List<List<Object>> freeIncomeRowList = new ArrayList<>();
        List<Object> freeIncomeTitle = Arrays.asList("姓名", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "所得项目", "免税事项", "免税性质", "免税金额");
        freeIncomeRowList.add(freeIncomeTitle);
        freeIncomeList.forEach(dto -> {
            List<Object> row = new ArrayList<>();
            row.add(dto.getUsername());
            row.add(dto.getTaxAgentName());
            row.add(dto.getDepartmentName());
            row.add(dto.getMobile());
            row.add(dto.getJobNum());
            row.add(dto.getIdNo());
            row.add(dto.getIncomeCategoryName());
            row.add(dto.getFreeItem());
            row.add(dto.getFreeProperty());
            row.add(dto.getFreeAmount());
            freeIncomeRowList.add(row);
        });
        map.put("免税收入", freeIncomeRowList);

        List<List<Object>> healthInsuranceRowList = new ArrayList<>();
        List<Object> healthInsuranceTitle = Arrays.asList("姓名", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "所得项目", "税优识别码", "保单生效日期", "年度保费", "月度保费", "本期扣除金额");
        healthInsuranceRowList.add(healthInsuranceTitle);
        healthInsuranceList.forEach(dto -> {
            List<Object> row = new ArrayList<>();
            row.add(dto.getUsername());
            row.add(dto.getTaxAgentName());
            row.add(dto.getDepartmentName());
            row.add(dto.getMobile());
            row.add(dto.getJobNum());
            row.add(dto.getIdNo());
            row.add(dto.getIncomeCategoryName());
            row.add(dto.getIdentificationNumber());
            row.add(dto.getEffectiveDate());
            row.add(dto.getYearPremium());
            row.add(dto.getMonthPremium());
            row.add(dto.getCurrentDeduction());
            healthInsuranceRowList.add(row);
        });
        map.put("商业健康保险", healthInsuranceRowList);


        List<List<Object>> endowmentInsuranceRowList = new ArrayList<>();
        List<Object> endowmentInsuranceTitle = Arrays.asList("姓名", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "所得项目","申报扣除月份", "税延养老账户编号", "报税校验码", "年度保费", "月度保费", "本期扣除金额");
        endowmentInsuranceRowList.add(endowmentInsuranceTitle);
        endowmentInsuranceList.forEach(dto -> {
            List<Object> row = new ArrayList<>();
            row.add(dto.getUsername());
            row.add(dto.getTaxAgentName());
            row.add(dto.getDepartmentName());
            row.add(dto.getMobile());
            row.add(dto.getJobNum());
            row.add(dto.getIdNo());
            row.add(dto.getIncomeCategoryName());
            row.add(dto.getDeductionMonth());
            row.add(dto.getAccountNumber());
            row.add(dto.getCheckCode());
            row.add(dto.getYearPremium());
            row.add(dto.getMonthPremium());
            row.add(dto.getCurrentDeduction());
            endowmentInsuranceRowList.add(row);
        });
        map.put("税延养老保险", endowmentInsuranceRowList);

        List<List<Object>> grantDonationRowList = new ArrayList<>();
        List<Object> grantDonationTitle = Arrays.asList("姓名", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "所得项目", "受赠单位名称", "受赠单位纳税人识别号", "凭证号", "捐赠日期", "捐赠金额", "扣除比例", "实际扣除金额");
        grantDonationRowList.add(grantDonationTitle);
        grantDonationList.forEach(dto -> {
            List<Object> row = new ArrayList<>();
            row.add(dto.getUsername());
            row.add(dto.getTaxAgentName());
            row.add(dto.getDepartmentName());
            row.add(dto.getMobile());
            row.add(dto.getJobNum());
            row.add(dto.getIdNo());
            row.add(dto.getIncomeCategoryName());
            row.add(dto.getRecipientName());
            row.add(dto.getTaxCode());
            row.add(dto.getDonationNumber());
            row.add(dto.getDonateDate());
            row.add(dto.getDonateAmount());
            row.add(dto.getDeductionProportion());
            row.add(dto.getActualDeduction());
            grantDonationRowList.add(row);
        });
        map.put("准予扣除的捐赠额", grantDonationRowList);

        List<List<Object>> derateDeductionRowList = new ArrayList<>();
        List<Object> derateDeductionTitle = Arrays.asList("姓名", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "所得项目", "减免事项", "减免性质", "减免金额");
        derateDeductionRowList.add(derateDeductionTitle);
        derateDeductionList.forEach(dto -> {
            List<Object> row = new ArrayList<>();
            row.add(dto.getUsername());
            row.add(dto.getTaxAgentName());
            row.add(dto.getDepartmentName());
            row.add(dto.getMobile());
            row.add(dto.getJobNum());
            row.add(dto.getIdNo());
            row.add(dto.getIncomeCategoryName());
            row.add(dto.getDerateItem());
            row.add(dto.getDerateProperty());
            row.add(dto.getDerateAmount());
            derateDeductionRowList.add(row);
        });
        map.put("减免税额", derateDeductionRowList);

        List<List<Object>> otherDerateDeductionRowList = new ArrayList<>();
        List<Object> otherDerateDeductionTitle = Arrays.asList("姓名", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "所得项目", "其他免税扣除金额", "备注");
        otherDerateDeductionRowList.add(otherDerateDeductionTitle);
        otherDerateDeductionList.forEach(dto -> {
            List<Object> row = new ArrayList<>();
            row.add(dto.getUsername());
            row.add(dto.getTaxAgentName());
            row.add(dto.getDepartmentName());
            row.add(dto.getMobile());
            row.add(dto.getJobNum());
            row.add(dto.getIdNo());
            row.add(dto.getIncomeCategoryName());
            row.add(dto.getOtherDeduction());
            row.add(dto.getRemark());
            otherDerateDeductionRowList.add(row);
        });
        map.put("其他", otherDerateDeductionRowList);

        List<List<Object>> personalPensionRowList = new ArrayList<>();
        List<Object> personalPensionTitle = Arrays.asList("姓名", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "所得项目", "凭证类型", "凭证编码", "缴费金额");
        personalPensionRowList.add(personalPensionTitle);
        personalPensionList.forEach(dto -> {
            List<Object> row = new ArrayList<>();
            row.add(dto.getUsername());
            row.add(dto.getTaxAgentName());
            row.add(dto.getDepartmentName());
            row.add(dto.getMobile());
            row.add(dto.getJobNum());
            row.add(dto.getIdNo());
            row.add(dto.getIncomeCategoryName());
            row.add(dto.getVoucherTypeName());
            row.add(dto.getVoucherNo());
            row.add(dto.getPayAmount());
            personalPensionRowList.add(row);
        });
        map.put("个人养老金", personalPensionRowList);

        XSSFWorkbook book = ExcelUtil.genWorkbookV2(map);
        return book;
    }

    @Override
    public PageInfo<FreeIncomeListDTO> freeIncomeList(OtherDeductionDetailQueryParam param) {

        FreeIncomePO build;
        if (param.getId() != null) {
            build = FreeIncomePO.builder().mainId(param.getId()).build();
        } else {
            build = FreeIncomePO.builder().taxAgentId(param.getTaxAgentId()).taxYearMonth(param.getTaxCycle()).employeeId(param.getEmployeeId()).build();
        }
        List<FreeIncomePO> pos = getFreeIncomeMapper().listSome(build);

        List<FreeIncomeListDTO> listDTOS = freeIncomePO2DTO(pos);
        return SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), listDTOS, FreeIncomeListDTO.class);
    }

    @NotNull
    private List<FreeIncomeListDTO> freeIncomePO2DTO(List<FreeIncomePO> pos) {
        List<Long> empIds = SalaryEntityUtil.properties(pos, FreeIncomePO::getEmployeeId, Collectors.toList());
        List<DataCollectionEmployee> employeeList = getSalaryEmployeeService(user).listByIds(empIds);
        Map<Long, DataCollectionEmployee> employeeMap = SalaryEntityUtil.convert2Map(employeeList, DataCollectionEmployee::getEmployeeId);
        List<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listAll();
        Map<Long, TaxAgentPO> taxAgentMap = SalaryEntityUtil.convert2Map(taxAgentPOS, TaxAgentPO::getId);
        List<FreeIncomeListDTO> listDTOS = pos.stream().map(po -> {
            FreeIncomeListDTO dto = new FreeIncomeListDTO();
            BeanUtils.copyProperties(po, dto);
            DataCollectionEmployee employee = employeeMap.getOrDefault(po.getEmployeeId(), new DataCollectionEmployee());
            TaxAgentPO taxAgent = taxAgentMap.getOrDefault(po.getTaxAgentId(), new TaxAgentPO());
            dto.setUsername(employee.getUsername());
            dto.setTaxAgentName(taxAgent.getName());
            dto.setDepartmentName(employee.getDepartmentName());
            dto.setMobile(employee.getMobile());
            dto.setJobNum(employee.getWorkcode());
            dto.setIdNo(employee.getIdNo());
            dto.setIncomeCategoryName(IncomeCategoryEnum.parseByValue(po.getIncomeCategory()).getDefaultLabel());
            return dto;
        }).collect(Collectors.toList());
        return listDTOS;
    }

    @Override
    public PageInfo<DerateDeductionListDTO> derateDeductionList(OtherDeductionDetailQueryParam param) {
        DerateDeductionPO build;
        if (param.getId() != null) {
            build = DerateDeductionPO.builder().mainId(param.getId()).build();
        } else {
            build = DerateDeductionPO.builder().taxAgentId(param.getTaxAgentId()).taxYearMonth(param.getTaxCycle()).employeeId(param.getEmployeeId()).build();
        }

        List<DerateDeductionPO> pos = getDerateDeductionMapper().listSome(build);
        List<DerateDeductionListDTO> listDTOS = derateDeductionPO2DTO(pos);
        return SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), listDTOS, DerateDeductionListDTO.class);
    }

    private List<DerateDeductionListDTO> derateDeductionPO2DTO(List<DerateDeductionPO> pos) {
        List<Long> empIds = SalaryEntityUtil.properties(pos, DerateDeductionPO::getEmployeeId, Collectors.toList());
        List<DataCollectionEmployee> employeeList = getSalaryEmployeeService(user).listByIds(empIds);
        Map<Long, DataCollectionEmployee> employeeMap = SalaryEntityUtil.convert2Map(employeeList, DataCollectionEmployee::getEmployeeId);
        List<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listAll();
        Map<Long, TaxAgentPO> taxAgentMap = SalaryEntityUtil.convert2Map(taxAgentPOS, TaxAgentPO::getId);
        List<DerateDeductionListDTO> listDTOS = pos.stream().map(po -> {
            DerateDeductionListDTO dto = new DerateDeductionListDTO();
            BeanUtils.copyProperties(po, dto);
            DataCollectionEmployee employee = employeeMap.getOrDefault(po.getEmployeeId(), new DataCollectionEmployee());
            TaxAgentPO taxAgent = taxAgentMap.getOrDefault(po.getTaxAgentId(), new TaxAgentPO());
            dto.setUsername(employee.getUsername());
            dto.setTaxAgentName(taxAgent.getName());
            dto.setDepartmentName(employee.getDepartmentName());
            dto.setMobile(employee.getMobile());
            dto.setJobNum(employee.getWorkcode());
            dto.setIdNo(employee.getIdNo());
            return dto;
        }).collect(Collectors.toList());
        return listDTOS;
    }

    @Override
    public PageInfo<EndowmentInsuranceListDTO> endowmentInsuranceList(OtherDeductionDetailQueryParam param) {
        EndowmentInsurancePO build;
        if (param.getId() != null) {
            build = EndowmentInsurancePO.builder().mainId(param.getId()).build();
        } else {
            build = EndowmentInsurancePO.builder().taxAgentId(param.getTaxAgentId()).taxYearMonth(param.getTaxCycle()).employeeId(param.getEmployeeId()).build();
        }

        List<EndowmentInsurancePO> pos = getEndowmentInsuranceMapper().listSome(build);

        List<EndowmentInsuranceListDTO> listDTOS = endowmentInsurancePO2DTO(pos);
        return SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), listDTOS, EndowmentInsuranceListDTO.class);
    }

    @NotNull
    private List<EndowmentInsuranceListDTO> endowmentInsurancePO2DTO(List<EndowmentInsurancePO> pos) {
        List<Long> empIds = SalaryEntityUtil.properties(pos, EndowmentInsurancePO::getEmployeeId, Collectors.toList());
        List<DataCollectionEmployee> employeeList = getSalaryEmployeeService(user).listByIds(empIds);
        Map<Long, DataCollectionEmployee> employeeMap = SalaryEntityUtil.convert2Map(employeeList, DataCollectionEmployee::getEmployeeId);
        List<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listAll();
        Map<Long, TaxAgentPO> taxAgentMap = SalaryEntityUtil.convert2Map(taxAgentPOS, TaxAgentPO::getId);
        List<EndowmentInsuranceListDTO> listDTOS = pos.stream().map(po -> {
            EndowmentInsuranceListDTO dto = new EndowmentInsuranceListDTO();
            BeanUtils.copyProperties(po, dto);
            DataCollectionEmployee employee = employeeMap.getOrDefault(po.getEmployeeId(), new DataCollectionEmployee());
            TaxAgentPO taxAgent = taxAgentMap.getOrDefault(po.getTaxAgentId(), new TaxAgentPO());
            dto.setUsername(employee.getUsername());
            dto.setTaxAgentName(taxAgent.getName());
            dto.setDepartmentName(employee.getDepartmentName());
            dto.setMobile(employee.getMobile());
            dto.setJobNum(employee.getWorkcode());
            dto.setIdNo(employee.getIdNo());
            return dto;
        }).collect(Collectors.toList());
        return listDTOS;
    }

    @Override
    public PageInfo<GrantDonationListDTO> grantDonationList(OtherDeductionDetailQueryParam param) {
        GrantDonationPO build;
        if (param.getId() != null) {
            build = GrantDonationPO.builder().mainId(param.getId()).build();
        } else {
            build = GrantDonationPO.builder().taxAgentId(param.getTaxAgentId()).taxYearMonth(param.getTaxCycle()).employeeId(param.getEmployeeId()).build();
        }

        List<GrantDonationPO> pos = getGrantDonationMapper().listSome(build);
        List<GrantDonationListDTO> listDTOS = grantDonationPO2DTO(pos);
        return SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), listDTOS, GrantDonationListDTO.class);
    }

    @NotNull
    private List<GrantDonationListDTO> grantDonationPO2DTO(List<GrantDonationPO> pos) {
        List<Long> empIds = SalaryEntityUtil.properties(pos, GrantDonationPO::getEmployeeId, Collectors.toList());
        List<DataCollectionEmployee> employeeList = getSalaryEmployeeService(user).listByIds(empIds);
        Map<Long, DataCollectionEmployee> employeeMap = SalaryEntityUtil.convert2Map(employeeList, DataCollectionEmployee::getEmployeeId);
        List<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listAll();
        Map<Long, TaxAgentPO> taxAgentMap = SalaryEntityUtil.convert2Map(taxAgentPOS, TaxAgentPO::getId);
        List<GrantDonationListDTO> listDTOS = pos.stream().map(po -> {
            GrantDonationListDTO dto = new GrantDonationListDTO();
            BeanUtils.copyProperties(po, dto);
            DataCollectionEmployee employee = employeeMap.getOrDefault(po.getEmployeeId(), new DataCollectionEmployee());
            TaxAgentPO taxAgent = taxAgentMap.getOrDefault(po.getTaxAgentId(), new TaxAgentPO());
            dto.setUsername(employee.getUsername());
            dto.setTaxAgentName(taxAgent.getName());
            dto.setDepartmentName(employee.getDepartmentName());
            dto.setMobile(employee.getMobile());
            dto.setJobNum(employee.getWorkcode());
            dto.setIdNo(employee.getIdNo());
            return dto;
        }).collect(Collectors.toList());
        return listDTOS;
    }

    @Override
    public PageInfo<HealthInsuranceListDTO> healthInsuranceList(OtherDeductionDetailQueryParam param) {
        HealthInsurancePO build;
        if (param.getId() != null) {
            build = HealthInsurancePO.builder().mainId(param.getId()).build();
        } else {
            build = HealthInsurancePO.builder().taxAgentId(param.getTaxAgentId()).taxYearMonth(param.getTaxCycle()).employeeId(param.getEmployeeId()).build();
        }

        List<HealthInsurancePO> pos = getHealthInsuranceMapper().listSome(build);
        List<HealthInsuranceListDTO> listDTOS = healthInsurancePO2DTO(pos);
        return SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), listDTOS, HealthInsuranceListDTO.class);
    }

    @NotNull
    private List<HealthInsuranceListDTO> healthInsurancePO2DTO(List<HealthInsurancePO> pos) {
        List<Long> empIds = SalaryEntityUtil.properties(pos, HealthInsurancePO::getEmployeeId, Collectors.toList());
        List<DataCollectionEmployee> employeeList = getSalaryEmployeeService(user).listByIds(empIds);
        Map<Long, DataCollectionEmployee> employeeMap = SalaryEntityUtil.convert2Map(employeeList, DataCollectionEmployee::getEmployeeId);
        List<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listAll();
        Map<Long, TaxAgentPO> taxAgentMap = SalaryEntityUtil.convert2Map(taxAgentPOS, TaxAgentPO::getId);
        List<HealthInsuranceListDTO> listDTOS = pos.stream().map(po -> {
            HealthInsuranceListDTO dto = new HealthInsuranceListDTO();
            BeanUtils.copyProperties(po, dto);
            DataCollectionEmployee employee = employeeMap.getOrDefault(po.getEmployeeId(), new DataCollectionEmployee());
            TaxAgentPO taxAgent = taxAgentMap.getOrDefault(po.getTaxAgentId(), new TaxAgentPO());
            dto.setUsername(employee.getUsername());
            dto.setTaxAgentName(taxAgent.getName());
            dto.setDepartmentName(employee.getDepartmentName());
            dto.setMobile(employee.getMobile());
            dto.setJobNum(employee.getWorkcode());
            dto.setIdNo(employee.getIdNo());
            return dto;
        }).collect(Collectors.toList());
        return listDTOS;
    }

    @Override
    public PageInfo<OtherDerateDeductionListDTO> otherDerateDeductionList(OtherDeductionDetailQueryParam param) {
        OtherDerateDeductionPO build;
        if (param.getId() != null) {
            build = OtherDerateDeductionPO.builder().mainId(param.getId()).build();
        } else {
            build = OtherDerateDeductionPO.builder().taxAgentId(param.getTaxAgentId()).taxYearMonth(param.getTaxCycle()).employeeId(param.getEmployeeId()).build();
        }

        List<OtherDerateDeductionPO> pos = getOtherDerateDeductionMapper().listSome(build);
        List<OtherDerateDeductionListDTO> listDTOS = otherDerateDeductionPO2DTO(pos);
        return SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), listDTOS, OtherDerateDeductionListDTO.class);
    }

    @NotNull
    private List<OtherDerateDeductionListDTO> otherDerateDeductionPO2DTO(List<OtherDerateDeductionPO> pos) {
        List<Long> empIds = SalaryEntityUtil.properties(pos, OtherDerateDeductionPO::getEmployeeId, Collectors.toList());
        List<DataCollectionEmployee> employeeList = getSalaryEmployeeService(user).listByIds(empIds);
        Map<Long, DataCollectionEmployee> employeeMap = SalaryEntityUtil.convert2Map(employeeList, DataCollectionEmployee::getEmployeeId);
        List<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listAll();
        Map<Long, TaxAgentPO> taxAgentMap = SalaryEntityUtil.convert2Map(taxAgentPOS, TaxAgentPO::getId);
        List<OtherDerateDeductionListDTO> listDTOS = pos.stream().map(po -> {
            OtherDerateDeductionListDTO dto = new OtherDerateDeductionListDTO();
            BeanUtils.copyProperties(po, dto);
            DataCollectionEmployee employee = employeeMap.getOrDefault(po.getEmployeeId(), new DataCollectionEmployee());
            TaxAgentPO taxAgent = taxAgentMap.getOrDefault(po.getTaxAgentId(), new TaxAgentPO());
            dto.setUsername(employee.getUsername());
            dto.setTaxAgentName(taxAgent.getName());
            dto.setDepartmentName(employee.getDepartmentName());
            dto.setMobile(employee.getMobile());
            dto.setJobNum(employee.getWorkcode());
            dto.setIdNo(employee.getIdNo());
            return dto;
        }).collect(Collectors.toList());
        return listDTOS;
    }

    @Override
    public PageInfo<PersonalPensionListDTO> personalPensionList(OtherDeductionDetailQueryParam param) {
        PersonalPensionPO build;
        if (param.getId() != null) {
            build = PersonalPensionPO.builder().mainId(param.getId()).build();
        } else {
            build = PersonalPensionPO.builder().taxAgentId(param.getTaxAgentId()).taxYearMonth(param.getTaxCycle()).employeeId(param.getEmployeeId()).build();
        }

        List<PersonalPensionPO> pos = getPersonalPensionMapper().listSome(build);
        List<PersonalPensionListDTO> listDTOS = personalPensionPO2DTO(pos);
        return SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), listDTOS, PersonalPensionListDTO.class);
    }

    @NotNull
    private List<PersonalPensionListDTO> personalPensionPO2DTO(List<PersonalPensionPO> pos) {
        List<Long> empIds = SalaryEntityUtil.properties(pos, PersonalPensionPO::getEmployeeId, Collectors.toList());
        List<DataCollectionEmployee> employeeList = getSalaryEmployeeService(user).listByIds(empIds);
        Map<Long, DataCollectionEmployee> employeeMap = SalaryEntityUtil.convert2Map(employeeList, DataCollectionEmployee::getEmployeeId);
        List<TaxAgentPO> taxAgentPOS = getTaxAgentService(user).listAll();
        Map<Long, TaxAgentPO> taxAgentMap = SalaryEntityUtil.convert2Map(taxAgentPOS, TaxAgentPO::getId);
        List<PersonalPensionListDTO> listDTOS = pos.stream().map(po -> {
            PersonalPensionListDTO dto = new PersonalPensionListDTO();
            BeanUtils.copyProperties(po, dto);
            DataCollectionEmployee employee = employeeMap.getOrDefault(po.getEmployeeId(), new DataCollectionEmployee());
            TaxAgentPO taxAgent = taxAgentMap.getOrDefault(po.getTaxAgentId(), new TaxAgentPO());
            dto.setUsername(employee.getUsername());
            dto.setTaxAgentName(taxAgent.getName());
            dto.setDepartmentName(employee.getDepartmentName());
            dto.setMobile(employee.getMobile());
            dto.setJobNum(employee.getWorkcode());
            dto.setIdNo(employee.getIdNo());
            return dto;
        }).collect(Collectors.toList());
        return listDTOS;
    }

    @Override
    public List<FreeIncomePO> queryFreeIncomes(OtherDeductionFreeListQueryParam param) {
        ValidUtil.doValidator(param);
        return getFreeIncomeMapper().listSome(FreeIncomePO.builder().taxYearMonth(param.getTaxCycle()).taxAgentId(param.getTaxAgentId()).build());
    }

    @Override
    public List<DerateDeductionPO> queryDerateDeductions(OtherDeductionFreeListQueryParam param) {
        ValidUtil.doValidator(param);
        return getDerateDeductionMapper().listSome(DerateDeductionPO.builder().taxYearMonth(param.getTaxCycle()).taxAgentId(param.getTaxAgentId()).build());
    }

    @Override
    public List<EndowmentInsurancePO> queryEndowmentInsurances(OtherDeductionFreeListQueryParam param) {
        ValidUtil.doValidator(param);
        return getEndowmentInsuranceMapper().listSome(EndowmentInsurancePO.builder().taxYearMonth(param.getTaxCycle()).taxAgentId(param.getTaxAgentId()).build());
    }

    @Override
    public List<GrantDonationPO> queryGrantDonations(OtherDeductionFreeListQueryParam param) {
        ValidUtil.doValidator(param);
        return getGrantDonationMapper().listSome(GrantDonationPO.builder().taxYearMonth(param.getTaxCycle()).taxAgentId(param.getTaxAgentId()).build());
    }

    @Override
    public List<HealthInsurancePO> queryHealthInsurances(OtherDeductionFreeListQueryParam param) {
        ValidUtil.doValidator(param);
        return getHealthInsuranceMapper().listSome(HealthInsurancePO.builder().taxYearMonth(param.getTaxCycle()).taxAgentId(param.getTaxAgentId()).build());
    }

    @Override
    public List<OtherDerateDeductionPO> queryOtherDerateDeductions(OtherDeductionFreeListQueryParam param) {
        ValidUtil.doValidator(param);
        return getOtherDerateDeductionMapper().listSome(OtherDerateDeductionPO.builder().taxYearMonth(param.getTaxCycle()).taxAgentId(param.getTaxAgentId()).build());
    }

    @Override
    public List<PersonalPensionPO> queryPersonalPensions(OtherDeductionFreeListQueryParam param) {
        ValidUtil.doValidator(param);
        return getPersonalPensionMapper().listSome(PersonalPensionPO.builder().taxYearMonth(param.getTaxCycle()).taxAgentId(param.getTaxAgentId()).build());
    }


    @Override
    public void saveFreeIncome(FreeIncomeSaveParam param) {
        Date now = new Date();

        Long mainId = param.getMainId();
        OtherDeductionPO deductionPO = getById(mainId);
        if (deductionPO == null) {
            throw new SalaryRunTimeException("主表不存在！");
        }

        Long id = param.getId();
        if (id == null) {
            FreeIncomePO po = FreeIncomePO.builder()
                    .id(IdGenerator.generate())
                    .mainId(mainId)
                    .taxYearMonth(deductionPO.getDeclareMonth())
                    .employeeId(deductionPO.getEmployeeId())
                    .taxAgentId(deductionPO.getTaxAgentId())
                    .incomeCategory(param.getIncomeCategory())
                    .freeItem(param.getFreeItem())
                    .freeProperty(param.getFreeProperty())
                    .freeAmount(param.getFreeAmount())
                    .fileStatus(1)
                    .employeeType(0)
                    .createTime(now)
                    .updateTime(now)
                    .creator((long) user.getUID())
                    .deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
                    .tenantKey(DEFAULT_TENANT_KEY)
                    .build();
            getFreeIncomeMapper().insertIgnoreNull(po);
        } else {
            FreeIncomePO po = getFreeIncomeMapper().getById(id);
            if (po == null) {
                throw new SalaryRunTimeException("记录不存在！");
            }

            po.setUpdateTime(now);
            po.setIncomeCategory(param.getIncomeCategory());
            po.setFreeItem(param.getFreeItem());
            po.setFreeProperty(param.getFreeProperty());
            po.setFreeAmount(param.getFreeAmount());

            getFreeIncomeMapper().updateIgnoreNull(po);
        }

        syncMain(mainId, Collections.singletonList(TaxFreeTypeEnum.FREE_INCOME));
    }

    @Override
    public void saveEndowmentInsurance(EndowmentInsuranceSaveParam param) {
        Date now = new Date();

        Long mainId = param.getMainId();
        OtherDeductionPO deductionPO = getById(mainId);
        if (deductionPO == null) {
            throw new SalaryRunTimeException("主表不存在！");
        }

        Long id = param.getId();
        if (id == null) {
            EndowmentInsurancePO po = EndowmentInsurancePO.builder()
                    .id(IdGenerator.generate())
                    .mainId(mainId)
                    .taxYearMonth(deductionPO.getDeclareMonth())
                    .employeeId(deductionPO.getEmployeeId())
                    .taxAgentId(deductionPO.getTaxAgentId())
                    .incomeCategory(param.getIncomeCategory())
                    .deductionMonth(param.getDeductionMonth())
                    .accountNumber(param.getAccountNumber())
                    .checkCode(param.getCheckCode())
                    .yearPremium(param.getYearPremium())
                    .monthPremium(param.getMonthPremium())
                    .currentDeduction(param.getCurrentDeduction())
                    .fileStatus(1)
                    .employeeType(0)
                    .createTime(now)
                    .updateTime(now)
                    .creator((long) user.getUID())
                    .deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
                    .tenantKey(DEFAULT_TENANT_KEY)
                    .build();
            getEndowmentInsuranceMapper().insertIgnoreNull(po);
        } else {
            EndowmentInsurancePO po = getEndowmentInsuranceMapper().getById(id);
            if (po == null) {
                throw new SalaryRunTimeException("记录不存在！");
            }

            po.setUpdateTime(now);
            po.setIncomeCategory(param.getIncomeCategory());
            po.setDeductionMonth(param.getDeductionMonth());
            po.setAccountNumber(param.getAccountNumber());
            po.setCheckCode(param.getCheckCode());
            po.setYearPremium(param.getYearPremium());
            po.setMonthPremium(param.getMonthPremium());
            po.setCurrentDeduction(param.getCurrentDeduction());

            getEndowmentInsuranceMapper().updateIgnoreNull(po);
        }

        syncMain(mainId, Collections.singletonList(TaxFreeTypeEnum.ENDOWMENT_INSURANCE));
    }

    @Override
    public void saveGrantDonation(GrantDonationSaveParam param) {
        Date now = new Date();

        Long mainId = param.getMainId();
        OtherDeductionPO deductionPO = getById(mainId);
        if (deductionPO == null) {
            throw new SalaryRunTimeException("主表不存在！");
        }

        Long id = param.getId();
        if (id == null) {
            GrantDonationPO po = GrantDonationPO.builder()
                    .id(IdGenerator.generate())
                    .mainId(mainId)
                    .taxYearMonth(deductionPO.getDeclareMonth())
                    .employeeId(deductionPO.getEmployeeId())
                    .taxAgentId(deductionPO.getTaxAgentId())
                    .incomeCategory(param.getIncomeCategory())
                    .recipientName(param.getRecipientName())
                    .taxCode(param.getTaxCode())
                    .donationNumber(param.getDonationNumber())
                    .donateDate(param.getDonateDate())
                    .donateAmount(param.getDonateAmount())
                    .deductionProportion(param.getDeductionProportion())
                    .actualDeduction(param.getActualDeduction())
                    .fileStatus(1)
                    .employeeType(0)
                    .createTime(now)
                    .updateTime(now)
                    .creator((long) user.getUID())
                    .deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
                    .tenantKey(DEFAULT_TENANT_KEY)
                    .build();
            getGrantDonationMapper().insertIgnoreNull(po);
        } else {
            GrantDonationPO po = getGrantDonationMapper().getById(id);
            if (po == null) {
                throw new SalaryRunTimeException("记录不存在！");
            }

            po.setUpdateTime(now);
            po.setIncomeCategory(param.getIncomeCategory());
            po.setRecipientName(param.getRecipientName());
            po.setTaxCode(param.getTaxCode());
            po.setDonationNumber(param.getDonationNumber());
            po.setDonateDate(param.getDonateDate());
            po.setDonateAmount(param.getDonateAmount());
            po.setDeductionProportion(param.getDeductionProportion());
            po.setActualDeduction(param.getActualDeduction());

            getGrantDonationMapper().updateIgnoreNull(po);
        }

        syncMain(mainId, Collections.singletonList(TaxFreeTypeEnum.GRANT_DONATION));
    }

    @Override
    public void saveHealthInsurance(HealthInsuranceSaveParam param) {
        Date now = new Date();

        Long mainId = param.getMainId();
        OtherDeductionPO deductionPO = getById(mainId);
        if (deductionPO == null) {
            throw new SalaryRunTimeException("主表不存在！");
        }

        Long id = param.getId();
        if (id == null) {
            HealthInsurancePO po = HealthInsurancePO.builder()
                    .id(IdGenerator.generate())
                    .mainId(mainId)
                    .taxYearMonth(deductionPO.getDeclareMonth())
                    .employeeId(deductionPO.getEmployeeId())
                    .taxAgentId(deductionPO.getTaxAgentId())
                    .incomeCategory(param.getIncomeCategory())
                    .identificationNumber(param.getIdentificationNumber())
                    .effectiveDate(param.getEffectiveDate())
                    .yearPremium(param.getYearPremium())
                    .monthPremium(param.getMonthPremium())
                    .currentDeduction(param.getCurrentDeduction())
                    .fileStatus(1)
                    .employeeType(0)
                    .createTime(now)
                    .updateTime(now)
                    .creator((long) user.getUID())
                    .deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
                    .tenantKey(DEFAULT_TENANT_KEY)
                    .build();
            getHealthInsuranceMapper().insertIgnoreNull(po);
        } else {
            HealthInsurancePO po = getHealthInsuranceMapper().getById(id);
            if (po == null) {
                throw new SalaryRunTimeException("记录不存在！");
            }

            po.setUpdateTime(now);
            po.setIncomeCategory(param.getIncomeCategory());
            po.setIdentificationNumber(param.getIdentificationNumber());
            po.setEffectiveDate(param.getEffectiveDate());
            po.setYearPremium(param.getYearPremium());
            po.setMonthPremium(param.getMonthPremium());
            po.setCurrentDeduction(param.getCurrentDeduction());

            getHealthInsuranceMapper().updateIgnoreNull(po);
        }

        syncMain(mainId, Collections.singletonList(TaxFreeTypeEnum.HEALTH_INSURANCE));
    }

    @Override
    public void saveOtherDerateDeduction(OtherDerateDeductionSaveParam param) {
        Date now = new Date();

        Long mainId = param.getMainId();
        OtherDeductionPO deductionPO = getById(mainId);
        if (deductionPO == null) {
            throw new SalaryRunTimeException("主表不存在！");
        }

        Long id = param.getId();
        if (id == null) {
            OtherDerateDeductionPO po = OtherDerateDeductionPO.builder()
                    .id(IdGenerator.generate())
                    .mainId(mainId)
                    .taxYearMonth(deductionPO.getDeclareMonth())
                    .employeeId(deductionPO.getEmployeeId())
                    .taxAgentId(deductionPO.getTaxAgentId())
                    .incomeCategory(param.getIncomeCategory())
                    .otherDeduction(param.getOtherDeduction())
                    .remark(param.getRemark())
                    .fileStatus(1)
                    .employeeType(0)
                    .createTime(now)
                    .updateTime(now)
                    .creator((long) user.getUID())
                    .deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
                    .tenantKey(DEFAULT_TENANT_KEY)
                    .build();
            getOtherDerateDeductionMapper().insertIgnoreNull(po);
        } else {
            OtherDerateDeductionPO po = getOtherDerateDeductionMapper().getById(id);
            if (po == null) {
                throw new SalaryRunTimeException("记录不存在！");
            }

            po.setUpdateTime(now);
            po.setIncomeCategory(param.getIncomeCategory());
            po.setOtherDeduction(param.getOtherDeduction());
            po.setRemark(param.getRemark());

            getOtherDerateDeductionMapper().updateIgnoreNull(po);
        }

        syncMain(mainId, Collections.singletonList(TaxFreeTypeEnum.OTHER_DERATE_DEDUCTION));
    }

    @Override
    public void saveDerateDeduction(DerateDeductionSaveParam param) {
        Date now = new Date();

        Long mainId = param.getMainId();
        OtherDeductionPO deductionPO = getById(mainId);
        if (deductionPO == null) {
            throw new SalaryRunTimeException("主表不存在！");
        }

        Long id = param.getId();
        if (id == null) {
            DerateDeductionPO po = DerateDeductionPO.builder()
                    .id(IdGenerator.generate())
                    .mainId(mainId)
                    .taxYearMonth(deductionPO.getDeclareMonth())
                    .employeeId(deductionPO.getEmployeeId())
                    .taxAgentId(deductionPO.getTaxAgentId())
                    .incomeCategory(param.getIncomeCategory())
                    .derateAmount(param.getDerateAmount())
                    .derateItem(param.getDerateItem())
                    .derateProperty(param.getDerateProperty())
                    .fileStatus(1)
                    .employeeType(0)
                    .createTime(now)
                    .updateTime(now)
                    .creator((long) user.getUID())
                    .deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
                    .tenantKey(DEFAULT_TENANT_KEY)
                    .build();
            getDerateDeductionMapper().insertIgnoreNull(po);
        } else {
            DerateDeductionPO po = getDerateDeductionMapper().getById(id);
            if (po == null) {
                throw new SalaryRunTimeException("记录不存在！");
            }

            po.setUpdateTime(now);
            po.setIncomeCategory(param.getIncomeCategory());
            po.setDerateAmount(param.getDerateAmount());
            po.setDerateItem(param.getDerateItem());
            po.setDerateProperty(param.getDerateProperty());

            getDerateDeductionMapper().updateIgnoreNull(po);
        }

        syncMain(mainId, Collections.singletonList(TaxFreeTypeEnum.DERATE_DEDUCTION));
    }

    @Override
    public void savePersonalPension(PersonalPensionSaveParam param) {
        Date now = new Date();

        Long mainId = param.getMainId();
        OtherDeductionPO deductionPO = getById(mainId);
        if (deductionPO == null) {
            throw new SalaryRunTimeException("主表不存在！");
        }

        Long id = param.getId();
        if (id == null) {
            PersonalPensionPO po = PersonalPensionPO.builder()
                    .id(IdGenerator.generate())
                    .mainId(mainId)
                    .taxYearMonth(deductionPO.getDeclareMonth())
                    .employeeId(deductionPO.getEmployeeId())
                    .taxAgentId(deductionPO.getTaxAgentId())
                    .incomeCategory(param.getIncomeCategory())
                    .voucherTypeName(param.getVoucherTypeName())
                    .voucherNo(param.getVoucherNo())
                    .payAmount(param.getPayAmount())
                    .fileStatus(1)
                    .employeeType(0)
                    .createTime(now)
                    .updateTime(now)
                    .creator((long) user.getUID())
                    .deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
                    .tenantKey(DEFAULT_TENANT_KEY)
                    .build();
            getPersonalPensionMapper().insertIgnoreNull(po);
        } else {
            PersonalPensionPO po = getPersonalPensionMapper().getById(id);
            if (po == null) {
                throw new SalaryRunTimeException("记录不存在！");
            }

            po.setUpdateTime(now);
            po.setIncomeCategory(param.getIncomeCategory());
            po.setVoucherTypeName(param.getVoucherTypeName());
            po.setVoucherNo(param.getVoucherNo());
            po.setPayAmount(param.getPayAmount());

            getPersonalPensionMapper().updateIgnoreNull(po);
        }

        syncMain(mainId, Collections.singletonList(TaxFreeTypeEnum.PERSONAL_PENSION));
    }

    @Override
    public void deleteFreeIncome(OtherDeductionDetailDeleteParam param) {
        getFreeIncomeMapper().deleteByIds(param.getIds());
        syncMain(param.getMainId(), Collections.singletonList(TaxFreeTypeEnum.FREE_INCOME));
    }

    @Override
    public void deleteEndowmentInsurance(OtherDeductionDetailDeleteParam param) {
        getEndowmentInsuranceMapper().deleteByIds(param.getIds());
        syncMain(param.getMainId(), Collections.singletonList(TaxFreeTypeEnum.ENDOWMENT_INSURANCE));
    }

    @Override
    public void deleteGrantDonation(OtherDeductionDetailDeleteParam param) {
        getGrantDonationMapper().deleteByIds(param.getIds());
        syncMain(param.getMainId(), Collections.singletonList(TaxFreeTypeEnum.GRANT_DONATION));
    }

    @Override
    public void deleteHealthInsurance(OtherDeductionDetailDeleteParam param) {
        getHealthInsuranceMapper().deleteByIds(param.getIds());
        syncMain(param.getMainId(), Collections.singletonList(TaxFreeTypeEnum.HEALTH_INSURANCE));
    }

    @Override
    public void deleteOtherDerateDeduction(OtherDeductionDetailDeleteParam param) {
        getOtherDerateDeductionMapper().deleteByIds(param.getIds());
        syncMain(param.getMainId(), Collections.singletonList(TaxFreeTypeEnum.OTHER_DERATE_DEDUCTION));
    }

    @Override
    public void deleteDerateDeduction(OtherDeductionDetailDeleteParam param) {
        getDerateDeductionMapper().deleteByIds(param.getIds());
        syncMain(param.getMainId(), Collections.singletonList(TaxFreeTypeEnum.DERATE_DEDUCTION));
    }

    @Override
    public void deletePersonalPension(OtherDeductionDetailDeleteParam param) {
        getPersonalPensionMapper().deleteByIds(param.getIds());
        syncMain(param.getMainId(), Collections.singletonList(TaxFreeTypeEnum.PERSONAL_PENSION));
    }

    @Override
    public void syncMain(Long mainId, List<TaxFreeTypeEnum> taxFreeTypes) {
        OtherDeductionPO deductionPO = getById(mainId);
        if (deductionPO == null) {
            throw new SalaryRunTimeException("主表不存在！");
        }

        if (taxFreeTypes.contains(TaxFreeTypeEnum.FREE_INCOME)) {
            syncFreeIncome(deductionPO);
        }
        if (taxFreeTypes.contains(TaxFreeTypeEnum.HEALTH_INSURANCE)) {
            syncHealthInsurance(deductionPO);
        }
        if (taxFreeTypes.contains(TaxFreeTypeEnum.ENDOWMENT_INSURANCE)) {
            syncEndowmentInsurance(deductionPO);
        }
        if (taxFreeTypes.contains(TaxFreeTypeEnum.GRANT_DONATION)) {
            syncGrantDonation(deductionPO);
        }
        if (taxFreeTypes.contains(TaxFreeTypeEnum.DERATE_DEDUCTION)) {
            syncDerateDeduction(deductionPO);
        }
        if (taxFreeTypes.contains(TaxFreeTypeEnum.OTHER_DERATE_DEDUCTION)) {
            syncOtherDerateDeduction(deductionPO);
        }
        if (taxFreeTypes.contains(TaxFreeTypeEnum.PERSONAL_PENSION)) {
            syncPersonalPension(deductionPO);
        }
    }

    @Override
    public void syncFreeIncome(OtherDeductionPO mainPO) {
        List<FreeIncomePO> freeIncomePOS = getFreeIncomeMapper().listSome(FreeIncomePO.builder().mainId(mainPO.getId()).build());
        String sum = freeIncomePOS.stream().filter(po -> NumberUtil.isNumber(po.getFreeAmount())).map(po -> new BigDecimal(po.getFreeAmount())).reduce(BigDecimal.ZERO, BigDecimal::add).toPlainString();
        mainPO.setFreeIncome(sum);
        getOtherDeductionMapper().updateData(Collections.singletonList(mainPO));
    }

    @Override
    public void syncEndowmentInsurance(OtherDeductionPO mainPO) {
        List<EndowmentInsurancePO> endowmentInsurancePOS = getEndowmentInsuranceMapper().listSome(EndowmentInsurancePO.builder().mainId(mainPO.getId()).build());
        String sum = endowmentInsurancePOS.stream().filter(po -> NumberUtil.isNumber(po.getCurrentDeduction())).map(po -> new BigDecimal(po.getCurrentDeduction())).reduce(BigDecimal.ZERO, BigDecimal::add).toPlainString();
        mainPO.setTaxDelayEndowmentInsurance(sum);
        getOtherDeductionMapper().updateData(Collections.singletonList(mainPO));
    }

    @Override
    public void syncGrantDonation(OtherDeductionPO mainPO) {
        List<GrantDonationPO> grantDonationPOS = getGrantDonationMapper().listSome(GrantDonationPO.builder().mainId(mainPO.getId()).build());
        String sum = grantDonationPOS.stream().filter(po -> NumberUtil.isNumber(po.getActualDeduction())).map(po -> new BigDecimal(po.getActualDeduction())).reduce(BigDecimal.ZERO, BigDecimal::add).toPlainString();
        mainPO.setDeductionAllowedDonation(sum);
        getOtherDeductionMapper().updateData(Collections.singletonList(mainPO));
    }

    @Override
    public void syncHealthInsurance(OtherDeductionPO mainPO) {
        List<HealthInsurancePO> healthInsurancePOS = getHealthInsuranceMapper().listSome(HealthInsurancePO.builder().mainId(mainPO.getId()).build());
        String sum = healthInsurancePOS.stream().filter(po -> NumberUtil.isNumber(po.getCurrentDeduction())).map(po -> new BigDecimal(po.getCurrentDeduction())).reduce(BigDecimal.ZERO, BigDecimal::add).toPlainString();
        mainPO.setBusinessHealthyInsurance(sum);
        getOtherDeductionMapper().updateData(Collections.singletonList(mainPO));
    }

    @Override
    public void syncOtherDerateDeduction(OtherDeductionPO mainPO) {
        List<OtherDerateDeductionPO> otherDerateDeductionPOS = getOtherDerateDeductionMapper().listSome(OtherDerateDeductionPO.builder().mainId(mainPO.getId()).build());
        String sum = otherDerateDeductionPOS.stream().filter(po -> NumberUtil.isNumber(po.getOtherDeduction())).map(po -> new BigDecimal(po.getOtherDeduction())).reduce(BigDecimal.ZERO, BigDecimal::add).toPlainString();
        mainPO.setOtherDeduction(sum);
        getOtherDeductionMapper().updateData(Collections.singletonList(mainPO));
    }

    @Override
    public void syncDerateDeduction(OtherDeductionPO mainPO) {
        List<DerateDeductionPO> derateDeductionPOS = getDerateDeductionMapper().listSome(DerateDeductionPO.builder().mainId(mainPO.getId()).build());
        String sum = derateDeductionPOS.stream().filter(po -> NumberUtil.isNumber(po.getDerateAmount())).map(po -> new BigDecimal(po.getDerateAmount())).reduce(BigDecimal.ZERO, BigDecimal::add).toPlainString();
        mainPO.setDerateDeduction(sum);
        getOtherDeductionMapper().updateData(Collections.singletonList(mainPO));
    }

    @Override
    public void syncPersonalPension(OtherDeductionPO mainPO) {
        List<PersonalPensionPO> personalPensionPOS = getPersonalPensionMapper().listSome(PersonalPensionPO.builder().mainId(mainPO.getId()).build());
        String sum = personalPensionPOS.stream().filter(po -> NumberUtil.isNumber(po.getPayAmount())).map(po -> new BigDecimal(po.getPayAmount())).reduce(BigDecimal.ZERO, BigDecimal::add).toPlainString();
        mainPO.setPrivatePension(sum);
        getOtherDeductionMapper().updateData(Collections.singletonList(mainPO));
    }

}