package com.engine.salary.service.impl;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.NumberUtil;
import com.alibaba.fastjson.JSON;
import com.api.browser.bean.SearchConditionGroup;
import com.api.browser.bean.SearchConditionItem;
import com.api.browser.util.ConditionFactory;
import com.api.browser.util.ConditionType;
import com.api.formmode.mybatis.util.SqlProxyHandle;
import com.cloudstore.dev.api.util.Util_DataCache;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.hrmelog.entity.dto.LoggerContext;
import com.engine.salary.biz.AddUpDeductionBiz;
import com.engine.salary.config.SalaryElogConfig;
import com.engine.salary.constant.SzyhApiConstant;
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.bo.DataCollectionBO;
import com.engine.salary.entity.datacollection.dto.AddUpDeductionDTO;
import com.engine.salary.entity.datacollection.dto.AddUpDeductionRecordDTO;
import com.engine.salary.entity.datacollection.dto.AddUpDeductionRequestFailListDTO;
import com.engine.salary.entity.datacollection.dto.AddUpDeductionRequestResultDTO;
import com.engine.salary.entity.datacollection.param.*;
import com.engine.salary.entity.datacollection.po.AddUpDeductionRequestFailPO;
import com.engine.salary.entity.datacollection.po.AddUpDeductionRequestPO;
import com.engine.salary.entity.datacollection.po.SpecialAddDeductionPO;
import com.engine.salary.entity.datacollection.response.QuerySpecialAmountFeedbackResponse;
import com.engine.salary.entity.datacollection.response.QuerySpecialAmountResponse;
import com.engine.salary.entity.employeedeclare.po.EmployeeDeclarePO;
import com.engine.salary.entity.extemp.po.ExtEmpPO;
import com.engine.salary.entity.salaryacct.po.SalaryAcctEmployeePO;
import com.engine.salary.entity.salaryacct.po.SalaryAcctRecordPO;
import com.engine.salary.entity.salaryarchive.po.SalaryArchivePO;
import com.engine.salary.entity.salarysob.po.SalarySobPO;
import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeEmployeeDTO;
import com.engine.salary.entity.taxagent.param.TaxAgentQueryParam;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.entity.taxagent.po.TaxAgentTaxReturnPO;
import com.engine.salary.entity.taxagent.response.SzyhResponseHead;
import com.engine.salary.entity.taxapiflow.bo.TaxApiFlowBO;
import com.engine.salary.entity.taxapiflow.po.TaxDeclarationApiFlowRecordPO;
import com.engine.salary.entity.taxdeclaration.po.TaxDeclarationApiConfigPO;
import com.engine.salary.enums.OperateTypeEnum;
import com.engine.salary.enums.UserStatusEnum;
import com.engine.salary.enums.auth.AuthFilterTypeEnum;
import com.engine.salary.enums.datacollection.EnumAddUpDeductionRequestStatus;
import com.engine.salary.enums.datacollection.UseEmployeeTypeEnum;
import com.engine.salary.enums.employeedeclare.DeclareStatusEnum;
import com.engine.salary.enums.salaryaccounting.SalaryAcctRecordStatusEnum;
import com.engine.salary.enums.salaryarchive.SalaryArchiveStatusEnum;
import com.engine.salary.enums.salarysob.IncomeCategoryEnum;
import com.engine.salary.enums.sicategory.DeleteTypeEnum;
import com.engine.salary.enums.taxagent.TaxAgentTaxReturnStatusEnum;
import com.engine.salary.enums.taxdeclaration.EnumDeclareApiBusinessType;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.datacollection.AddUpDeductionMapper;
import com.engine.salary.mapper.datacollection.AddUpDeductionRequestFailMapper;
import com.engine.salary.mapper.datacollection.AddUpDeductionRequestMapper;
import com.engine.salary.mapper.employeedeclare.EmployeeDeclareMapper;
import com.engine.salary.mapper.sys.SalarySysConfMapper;
import com.engine.salary.report.enums.EmployeeTypeEnum;
import com.engine.salary.service.*;
import com.engine.salary.service.auth.AuthService;
import com.engine.salary.service.auth.AuthServiceImpl;
import com.engine.salary.sys.entity.po.SalarySysConfPO;
import com.engine.salary.sys.entity.vo.OrderRuleVO;
import com.engine.salary.sys.service.SalarySysConfService;
import com.engine.salary.sys.service.impl.SalarySysConfServiceImpl;
import com.engine.salary.util.*;
import com.engine.salary.util.db.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.google.common.collect.Lists;
import com.google.common.collect.Maps;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
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 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.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
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;

/**
 * 累计专项
 * <p>Copyright: Copyright (c) 2022</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
@Slf4j
public class AddUpDeductionServiceImpl extends Service implements AddUpDeductionService {
    private EncryptUtil encryptUtil = new EncryptUtil();

    private AddUpDeductionMapper getAddUpDeductionMapper() {
        return MapperProxyFactory.getProxy(AddUpDeductionMapper.class);
    }

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

    private SalaryAcctRecordService getSalaryAcctRecordService(User user) {
        return ServiceUtil.getService(SalaryAcctRecordServiceImpl.class, user);
    }

    private SalaryAcctEmployeeService getSalaryAcctEmployeeService(User user) {
        return ServiceUtil.getService(SalaryAcctEmployeeServiceImpl.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 SpecialAddDeductionService getSpecialAddDeductionService(User user) {
        return ServiceUtil.getService(SpecialAddDeductionServiceImpl.class, user);
    }

    private TaxDeclarationApiConfigService getTaxDeclarationApiConfigService(User user) {
        return ServiceUtil.getService(TaxDeclarationApiConfigServiceImpl.class, user);
    }

    private TaxAgentTaxReturnService getTaxAgentTaxReturnService(User user) {
        return ServiceUtil.getService(TaxAgentTaxReturnServiceImpl.class, user);
    }

    private SalaryArchiveService getSalaryArchiveService(User user) {
        return ServiceUtil.getService(SalaryArchiveServiceImpl.class, user);
    }

    public TaxDeclarationApiBillingService getTaxDeclarationApiBillingService(User user) {
        return ServiceUtil.getService(TaxDeclarationApiBillingServiceImpl.class, user);
    }

    private EmployeeDeclareMapper getEmployeeDeclareMapper() {
        return MapperProxyFactory.getProxy(EmployeeDeclareMapper.class);
    }

    private AddUpDeductionRequestMapper getAddUpDeductionRequestMapper() {
        return MapperProxyFactory.getProxy(AddUpDeductionRequestMapper.class);
    }

    private AddUpDeductionRequestFailMapper getAddUpDeductionRequestFailMapper() {
        return MapperProxyFactory.getProxy(AddUpDeductionRequestFailMapper.class);
    }

    private ExtEmpService getExtEmpService(User user) {
        return ServiceUtil.getService(ExtEmpServiceImpl.class, user);
    }

    public AuthService getAuthService(User user) {
        return ServiceUtil.getService(AuthServiceImpl.class, user);
    }


    private SalarySobService getSalarySobService(User user) {
        return ServiceUtil.getService(SalarySobServiceImpl.class, user);
    }

    @Override
    public Map<String, Object> getSearchCondition(Map<String, Object> params) {
        Map<String, Object> apidatas = new HashMap<String, Object>();
        ConditionFactory conditionFactory = new ConditionFactory(user);

        //条件组
        List<SearchConditionGroup> addGroups = new ArrayList<SearchConditionGroup>();

        List<SearchConditionItem> conditionItems = new ArrayList<SearchConditionItem>();

        //文本输入框
        SearchConditionItem username = conditionFactory.createCondition(ConditionType.INPUT, 25034, "username");
        username.setInputType("input");
        username.setColSpan(2);
        username.setFieldcol(16);
        username.setLabelcol(8);
        username.setViewAttr(2);
        username.setLabel("姓名");
        conditionItems.add(username);


        SearchConditionItem departmentName = conditionFactory.createCondition(ConditionType.BROWSER, 502227, "departmentIds", "57");
        departmentName.setInputType("browser");
        departmentName.setColSpan(2);
        departmentName.setFieldcol(16);
        departmentName.setLabelcol(8);
        departmentName.setViewAttr(2);
        departmentName.setIsQuickSearch(false);
        departmentName.setLabel("部门");
        conditionItems.add(departmentName);


        SearchConditionItem jobNum = conditionFactory.createCondition(ConditionType.INPUT, 25034, "jobNum");
        jobNum.setInputType("input");
        jobNum.setColSpan(2);
        jobNum.setFieldcol(16);
        jobNum.setLabelcol(8);
        jobNum.setViewAttr(2);
        jobNum.setLabel("工号");
        conditionItems.add(jobNum);

        addGroups.add(new SearchConditionGroup("常用条件", true, conditionItems));

        apidatas.put("condition", addGroups);
        return apidatas;
    }


    @Override
    public Map<String, Object> importAddUpDeduction(AddUpDeductionImportParam importParam) {
        long currentEmployeeId = user.getUID();
        Boolean openDevolution = getTaxAgentService(user).isOpenDevolution();

        Map<String, Object> apidatas = new HashMap<String, Object>();
        AddUpDeductionBiz addUpDeductionBiz = new AddUpDeductionBiz();

        //检验参数
        checkImportParam(importParam);

        //税款所属期
        String declareMonthStr = importParam.getDeclareMonth();
        //excel文件id
        String imageId = Util.null2String(importParam.getImageId());
        Validate.notBlank(imageId, "imageId为空");
        // 获取所有个税扣缴义务人
        // 获取所有个税扣缴义务人
        TaxAgentQueryParam param = TaxAgentQueryParam.builder().build();
        param.setFilterType(AuthFilterTypeEnum.ADMIN_DATA);
        Collection<TaxAgentPO> taxAgentList = getTaxAgentService(user).listAuth(param);
        // Collection<TaxAgentManageRangeEmployeeDTO> taxAgentList = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId);
        //个税扣缴义务人
        String taxAgentId = Util.null2String(importParam.getTaxAgentId());
        // 获取租户下所有的人员
        List<DataCollectionEmployee> employees = getSalaryEmployeeService(user).listEmployee();
        // 已经核算过的不可操作
        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        // 查询已有数据
        Date declareMonth = SalaryDateUtil.localDateToDate(LocalDate.parse(declareMonthStr + "-01", SalaryDateUtil.DATE_FORMATTER));
        List<AddUpDeduction> list = getAddUpDeductionMapper().listSome(AddUpDeduction.builder().declareMonth(declareMonth).build());

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

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

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

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

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

                AddUpDeductionDTO dto = addUpDeductions.get(i);

                Date now = new Date();
                //待插入数据库对象
                AddUpDeduction addUpDeduction = AddUpDeduction.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<DataCollectionEmployee> employeeSameIds = getSalaryEmployeeService(user).matchImportEmployee(confValue, employees, userName, deparmentName, mobile, workcode, idNo, null);

                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)) {
                    Map<String, String> errorMessageMap = Maps.newHashMap();
                    errorMessageMap.put("message", rowIndex + "员工信息不存在");
                    errorData.add(errorMessageMap);
                    errorSum += 1;
                } else if (employeeSameIds.size() > 1) {
                    //存在离职和在职状态取在职状态
                    employeeSameIds = employeeSameIds.stream().filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus())).collect(Collectors.toList());
                    if (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).getEmployeeId() : null;
                        addUpDeduction.setEmployeeId(employeeId);
                    }
                } else {
                    Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0).getEmployeeId() : null;
                    if (employeeId != null && employeeId > 0) {
                        addUpDeduction.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<TaxAgentPO> optionalTemp = taxAgentList.stream().filter(m -> m.getName().equals(taxAgentName)).findFirst();
                    if (optionalTemp.isPresent()) {
                        if (StringUtils.isNotEmpty(taxAgentId) && !optionalTemp.get().getId().equals(Long.valueOf(taxAgentId))) {
                            //个税扣缴义务人与导入时选择的不一致
                            Map<String, String> errorMessageMap = Maps.newHashMap();
                            errorMessageMap.put("message", rowIndex + "个税扣缴义务人与导入时选择的不一致");
                            errorData.add(errorMessageMap);
                            errorSum += 1;
                        } else {
                            addUpDeduction.setTaxAgentId(optionalTemp.get().getId());
                            // taxAgentEmployees = optionalTemp.get().getEmployeeList();
                        }
                    } else {
                        //个税扣缴义务人不存在
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "个税扣缴义务人不存在或不在权限范围内");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }


                //fixme 分权判断
//                if (openDevolution) {
//                    Optional<TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee> optionalTaxAgentEmp = taxAgentEmployees.stream().filter(f -> f.getEmployeeId().equals(addUpDeduction.getEmployeeId())).findFirst();
//                    if (!optionalTaxAgentEmp.isPresent()) {
//                        Map<String, String> errorMessageMap = Maps.newHashMap();
//                        errorMessageMap.put("message", rowIndex + "该条数据不在个税扣缴义务人人员范围内，不可导入");
//                        errorData.add(errorMessageMap);
//                        errorSum += 1;
//                    }
//                }

                // 判断是否有核算过
                if (CollectionUtils.isNotEmpty(salaryAcctEmployees)) {
                    Optional<SalaryAcctEmployeePO> optionalAcctEmp = salaryAcctEmployees.stream().filter(f -> f.getEmployeeId().equals(addUpDeduction.getEmployeeId()) && f.getTaxAgentId().equals(addUpDeduction.getTaxAgentId())).findFirst();
                    boolean isExist = list.stream().anyMatch(f -> f.getEmployeeId().equals(addUpDeduction.getEmployeeId()) && f.getTaxAgentId().equals(addUpDeduction.getTaxAgentId()));
                    if (optionalAcctEmp.isPresent() && isExist) {
                        Map<String, String> errorMessageMap = Maps.newHashMap();
                        errorMessageMap.put("message", rowIndex + "该年月这条数据已经核算过，不可导入");
                        errorData.add(errorMessageMap);
                        errorSum += 1;
                    }
                }
                //累计子女教育
                String addUpChildEducation = dto.getAddUpChildEducation();
                addUpDeduction.setAddUpChildEducation(Util.null2String(addUpChildEducation));
                //累计继续教育
                String addUpContinuingEducation = dto.getAddUpContinuingEducation();
                addUpDeduction.setAddUpContinuingEducation(Util.null2String(addUpContinuingEducation));
                //累计住房贷款利息
                String addUpHousingLoanInterest = dto.getAddUpHousingLoanInterest();
                addUpDeduction.setAddUpHousingLoanInterest(Util.null2String(addUpHousingLoanInterest));
                //累计住房租金
                String addUpHousingRent = dto.getAddUpHousingRent();
                addUpDeduction.setAddUpHousingRent(Util.null2String(addUpHousingRent));
                //累计赡养老人
                String addUpSupportElderly = dto.getAddUpSupportElderly();
                addUpDeduction.setAddUpSupportElderly(Util.null2String(addUpSupportElderly));
                addUpDeduction.setAddUpIllnessMedical(Util.null2String(dto.getAddUpIllnessMedical()));
                addUpDeduction.setAddUpInfantCare(Util.null2String(dto.getAddUpInfantCare()));
                if (errorSum == 0) {
                    successCount += 1;
                    // 合格数据
                    eligibleData.add(addUpDeduction);
                } else {
                    errorCount += 1;
                    // 添加错误数据
                }
            }
            //入库
            handleImportData(eligibleData);
            apidatas.put("successCount", successCount);
            apidatas.put("errorCount", errorCount);
            apidatas.put("errorData", errorData);
        } finally {
            IOUtils.closeQuietly(fileInputStream);
        }
        return apidatas;
    }

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

        // 修改
        if (CollectionUtils.isNotEmpty(updateList)) {
            addUpDeductionBiz.batchUpdate(updateList);
        }
        // 保存
        if (CollectionUtils.isNotEmpty(saveList)) {
            addUpDeductionBiz.batchSave(saveList);
        }

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

        if (CollectionUtils.isNotEmpty(updateList)) {
            String formatYearMonth = SalaryDateUtil.getFormatYearMonth(po.getDeclareMonth());
            LoggerContext loggerContext = new LoggerContext();
            loggerContext.setUser(user);
            loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(0, "累计专项附加扣除 ") + formatYearMonth);
            loggerContext.setOperateType(OperateTypeEnum.ADD.getValue());
            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "导入"));
            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "导入累计专项附加扣除 ") + formatYearMonth);
            loggerContext.setNewValueList(updateList);
            SalaryElogConfig.addUpDeductionLoggerTemplate.write(loggerContext);
        }

    }

    @Override
    public void editAddUpDeduction(AddUpDeductionRecordParam addUpDeduction) {
        AddUpDeductionBiz addUpDeductionBiz = new AddUpDeductionBiz();
        String declareMonthStr = addUpDeduction.getDeclareMonth();

        AddUpDeduction po = addUpDeductionBiz.getById(addUpDeduction.getId());
        if (po == null) {
            throw new SalaryRunTimeException("该数据不存在！");
        }
        // 获取所有个税扣缴义务人
        TaxAgentQueryParam param = TaxAgentQueryParam.builder().build();
        param.setFilterType(AuthFilterTypeEnum.ADMIN_DATA);
        Collection<TaxAgentPO> taxAgentList = getTaxAgentService(user).listAuth(param);
        List<Long> taxAgentIds = SalaryEntityUtil.properties(taxAgentList, TaxAgentPO::getId, Collectors.toList());
        Long taxAgentId = po.getTaxAgentId();
        if (!taxAgentIds.contains(taxAgentId)) {
            //没有编辑权限
            throw new SalaryRunTimeException("该个税扣缴义务人无权限编辑此数据！");
        }

        // 已经核算过的不可操作
        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        // 判断是否有核算过
        if (CollectionUtils.isNotEmpty(salaryAcctEmployees)) {
            Optional<SalaryAcctEmployeePO> optionalAcctEmp = salaryAcctEmployees.stream().filter(f -> f.getEmployeeId().equals(addUpDeduction.getEmployeeId()) && f.getTaxAgentId().equals(addUpDeduction.getTaxAgentId())).findFirst();
            if (optionalAcctEmp.isPresent()) {
                throw new SalaryRunTimeException("该年月这条数据已经核算过,不可进行编辑！");
            }
        }
        ArrayList<AddUpDeduction> updateList = new ArrayList<>();
        AddUpDeduction build = AddUpDeduction.builder().id(addUpDeduction.getId()).addUpChildEducation(addUpDeduction.getAddUpChildEducation()).addUpContinuingEducation(addUpDeduction.getAddUpContinuingEducation()).addUpHousingLoanInterest(addUpDeduction.getAddUpHousingLoanInterest()).addUpHousingRent(addUpDeduction.getAddUpHousingRent()).addUpSupportElderly(addUpDeduction.getAddUpSupportElderly()).addUpIllnessMedical(addUpDeduction.getAddUpIllnessMedical()).addUpInfantCare(addUpDeduction.getAddUpInfantCare()).createTime(new Date()).build();
        updateList.add(build);
        addUpDeductionBiz.batchUpdate(updateList);

        // 记录日志
        AddUpDeduction newValue = addUpDeductionBiz.getById(build.getId());
        String name = SalaryI18nUtil.getI18nLabel(0, "编辑");
        LoggerContext<AddUpDeduction> loggerContext = new LoggerContext<>();
        loggerContext.setTargetId(addUpDeduction.getId().toString());
        loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(0, "累计专项附加扣除") + "-" + addUpDeduction.getId());
        loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
        loggerContext.setOperateTypeName(name);
        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "累计专项附加扣除") + "-" + SalaryI18nUtil.getI18nLabel(0, "编辑"));
        loggerContext.setOldValues(po);
        loggerContext.setNewValues(newValue);
        loggerContext.setUser(user);
        SalaryElogConfig.addUpDeductionLoggerTemplate.write(loggerContext);
    }

    @Override
    public void createAddUpDeduction(AddUpDeductionRecordParam addUpDeductionRecordParam) {
        //税款所属期
        String declareMonthStr = addUpDeductionRecordParam.getDeclareMonth();
        if (declareMonthStr.equals("")) {
            throw new SalaryRunTimeException("税款所属期不能为空！");
        }
        // 获取所有个税扣缴义务人
        TaxAgentQueryParam param = TaxAgentQueryParam.builder().build();
        param.setFilterType(AuthFilterTypeEnum.ADMIN_DATA);
        Collection<TaxAgentPO> taxAgentList = getTaxAgentService(user).listAuth(param);
        // 获取租户下所有的人员
        List<DataCollectionEmployee> employees = getSalaryEmployeeService(user).listEmployee();
        // 已经核算过的不可操作
        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        // 查询已有数据
        Date declareMonth = SalaryDateUtil.localDateToDate(LocalDate.parse(declareMonthStr + "-01", SalaryDateUtil.DATE_FORMATTER));
        List<AddUpDeduction> list = getAddUpDeductionMapper().listSome(AddUpDeduction.builder().declareMonth(declareMonth).build());

        //查询对于人员信息导入筛选的全局配置
        SalarySysConfPO salarySysConfPO = getSalarySysConfMapper().getOneByCode("matchEmployeeMode");
        List<AddUpDeduction> insertData = new ArrayList<>();
        Date now = new Date();
        //待插入数据库对象
        AddUpDeduction addUpDeduction = AddUpDeduction.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(), addUpDeductionRecordParam.getEmployeeId()));
        if (!employeeSameId) {
            throw new SalaryRunTimeException("员工信息不存在");
        }
        addUpDeduction.setEmployeeId(addUpDeductionRecordParam.getEmployeeId());

        String taxAgentName = addUpDeductionRecordParam.getTaxAgentName();
        if (StringUtils.isBlank(taxAgentName)) {
            //个税扣缴义务人不能为空
            throw new SalaryRunTimeException("个税扣缴义务人不能为空");
        } else {
            Optional<TaxAgentPO> optionalTemp = taxAgentList.stream().filter(m -> m.getName().equals(taxAgentName)).findFirst();
            if (optionalTemp.isPresent()) {
                addUpDeduction.setTaxAgentId(optionalTemp.get().getId());
            } else {
                //个税扣缴义务人不存在或不在权限范围内
                throw new SalaryRunTimeException("个税扣缴义务人不存在或不在权限范围内");
            }
        }

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

        //累计子女教育
        String addUpChildEducation = addUpDeductionRecordParam.getAddUpChildEducation();
        addUpDeduction.setAddUpChildEducation(Util.null2String(addUpChildEducation));
        //累计继续教育
        String addUpContinuingEducation = addUpDeductionRecordParam.getAddUpContinuingEducation();
        addUpDeduction.setAddUpContinuingEducation(Util.null2String(addUpContinuingEducation));
        //累计住房贷款利息
        String addUpHousingLoanInterest = addUpDeductionRecordParam.getAddUpHousingLoanInterest();
        addUpDeduction.setAddUpHousingLoanInterest(Util.null2String(addUpHousingLoanInterest));
        //累计住房租金
        String addUpHousingRent = addUpDeductionRecordParam.getAddUpHousingRent();
        addUpDeduction.setAddUpHousingRent(Util.null2String(addUpHousingRent));
        //累计赡养老人
        String addUpSupportElderly = addUpDeductionRecordParam.getAddUpSupportElderly();
        addUpDeduction.setAddUpSupportElderly(Util.null2String(addUpSupportElderly));

        addUpDeduction.setAddUpIllnessMedical(Util.null2String(addUpDeductionRecordParam.getAddUpIllnessMedical()));
        addUpDeduction.setAddUpInfantCare(Util.null2String(addUpDeductionRecordParam.getAddUpInfantCare()));
        insertData.add(addUpDeduction);
        //入库
        handleImportData(insertData);
    }

    private void addLogger4Insert(Integer currentEmployeeId, AddUpDeduction addUpDeduction, String targetName) {
        String name = SalaryI18nUtil.getI18nLabel(0, "新增") + SalaryI18nUtil.getI18nLabel(0, "累计专项附加扣除");
        LoggerContext<AddUpDeduction> loggerContext = new LoggerContext<>();
        loggerContext.setTargetId(addUpDeduction.getId().toString());
        loggerContext.setTargetName(targetName);
        loggerContext.setOperateType(OperateTypeEnum.ADD.getValue());
        loggerContext.setOperateTypeName(name);
        loggerContext.setOperatedesc(name);
        loggerContext.setNewValues(addUpDeduction);
        loggerContext.setOperator(currentEmployeeId.toString());
        SalaryElogConfig.addUpDeductionLoggerTemplate.write(loggerContext);
    }

    @Override
    public void deleteSelectAddUpDeduction(AddUpDeductionRecordDeleteParam deleteParam) {
        long currentEmployeeId = user.getUID();
        // 获取所有个税扣缴义务人
        Collection<TaxAgentManageRangeEmployeeDTO> taxAgentList = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId);
        AddUpDeductionBiz addUpDeductionBiz = new AddUpDeductionBiz();
        String declareMonthStr = deleteParam.getDeclareMonth();
        List<Long> deleteIds = deleteParam.getIds();
        // 已经核算过的不可操作
        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        // 判断是否有核算过
        List<Long> deleteList = new ArrayList<>();
        ArrayList<AddUpDeduction> oldAddUpDeductions = new ArrayList<>();
        for (int i = 0; i < deleteIds.size(); i++) {
            Long id = deleteIds.get(i);
            AddUpDeduction byId = addUpDeductionBiz.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());
            oldAddUpDeductions.add(byId);
        }
        addUpDeductionBiz.batchDeleteByIDS(deleteList);

        //记录日志
        if (CollectionUtils.isNotEmpty(oldAddUpDeductions)) {
            oldAddUpDeductions.stream().forEach(e -> {
                LoggerContext<AddUpDeduction> loggerContext = new LoggerContext<>();
                loggerContext.setTargetId(e.getId().toString());
                loggerContext.setTargetName(SalaryI18nUtil.getI18nLabel(0, "累计专项附加扣除") + "-" + e.getId());
                loggerContext.setOperateType(OperateTypeEnum.DELETE.getValue());
                loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "删除"));
                loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "累计专项附加扣除") + "-" + SalaryI18nUtil.getI18nLabel(0, "删除"));
                loggerContext.setOldValues(e);
                loggerContext.setUser(user);
                SalaryElogConfig.addUpDeductionLoggerTemplate.write(loggerContext);
            });
        }
    }

    @Override
    public void deleteAllAddUpDeduction(AddUpDeductionRecordDeleteParam deleteParam) {
        String declareMonthStr = deleteParam.getDeclareMonth();
        long currentEmployeeId = user.getUID();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 获取所有个税扣缴义务人
        TaxAgentQueryParam param = TaxAgentQueryParam.builder().build();
        param.setFilterType(AuthFilterTypeEnum.ADMIN_DATA);
        Collection<TaxAgentPO> taxAgentList = getTaxAgentService(user).listAuth(param);
        List<Long> taxAgentIds = SalaryEntityUtil.properties(taxAgentList, TaxAgentPO::getId, Collectors.toList());
        AddUpDeductionBiz addUpDeductionBiz = new AddUpDeductionBiz();
        ArrayList<Date> declareMonthDate = new ArrayList<>();
        try {
            declareMonthDate.add(sdf.parse(declareMonthStr + "-01"));
        } catch (Exception e) {
            throw new SalaryRunTimeException("日期异常");
        }
        AddUpDeductionQueryParam queryParam = null;
        if (deleteParam.getTaxAgentId() != null && (!deleteParam.getTaxAgentId().equals(""))) {
            // 设置了个税扣缴义务人
            Long taxAgentId = SalaryEntityUtil.string2Long(deleteParam.getTaxAgentId());
            ArrayList<Long> tai = new ArrayList<>();
            tai.add(taxAgentId);
            queryParam = AddUpDeductionQueryParam.builder().declareMonthDate(declareMonthDate).taxAgentIds(tai).build();
        } else {
            queryParam = AddUpDeductionQueryParam.builder().declareMonthDate(declareMonthDate).taxAgentIds(taxAgentIds).build();
        }
        // 获取所有想要删除的数据
        queryParam.setFilterType(AuthFilterTypeEnum.ADMIN_DATA);
        List<AddUpDeductionDTO> list = listAuth(queryParam);

        // 获取已经核算的数据
        List<SalaryAcctEmployeePO> salaryAcctEmployees = getAccountedEmployeeDataByTaxYearMonth(declareMonthStr);
        for (AddUpDeductionDTO 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("员工：" + item.getUsername() + ",在该年月中已完成核算并归档，不能进行一键清空！");
                }
            }
        }
        List<Long> deleteIds = list.stream().map(AddUpDeductionDTO::getId).collect(Collectors.toList());
        addUpDeductionBiz.batchDeleteByIDS(deleteIds);

        // 记录日志
        Collection<Long> finalTaxAgentIds = queryParam.getTaxAgentIds();
        List<String> taxAgentNames = taxAgentList.stream().filter(t -> finalTaxAgentIds.contains(t.getId())).map(TaxAgentPO::getName).collect(Collectors.toList());
        String name = declareMonthStr + " " + StringUtils.join(taxAgentNames, ",");
        LoggerContext<AddUpDeduction> loggerContext = new LoggerContext<>();
        loggerContext.setUser(user);
        loggerContext.setTargetName(name);
        loggerContext.setOperateType(OperateTypeEnum.CLEAR.getValue());
        loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "一键清空"));
        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "累计专项附加扣除") + "-" + SalaryI18nUtil.getI18nLabel(0, "一键清空：") + name);
        SalaryElogConfig.addUpDeductionLoggerTemplate.write(loggerContext);
    }

    @Override
    public AddUpDeductionRecordDTO getAddUpDeduction(AddUpDeductionQueryParam param) {
        ArrayList<Long> ids = new ArrayList<>();
        ids.add(param.getId());
        AddUpDeductionQueryParam build = AddUpDeductionQueryParam.builder().ids(ids).build();
        List<AddUpDeductionRecordDTO> addUpDeductionRecordDTOS = new AddUpDeductionBiz().recordList(build);
        if (addUpDeductionRecordDTOS == null || addUpDeductionRecordDTOS.size() == 0) {
            throw new SalaryRunTimeException("该数据不存在！");
        }
        return addUpDeductionRecordDTOS.get(0);
    }

    @Override
    public String autoAddAll(Date yearMonth, Boolean isAdmin, List<Long> taxAgentIds) {
        String cacheKey = "addUpDeduction_autoAddAll_processing";
        Object objVal = Util_DataCache.getObjVal(cacheKey);
        if (objVal != null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(135788, "一键累计过于频繁，请稍后再试 "));
        }
        try {
            Util_DataCache.setObjVal(cacheKey, true);
            //如果是定时任务直接查询所有，isAdmin传true
            Collection<TaxAgentPO> taxAgents;
            if (isAdmin) {
                taxAgents = getTaxAgentService(user).listAll();
            } else {
                TaxAgentQueryParam param = TaxAgentQueryParam.builder().build();
                param.setFilterType(AuthFilterTypeEnum.ADMIN_DATA);
                taxAgents = getTaxAgentService(user).listAuth(param);
            }
            // 过滤个税扣缴义务人选择框
            if (CollectionUtils.isNotEmpty(taxAgentIds)) {
                taxAgents = taxAgents.stream().filter(taxAgent -> taxAgentIds.contains(taxAgent.getId())).collect(Collectors.toList());
            }
            LocalDateTime yearMonthTime = DateUtil.toLocalDateTime(yearMonth);
            //设置时间到下一年1月1号
            Instant instant = yearMonthTime.plusYears(1L).withMonth(1).withDayOfMonth(1).atZone(ZoneOffset.systemDefault()).toInstant();
            Date nextYearStart = Date.from(instant);
            int countByDeclareAfter = getAddUpDeductionMapper().countByDeclareAfter(yearMonth, nextYearStart, taxAgents.stream().map(TaxAgentPO::getId).collect(Collectors.toList()));
            if (countByDeclareAfter > 0) {
                throw new SalaryRunTimeException("无法累计，请检查当前累计年度内该月后是否有累计专项附加扣除记录！");
            }
            List<AddUpDeduction> updateList = new ArrayList<>();
            List<AddUpDeduction> insertList = new ArrayList<>();
            List<Long> errorMessages = new ArrayList<>();
            List<SalaryAcctEmployeePO> accountedEmployeeData = getAccountedEmployeeDataByTaxYearMonth(DateUtil.format(yearMonth, "yyyy-MM"));
            for (TaxAgentPO taxAgent : taxAgents) {
                List<SpecialAddDeductionPO> employeePOs = getSpecialAddDeductionService(user).getSpecialAddDeductionPOByEmployee(null, taxAgent.getId());


                //获取上月员工数据，用于累加
                LocalDateTime lastMonthDateTime = yearMonthTime.minusMonths(1);
                Map<Long, List<AddUpDeduction>> lastEmpInfo;
                if (lastMonthDateTime.getYear() == yearMonthTime.getYear()) {
                    YearMonth lastMonth = YearMonth.of(lastMonthDateTime.getYear(), lastMonthDateTime.getMonth());
                    lastEmpInfo = getEmpInfoByYearMonth(taxAgent, employeePOs, lastMonth);
                } else {
                    lastEmpInfo = new HashMap<>(0);
                }

                //获取当月员工数据，用于更新
                YearMonth currentMonth = YearMonth.of(yearMonthTime.getYear(), yearMonthTime.getMonth());
                Map<Long, List<AddUpDeduction>> currentEmpInfo = getEmpInfoByYearMonth(taxAgent, employeePOs, currentMonth);

                employeePOs.forEach(employeePO -> {
                    Long employeeId = employeePO.getEmployeeId();
                    // 如果该员工当前月份已经核算，不做累计
                    SalaryAcctEmployeePO anyAccountedEmployee = accountedEmployeeData.stream().filter(e -> e.getEmployeeId().equals(employeeId)).filter(e -> e.getTaxAgentId().equals(taxAgent.getId())).findAny().orElse(null);
                    if (anyAccountedEmployee != null) {
                        errorMessages.add(employeeId);
                        return;
                    }
                    AddUpDeduction addUpDeduction = Optional.ofNullable(lastEmpInfo.get(employeeId)).flatMap(list -> list.stream().findFirst()).orElseGet(AddUpDeduction::new);
                    this.combine(addUpDeduction, employeePO);

                    addUpDeduction.setEmployeeId(employeeId);
                    addUpDeduction.setTaxAgentId(taxAgent.getId());
                    addUpDeduction.setDeclareMonth(DateUtil.beginOfMonth(yearMonth));
                    addUpDeduction.setCreator(user == null ? 0 : (long) user.getUID());
                    addUpDeduction.setTenantKey(DEFAULT_TENANT_KEY);

                    //确认当期是否有已经累计的记录
                    AddUpDeduction oldInfo = Optional.ofNullable(currentEmpInfo.get(employeeId)).flatMap(c -> c.stream().findFirst()).orElse(null);
                    Date now = new Date();
                    if (oldInfo == null) {
                        addUpDeduction.setCreateTime(now);
                        addUpDeduction.setUpdateTime(now);
                        insertList.add(encryptUtil.encrypt(addUpDeduction, AddUpDeduction.class));
                    } else {
                        addUpDeduction.setId(oldInfo.getId());
                        addUpDeduction.setCreateTime(oldInfo.getCreateTime());
                        addUpDeduction.setUpdateTime(now);
                        updateList.add(encryptUtil.encrypt(addUpDeduction, AddUpDeduction.class));
                    }
                });
            }
            Lists.partition(insertList, 100).forEach(l -> getAddUpDeductionMapper().insertData((List<AddUpDeduction>) l));
            Lists.partition(updateList, 100).forEach(l -> getAddUpDeductionMapper().updateDataAndDeclareMonth((List<AddUpDeduction>) l));

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

            if (CollectionUtils.isNotEmpty(updateList)) {
                String yearMonthStr = SalaryDateUtil.getFormatYearMonth(yearMonth);
                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(updateList);
                SalaryElogConfig.addUpDeductionLoggerTemplate.write(loggerContext);
            }

            if (!errorMessages.isEmpty()) {
                String userNames = getSalaryEmployeeService(user).getEmployeeByIdsAll(errorMessages).stream().map(DataCollectionEmployee::getUsername).collect(Collectors.joining(","));
                return "一键累计完成！员工" + userNames + "在该年月已核算归档，跳过本次累计";
            }
            return "一键累计完成！";
        } finally {
            Util_DataCache.clearVal(cacheKey);
        }
    }

    @Override
    public List<AddUpDeductionDTO> listAuth(AddUpDeductionQueryParam param) {
        List<AddUpDeductionDTO> list = getAddUpDeductionMapper().list(param);
        list = getAuthService(user).auth(list, param.getFilterType(), AddUpDeductionDTO.class);
        return list;
    }

    /**
     * 对每个扣除项做加法
     *
     * @param addUpDeduction 上次记录
     * @param employeePO     专项附加扣除值
     */
    private void combine(AddUpDeduction addUpDeduction, SpecialAddDeductionPO employeePO) {
        final String zero = "0";
        String childEducation = Optional.ofNullable(addUpDeduction.getAddUpChildEducation()).orElse(zero);
        addUpDeduction.setAddUpChildEducation(plus(childEducation, employeePO.getChildrenEducation()));

        String continuingEducation = Optional.ofNullable(addUpDeduction.getAddUpContinuingEducation()).orElse(zero);
        addUpDeduction.setAddUpContinuingEducation(plus(continuingEducation, employeePO.getContinuingEducation()));

        String housingLoanInterest = Optional.ofNullable(addUpDeduction.getAddUpHousingLoanInterest()).orElse(zero);
        addUpDeduction.setAddUpHousingLoanInterest(plus(housingLoanInterest, employeePO.getHousingLoanInterest()));

        String housingRent = Optional.ofNullable(addUpDeduction.getAddUpHousingRent()).orElse(zero);
        addUpDeduction.setAddUpHousingRent(plus(housingRent, employeePO.getHousingRent()));

        String supportElderly = Optional.ofNullable(addUpDeduction.getAddUpSupportElderly()).orElse(zero);
        addUpDeduction.setAddUpSupportElderly(plus(supportElderly, employeePO.getSupportingElder()));

        String illnessMedical = Optional.ofNullable(addUpDeduction.getAddUpIllnessMedical()).orElse(zero);
        addUpDeduction.setAddUpIllnessMedical(plus(illnessMedical, employeePO.getSeriousIllnessTreatment()));

        String infantCare = Optional.ofNullable(addUpDeduction.getAddUpInfantCare()).orElse(zero);
        addUpDeduction.setAddUpInfantCare(plus(infantCare, employeePO.getInfantCare()));
    }

    private String plus(String var0, String var1) {
        return SalaryEntityUtil.string2BigDecimalDefault0(var0).add(SalaryEntityUtil.string2BigDecimalDefault0(var1)).toString();
    }

    private Map<Long, List<AddUpDeduction>> getEmpInfoByYearMonth(TaxAgentPO taxAgent, List<SpecialAddDeductionPO> employeePOs, YearMonth lastMonth) {
        List<AddUpDeduction> addUpDeductionList = getAddUpDeductionList(lastMonth, employeePOs.stream().map(SpecialAddDeductionPO::getEmployeeId).collect(Collectors.toList()), Collections.singletonList(taxAgent.getId()));
        return addUpDeductionList.stream().filter(addUpDeduction -> taxAgent.getId().equals(addUpDeduction.getTaxAgentId())).collect(Collectors.groupingBy(AddUpDeduction::getEmployeeId));
    }


    private void checkImportParam(AddUpDeductionImportParam importParam) {


        //excel文件id
        String imageId = Util.null2String(importParam.getImageId());
        //税款所属期
        String declareMonthStr = Util.null2String(importParam.getDeclareMonth());
        //个税扣缴义务人
        String taxAgentId = Util.null2String(importParam.getTaxAgentId());

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


    @Override
    public Map<String, Object> preview(AddUpDeductionImportParam 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);
        }
    }


    @Override
    public AddUpDeduction getById(Long id) {
        return getAddUpDeductionMapper().getById(id);
    }

    @Override
    public PageInfo<AddUpDeductionDTO> listPage(AddUpDeductionQueryParam queryParam) {
        //申报月份
        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()));
        }

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

        queryParam.setFilterType(AuthFilterTypeEnum.DATA_OPT);
        List<AddUpDeductionDTO> list = listAuth(queryParam);

        PageInfo<AddUpDeductionDTO> pageInfo = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), list, AddUpDeductionDTO.class);
        encryptUtil.decryptList(pageInfo.getList(), AddUpDeductionDTO.class);
        SalaryI18nUtil.i18nList(pageInfo.getList());
        return pageInfo;
    }

    @Override
    public PageInfo<AddUpDeductionRecordDTO> recordListPage(AddUpDeductionQueryParam queryParam) {
        List<AddUpDeductionRecordDTO> list = getAddUpDeductionMapper().recordList(queryParam);
        list = getAuthService(user).auth(list, AuthFilterTypeEnum.DATA_OPT, AddUpDeductionRecordDTO.class);
        PageInfo<AddUpDeductionRecordDTO> page = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), list, AddUpDeductionRecordDTO.class);
        encryptUtil.decryptList(page.getList(), AddUpDeductionRecordDTO.class);
        return page;
    }


    /**
     * 导出详情列表
     *
     * @return
     */
    @Override
    public XSSFWorkbook exportDetail(Long beLongEmployeeId, AddUpDeductionQueryParam queryParam) {
        queryParam.setEmployeeId(beLongEmployeeId);
        AddUpDeductionBiz biz = new AddUpDeductionBiz();

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

        AddUpDeduction 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("员工信息不存在");
        }

        //查询参数
        queryParam.setEmployeeId(po.getEmployeeId());
        //申报月份
        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()));
        }


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


        //获取excel
        return ExcelUtil.genWorkbookWithDefaultPattern(rowList, "累计专项附加扣除明细", 2);
    }


    /**
     * 导出详情
     *
     * @param param
     * @return
     */
    private List<List<Object>> getExcelRowDetailList(AddUpDeductionQueryParam param) {

        //excel标题
        List<Object> title = Arrays.asList("姓名", "申报月份", "个税扣缴义务人", "部门", "工号", "累计子女教育", "累计继续教育", "累计住房贷款利息", "累计住房租金", "累计赡养老人", "累计大病医疗", "累计婴幼儿照护");


        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM");
        //查询详细信息
        List<AddUpDeductionRecordDTO> list = new AddUpDeductionBiz().recordList(param);
        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.getJobNum()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpChildEducation()) ? new BigDecimal(dto.getAddUpChildEducation()) : Util.null2String(dto.getAddUpChildEducation()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpContinuingEducation()) ? new BigDecimal(dto.getAddUpContinuingEducation()) : Util.null2String(dto.getAddUpContinuingEducation()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpHousingLoanInterest()) ? new BigDecimal(dto.getAddUpHousingLoanInterest()) : Util.null2String(dto.getAddUpHousingLoanInterest()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpHousingRent()) ? new BigDecimal(dto.getAddUpHousingRent()) : Util.null2String(dto.getAddUpHousingRent()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpSupportElderly()) ? new BigDecimal(dto.getAddUpSupportElderly()) : Util.null2String(dto.getAddUpSupportElderly()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpIllnessMedical()) ? new BigDecimal(dto.getAddUpIllnessMedical()) : Util.null2String(dto.getAddUpIllnessMedical()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpInfantCare()) ? new BigDecimal(dto.getAddUpInfantCare()) : Util.null2String(dto.getAddUpInfantCare()));

            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<AddUpDeduction> getAddUpDeductionList(YearMonth declareMonth, List<Long> employeeIds, List<Long> taxAgentIds) {
        AddUpDeductionBiz addUpDeductionBiz = new AddUpDeductionBiz();
        if (declareMonth == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100342, "参数有误：申报月份、租户key必传"));
        }
        return addUpDeductionBiz.listSome(AddUpDeduction.builder().declareMonth(SalaryDateUtil.toDateStartOfMonth(declareMonth)).employeeIds(employeeIds).taxAgentIds(taxAgentIds).build());
    }

    @Override
    public XSSFWorkbook downloadTemplate(AddUpDeductionQueryParam queryParam) {

        String sheetName = SalaryI18nUtil.getI18nLabel(101603, "累计专项附加扣除导入模板");
        String[] header = {SalaryI18nUtil.getI18nLabel(85429, "姓名"), SalaryI18nUtil.getI18nLabel(86184, "个税扣缴义务人"), SalaryI18nUtil.getI18nLabel(86185, "部门"), SalaryI18nUtil.getI18nLabel(86186, "手机号"), SalaryI18nUtil.getI18nLabel(86317, "工号"), SalaryI18nUtil.getI18nLabel(86318, "证件号码"), SalaryI18nUtil.getI18nLabel(86319, "入职日期"), SalaryI18nUtil.getI18nLabel(86321, "累计子女教育"), SalaryI18nUtil.getI18nLabel(86323, "累计继续教育"), SalaryI18nUtil.getI18nLabel(86324, "累计住房贷款利息"), SalaryI18nUtil.getI18nLabel(86325, "累计住房租金"), SalaryI18nUtil.getI18nLabel(86326, "累计赡养老人"), SalaryI18nUtil.getI18nLabel(105142, "累计大病医疗"), SalaryI18nUtil.getI18nLabel(105142, "累计婴幼儿照护")};

        List<Object> headerList = Arrays.asList(header);

        //查询当前申报月份和个税扣缴义务人的累计专项附加扣除表数据
        List<List<Object>> rows = new ArrayList<>();
        rows.add(headerList);
        if (queryParam.isHasData()) {
            queryParam.setFilterType(AuthFilterTypeEnum.ADMIN_DATA);
            List<List<Object>> datas = getLists(queryParam);
            rows.addAll(datas);
        }

        // 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, "输入数字")));
        excelComments.add(new ExcelComment(12, 0, 15, 2, SalaryI18nUtil.getI18nLabel(100344, "输入数字")));
        excelComments.add(new ExcelComment(13, 0, 16, 2, SalaryI18nUtil.getI18nLabel(100344, "输入数字")));

        XSSFWorkbook book = ExcelUtil.genWorkbookV2(rows, sheetName, excelComments);

        return book;
    }


    @Override
    public XSSFWorkbook export(AddUpDeductionQueryParam queryParam) {
        //excel标题
        List<Object> title = Arrays.asList("姓名", "个税扣缴义务人", "部门", "手机号", "工号", "证件号码", "入职日期", "累计子女教育", "累计继续教育", "累计住房贷款利息", "累计住房租金", "累计赡养老人", "累计大病医疗", "累计婴幼儿照护");

        queryParam.setFilterType(AuthFilterTypeEnum.QUERY_DATA);
        List<List<Object>> dataRowList = getLists(queryParam);

        List<List<Object>> rowList = new ArrayList<>();
        rowList.add(title);

        rowList.addAll(dataRowList);

        // 记录日志
        String name = SalaryI18nUtil.getI18nLabel(0, "导出");
        LoggerContext<AddUpDeduction> 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.addUpDeductionLoggerTemplate.write(loggerContext);

        //获取excel
        return ExcelUtil.genWorkbookV2WithDefaultPattern(rowList, "累计专项附加扣除", 2);
    }

    private List<List<Object>> getLists(AddUpDeductionQueryParam param) {

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

        List<AddUpDeductionDTO> list = listAuth(param);
        encryptUtil.decryptList(list, AddUpDeductionDTO.class);
        SalaryI18nUtil.i18nList(list);

        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.getAddUpChildEducation()) ? new BigDecimal(dto.getAddUpChildEducation()) : Util.null2String(dto.getAddUpChildEducation()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpContinuingEducation()) ? new BigDecimal(dto.getAddUpContinuingEducation()) : Util.null2String(dto.getAddUpContinuingEducation()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpHousingLoanInterest()) ? new BigDecimal(dto.getAddUpHousingLoanInterest()) : Util.null2String(dto.getAddUpHousingLoanInterest()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpHousingRent()) ? new BigDecimal(dto.getAddUpHousingRent()) : Util.null2String(dto.getAddUpHousingRent()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpSupportElderly()) ? new BigDecimal(dto.getAddUpSupportElderly()) : Util.null2String(dto.getAddUpSupportElderly()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpIllnessMedical()) ? new BigDecimal(dto.getAddUpIllnessMedical()) : Util.null2String(dto.getAddUpIllnessMedical()));
            cellList.add(NumberUtil.isNumber(dto.getAddUpInfantCare()) ? new BigDecimal(dto.getAddUpInfantCare()) : Util.null2String(dto.getAddUpInfantCare()));
            return cellList;
        }).collect(Collectors.toList())).orElse(Collections.emptyList());
        return dataRowList;
    }


    @Override
    public List<SalaryAcctEmployeePO> getAccountedEmployeeDataByTaxYearMonth(String yearMonth) {
        List<SalaryAcctEmployeePO> list = Lists.newArrayList();
        YearMonth month = YearMonth.parse(yearMonth);
        Date taxCycle = SalaryDateUtil.localDateToDate(month.atDay(1));

        List<SalaryAcctRecordPO> salaryAcctRecords = getSalaryAcctRecordService(user).listSome(SalaryAcctRecordPO.builder().taxCycle(taxCycle).build());
        List<SalarySobPO> salarySobPOS = getSalarySobService(user).listAll();
        List<Long> sobIds = salarySobPOS.stream()
                .filter(e -> IncomeCategoryEnum.WAGES_AND_SALARIES.getValue().equals(e.getIncomeCategory()))
                .map(SalarySobPO::getId)
                .collect(Collectors.toList());
        salaryAcctRecords.stream()
                .filter(e -> !SalaryAcctRecordStatusEnum.NOT_ARCHIVED.getValue().equals(e.getStatus()))
                .filter(e -> sobIds.contains(e.getSalarySobId()))
                .forEach(e -> {
                    list.addAll(getSalaryAcctEmployeeService(user).listBySalaryAcctRecordIds(Collections.singleton(e.getId())));
                });

        return list;
    }

    @Override
    public Map<String, Object> onlineRequest(AddUpDeductionMonthTaxAgentParam param) {
        SalaryAssert.notNull(param.getDeclareMonth(), SalaryI18nUtil.getI18nLabel(100586, "税款所属期必传"));
        //  获取接口配置
        TaxDeclarationApiConfigPO apiConfig = getTaxDeclarationApiConfigService(user).getConfig(true);
        //  获取包装类
        AddUpDeductionOnlineRequestWrapper requestWrapper = getAddUpDeductionOnlineRequestWrapper(null, apiConfig);
        //  获取报税信息
        List<TaxAgentTaxReturnPO> taxReturnPOList = getTaxAgentTaxReturnService(user).getByTaxAgentIds(param.getTaxAgentIds());
        List<TaxAgentTaxReturnPO> failReturnPOList = taxReturnPOList.stream().filter(e -> !TaxAgentTaxReturnStatusEnum.SUCCESS.getValue().equals(e.getCheckStatus())).collect(Collectors.toList());
        SalaryAssert.isFalse(taxReturnPOList.size() == failReturnPOList.size(), SalaryI18nUtil.getI18nLabel(183781, "企业未通过验证，暂时无法获取累计专项附加扣除数据，请先在【个税扣缴义务人】菜单验证企业报税信息"));
        Map<String, Object> result = new HashMap<>(1);
        if (!failReturnPOList.isEmpty()) {
            String failTaxAgentNames = failReturnPOList.stream().map(e -> requestWrapper.getTaxAgentMap().get(e.getTaxAgentId())).collect(Collectors.joining("、"));
            result.put("msg", String.format(SalaryI18nUtil.getI18nLabel(183782, "%s未通过登记验证，无法在线获取数据"), failTaxAgentNames));
        }
        //  获取请求
        List<AddUpDeductionRequestPO> requestPOList = getAddUpDeductionRequestPOS();
        SalaryAssert.isEmpty(requestPOList, SalaryI18nUtil.getI18nLabel(153341, "获取中，稍后请点击【获取结果下载】"));
        //  获取报送成功的人员名单
        Map<Long, List<EmployeeDeclarePO>> taxAgentEmpDeclareMap = getEmpDeclareMap(requestWrapper.getTaxAgentMap().keySet(), param.getDeclareMonth());
        //  开始请求接口获取数据
        List<QuerySpecialAmountResponse.Body> querySpecialAmountBodies = getQuerySpecialAmountBodies(param, requestWrapper, taxAgentEmpDeclareMap, taxReturnPOList);
        //  持久化数据
        persistFeedbackData(param, querySpecialAmountBodies);
        return result;
    }

    private AddUpDeductionOnlineRequestWrapper getAddUpDeductionOnlineRequestWrapper(List<AddUpDeductionRequestPO> requestPOList, TaxDeclarationApiConfigPO apiConfig) {
        boolean isOpenDevolution = getTaxAgentService(user).isOpenDevolution();
        long employeeId = (long) user.getUID();
        boolean isChief = getTaxAgentService(user).isChief(employeeId);
        List<TaxAgentPO> taxAgents = !isOpenDevolution || isChief ? getTaxAgentService(user).listAll() : (List<TaxAgentPO>) getTaxAgentService(user).listAllTaxAgentsAsAdmin(employeeId);
        List<Long> taxAgentIdSet = SalaryEntityUtil.properties(taxAgents, TaxAgentPO::getId, Collectors.toList());
        //  获取薪资档案
        List<SalaryArchivePO> salaryArchiveList = getSalaryArchiveService(user).listByRunStatus(Arrays.asList(
                SalaryArchiveStatusEnum.FIXED.getValue(),
                SalaryArchiveStatusEnum.SUSPEND.getValue(),
                SalaryArchiveStatusEnum.STOP_FROM_SUSPEND.getValue(),
                SalaryArchiveStatusEnum.STOP_FROM_PENDING.getValue())
        );
        salaryArchiveList = salaryArchiveList.stream().filter(e -> taxAgentIdSet.contains(e.getTaxAgentId())).collect(Collectors.toList());
        AddUpDeductionOnlineRequestWrapper requestWrapper = new AddUpDeductionOnlineRequestWrapper(requestPOList, salaryArchiveList, taxAgents, (long) user.getUID());
        requestWrapper.setApiConfig(apiConfig);
        return requestWrapper;
    }

    private Map<Long, List<EmployeeDeclarePO>> getEmpDeclareMap(Collection<Long> taxAgentIds, Date declareMonth) {
        List<EmployeeDeclarePO> employeeDeclarePOS = getEmployeeDeclarePOList(taxAgentIds, declareMonth);
        SalaryAssert.notEmpty(employeeDeclarePOS, SalaryI18nUtil.getI18nLabel(183783, "暂无人员报送状态为正常的数据，请先报送再获取累计专项附加扣除数据。"));
        return employeeDeclarePOS.stream().collect(Collectors.groupingBy(EmployeeDeclarePO::getTaxAgentId));
    }

    private List<EmployeeDeclarePO> getEmployeeDeclarePOList(Collection<Long> taxAgentIds, Date declareMonth) {
        return getEmployeeDeclareMapper().listSome(EmployeeDeclarePO.builder().declareStatus(DeclareStatusEnum.DECLARE_SUCCESS.getValue()).taxCycle(declareMonth).taxAgentIds(taxAgentIds).build());
    }

    private List<QuerySpecialAmountResponse.Body> getQuerySpecialAmountBodies(AddUpDeductionMonthTaxAgentParam param,
                                                                              AddUpDeductionOnlineRequestWrapper requestWrapper,
                                                                              Map<Long, List<EmployeeDeclarePO>> taxAgentEmployeeDeclareMap,
                                                                              List<TaxAgentTaxReturnPO> taxReturnPOList) {
        List<QuerySpecialAmountResponse.Body> queryResponseList = new ArrayList<>();
        for (TaxAgentTaxReturnPO returnPO : taxReturnPOList) {
            if (!TaxAgentTaxReturnStatusEnum.SUCCESS.getValue().equals(returnPO.getCheckStatus())) {
                continue;
            }
            //  发起请求
            String taxAgentName = requestWrapper.getTaxAgentMap().get(returnPO.getTaxAgentId());
            List<EmployeeDeclarePO> declarePOList = taxAgentEmployeeDeclareMap.getOrDefault(returnPO.getTaxAgentId(), new ArrayList<>());
            if (declarePOList.isEmpty()) {
                log.info("该主体下没有报送成功的人员，主体名称：{}", taxAgentName);
                continue;
            }
            QuerySpecialAmountResponse queryResponse = getQuerySpecialAmountResponse(returnPO, taxAgentName, declarePOList, param, requestWrapper.getApiConfig());
            //  校验请求结果
            String responseCode = Optional.ofNullable(queryResponse)
                    .map(QuerySpecialAmountResponse::getHead)
                    .map(SzyhResponseHead::getCode)
                    .orElse(null);
            String outerRequestId = Optional.ofNullable(queryResponse)
                    .map(QuerySpecialAmountResponse::getBody)
                    .map(QuerySpecialAmountResponse.Body::getRequestId)
                    .orElse(null);
            if (!SzyhApiConstant.SUCCESS_CODE.equals(responseCode) || StringUtils.isEmpty(outerRequestId)) {
                log.info("getQuerySpecialAmountBodies error：{}", JSON.toJSONString(queryResponse));
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(95828, "服务异常，请稍后重试"));
            }
            queryResponse.getBody().setTaxAgentId(returnPO.getTaxAgentId());
            queryResponseList.add(queryResponse.getBody());
        }
        return queryResponseList;
    }

    private void persistFeedbackData(AddUpDeductionMonthTaxAgentParam param, List<QuerySpecialAmountResponse.Body> queryResponseList) {
        long requestId = IdGenerator.generate();
        for (QuerySpecialAmountResponse.Body body : queryResponseList) {
            AddUpDeductionRequestPO po = AddUpDeductionRequestPO.builder()
                    .id(IdGenerator.generate())
                    .requestId(requestId)
                    .taxAgentId(body.getTaxAgentId())
                    .requestStatus(EnumAddUpDeductionRequestStatus.RUNNING.getValue())
                    .outerRequestId(body.getRequestId())
                    .taxYearMonth(param.getDeclareMonth())
                    .deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
                    .tenantKey(DEFAULT_TENANT_KEY)
                    .createTime(new Date())
                    .updateTime(new Date())
                    .creator((long) user.getUID())
                    .lockVersion(0)
                    .build();
            getAddUpDeductionRequestMapper().insertIgnoreNull(po);
        }
    }

    private QuerySpecialAmountResponse getQuerySpecialAmountResponse(TaxAgentTaxReturnPO returnPO,
                                                                     String taxAgentName,
                                                                     List<EmployeeDeclarePO> declarePOList,
                                                                     AddUpDeductionMonthTaxAgentParam param,
                                                                     TaxDeclarationApiConfigPO apiConfig) {
        String url = apiConfig.getHost() + SzyhApiConstant.QUERY_SPECIAL_AMOUNT;
        Map<String, Object> requestParam = DataCollectionBO.getApiBaseQueryParams(returnPO, taxAgentName, SalaryDateUtil.getFormatYYYYMM(param.getDeclareMonth()));
        requestParam.put("rylb", DataCollectionBO.getEmployeeList(declarePOList));
        String reqJson = JsonUtil.toJsonString(requestParam);
        log.info("getQuerySpecialAmountResponse params --- \n{}\n", reqJson);
        Map<String, String> params = new HashMap<>(1);
        Map<String, String> header = SingnatureData.initHeader(params, apiConfig.getAppKey(), apiConfig.getAppSecret());
        //  开始请求
        String res = HttpUtil.doPost(url, header, reqJson, HttpUtil.JSON_TYPE);
        log.info("getQuerySpecialAmountResponse res --- {}", res);
        return JsonUtil.parseObject(res, QuerySpecialAmountResponse.class);
    }

    @Override
    public AddUpDeductionRequestResultDTO onlineFeedback() {
        TaxDeclarationApiConfigPO apiConfig = getTaxDeclarationApiConfigService(user).getConfig(true);
        List<AddUpDeductionRequestPO> requestPOList = getAddUpDeductionRequestPOS();
        //  校验请求是否合法
        Long requestId = checkRequestPOList(requestPOList);
        //  前置数据封装为包装类
        AddUpDeductionOnlineRequestWrapper requestWrapper = getAddUpDeductionOnlineRequestWrapper(requestPOList, apiConfig);
        //  开始请求反馈数据
        AddUpDeductionRequestResultDTO resultDTO = getQuerySpecialAmountFeedback(requestWrapper);
        //  判断是否需要继续轮询或者异常退出
        if (!resultDTO.getFinish()) {
            return resultDTO;
        }
        //  更新请求状态为已完成
        updateRequestStatus(requestPOList, EnumAddUpDeductionRequestStatus.RUNNING.getValue(), EnumAddUpDeductionRequestStatus.COMPLETED.getValue());
        //  获取员工信息
        setEmployeeInfoMap(requestWrapper);
        //  获取已存在的累计附加扣除数据
        setExistedDataMap(requestWrapper);
        //  开始处理反馈结果
        TaxDeclarationApiBillingServiceImpl.ApiFlowUpdateWrapper apiFlowUpdateWrapper
                = new TaxDeclarationApiBillingServiceImpl.ApiFlowUpdateWrapper(requestPOList.get(0).getTaxYearMonth(), requestWrapper.getApiConfig(), EnumDeclareApiBusinessType.ADD_UP_DEDUCTION, (long) user.getUID());
        handleFeedbackData(requestWrapper, apiFlowUpdateWrapper);
        //  持久化数据
        persistFeedbackData(requestWrapper);
        //  更新流量统计数据
        getTaxDeclarationApiBillingService(user).updateApiFlowInfo(apiFlowUpdateWrapper);
        //  返回结果
        return DataCollectionBO.buildRequestResultDTO(requestId, requestWrapper);
    }

    @Override
    public PageInfo<AddUpDeductionRequestFailListDTO> onlineFeedbackFail(AddUpDeductionRequestFailQueryParam queryParam) {
        List<AddUpDeductionRequestFailPO> addUpDeductionRequestFailPOS = getAddUpDeductionRequestFailMapper().listSome(AddUpDeductionRequestFailPO.builder().requestId(queryParam.getRequestId()).build());
        List<AddUpDeductionRequestFailPO> list = SalaryPageUtil.subList(queryParam.getCurrent(), queryParam.getPageSize(), addUpDeductionRequestFailPOS);
        //  获取薪资档案
        AddUpDeductionOnlineRequestWrapper requestWrapper = getAddUpDeductionOnlineRequestWrapper(null, null);
        this.getEmployeeInfoMap(requestWrapper);

        List<AddUpDeductionRequestFailListDTO> listDTOList = list.stream().map(requestWrapper::buildAddUpDeductionRequestFailListDTO).collect(Collectors.toList());

        PageInfo<AddUpDeductionRequestFailListDTO> page = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), listDTOList, AddUpDeductionRequestFailListDTO.class);
        page.setTotal(addUpDeductionRequestFailPOS.size());
        return page;
    }

    @Override
    public List<AddUpDeductionRequestFailPO> getAddUpDeductionRequestFailPOList(Long requestId) {
        return getAddUpDeductionRequestFailMapper().listSome(AddUpDeductionRequestFailPO.builder().requestId(requestId).build());
    }

    @Override
    public XSSFWorkbook exportOnlineFeedbackFail( Long requestId) {
        List<List<Object>> rows = new ArrayList<>();
        //  表头
        List<Object> headers = new ArrayList<>();
        headers.add(SalaryI18nUtil.getI18nLabel(85429, "姓名"));
        headers.add(SalaryI18nUtil.getI18nLabel(86184, "个税扣缴义务人"));
        headers.add(SalaryI18nUtil.getI18nLabel(86317, "工号"));
        headers.add(SalaryI18nUtil.getI18nLabel(86185, "部门"));
        headers.add(SalaryI18nUtil.getI18nLabel(106277, "身份证号码"));
        headers.add(SalaryI18nUtil.getI18nLabel(144832, "失败原因"));
        rows.add(headers);
        //  获取薪资档案
        AddUpDeductionOnlineRequestWrapper requestWrapper = getAddUpDeductionOnlineRequestWrapper(null, null);
        //  获取身份信息map
        this.getEmployeeInfoMap(requestWrapper);
        //  获取数据
        List<AddUpDeductionRequestFailPO> pos = getAddUpDeductionRequestFailPOList(requestId);
        //  组装数据
        for (AddUpDeductionRequestFailPO po : pos) {
            AddUpDeductionRequestFailListDTO failListDTO = requestWrapper.buildAddUpDeductionRequestFailListDTO(po);
            List<Object> row = new ArrayList<>();
            row.add(failListDTO.getEmployeeName());
            row.add(failListDTO.getTaxAgentName());
            row.add(failListDTO.getJobNum());
            row.add(failListDTO.getDepartmentName());
            row.add(failListDTO.getIdNo());
            row.add(failListDTO.getFailReason());
            rows.add(row);
        }
        //  生成表格
        return ExcelUtil.genWorkbookV2(rows, "在线获取专项附加扣除失败数据");
    }


    private void getEmployeeInfoMap(AddUpDeductionOnlineRequestWrapper wrapper) {
        //  身份证号
        List<Long> employeeIds = SalaryEntityUtil.properties(wrapper.getSalaryArchiveList(), SalaryArchivePO::getEmployeeId, Collectors.toList());
        List<DataCollectionEmployee> simpleUserInfos = getSalaryEmployeeService(user).listByIds(employeeIds);
        Map<Long, DataCollectionEmployee> simpleUserInfoMap = SalaryEntityUtil.convert2Map(simpleUserInfos, DataCollectionEmployee::getEmployeeId);
        wrapper.setUserInfoUserIdMap(simpleUserInfoMap);
        //  人员信息
        List<DataCollectionEmployee> simpleEmployees = getSalaryEmployeeService(user).listAll(UseEmployeeTypeEnum.ALL);
        Map<Long, DataCollectionEmployee> simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, DataCollectionEmployee::getEmployeeId);
        wrapper.setSimpleEmployeeMap(simpleEmployeeMap);
        //  外部人员信息
        List<ExtEmpPO> extEmployeePOS = getExtEmpService(user).listAll();
        Map<Long, ExtEmpPO> extEmployeePOMap = SalaryEntityUtil.convert2Map(extEmployeePOS, ExtEmpPO::getId, e -> e);
        wrapper.setExtEmployeePOMap(extEmployeePOMap);
    }

    private List<AddUpDeductionRequestPO> getAddUpDeductionRequestPOS() {
        return getAddUpDeductionRequestMapper().listSome(AddUpDeductionRequestPO.builder().requestStatus(EnumAddUpDeductionRequestStatus.RUNNING.getValue()).build());
    }

    private void handleFeedbackData(AddUpDeductionOnlineRequestWrapper requestWrapper, TaxDeclarationApiBillingServiceImpl.ApiFlowUpdateWrapper apiFlowUpdateWrapper) {
        requestWrapper.getRequestFeedBackMap().forEach((outerRequestId, feedbacks) -> feedbacks.forEach(feedback -> {
            DataCollectionEmployee simpleUserInfo = requestWrapper.getUserInfoIdNoMap().get(feedback.getZzhm());
            Long extEmpId = requestWrapper.getExtEmployeeIdCardMap().get(feedback.getZzhm());
            Long employeeId = Optional.ofNullable(simpleUserInfo)
                    .map(DataCollectionEmployee::getEmployeeId)
                    .orElse(extEmpId);
            AddUpDeductionRequestPO requestPO = requestWrapper.getRequestPoMap().get(outerRequestId);

            //  流量使用情况
            TaxDeclarationApiFlowRecordPO flowRecordPO = TaxApiFlowBO.buildTaxDeclarationApiFlowRecordPO(apiFlowUpdateWrapper, requestPO.getTaxAgentId(), employeeId);

            if (employeeId == null || StringUtils.isNotEmpty(feedback.getSbyy())) {
                //  处理失败数据
                AddUpDeductionRequestFailPO failPO = DataCollectionBO.buildAddUpDeductionRequestFailPO(requestWrapper, requestPO, employeeId);
                failPO.setReason(employeeId == null
                        ? String.format("该人员报送成功的身份证号与人事档案下的身份证号不一致，报送人员信息:[%s]|[%s]", feedback.getXm(), feedback.getZzhm())
                        : feedback.getSbyy());
                failPO.setEmployeeType(simpleUserInfo != null ? EmployeeTypeEnum.ORGANIZATION.getValue() :
                        extEmpId != null ? EmployeeTypeEnum.EXT_EMPLOYEE.getValue() : 2);
                requestWrapper.getFailPOList().add(failPO);
                flowRecordPO.setEmployeeId(Optional.ofNullable(employeeId).orElse(0L));
                flowRecordPO.setResultStatus(TaxAgentTaxReturnStatusEnum.FAIL.getValue());
            } else {
                //  处理成功数据
                AddUpDeduction po = DataCollectionBO.buildAddUpDeductionPO(feedback);
                Long poId = requestWrapper.getExistedDataMap().get(requestPO.getTaxAgentId() + "-" + employeeId);
                if (Objects.nonNull(poId)) {
                    po.setId(poId);
                    requestWrapper.getUpdateList().add(po);
                } else {
                    setBaseInfo2PO(requestWrapper, employeeId, requestPO, po);
                    requestWrapper.getInsertList().add(po);
                }
            }
            apiFlowUpdateWrapper.getApiFlowDetailPOList().add(flowRecordPO);
        }));
    }

    private Long checkRequestPOList(List<AddUpDeductionRequestPO> requestPOList) {
        Map<Integer, List<AddUpDeductionRequestPO>> statusRequestMap = SalaryEntityUtil.group2Map(requestPOList, AddUpDeductionRequestPO::getRequestStatus);
        if (CollectionUtils.isEmpty(statusRequestMap.get(EnumAddUpDeductionRequestStatus.RUNNING.getValue()))) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(153343, "请先点击【在线获取】按钮，选择税款所属期进行获取数据。"));
        }
        Set<Long> requestIds = SalaryEntityUtil.properties(requestPOList, AddUpDeductionRequestPO::getRequestId);
        if (requestIds.size() != 1) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(153344, "当前同时存在多个任务，请联系管理员进行处理。"));
        }
        return requestPOList.get(0).getRequestId();
    }

    private void setEmployeeInfoMap(AddUpDeductionOnlineRequestWrapper requestWrapper) {
        //  内部员工（详细信息）
        List<DataCollectionEmployee> simpleEmployees = getSalaryEmployeeService(user).listAll(UseEmployeeTypeEnum.ORG);
        Map<Long, DataCollectionEmployee> simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, DataCollectionEmployee::getEmployeeId);
        requestWrapper.setSimpleEmployeeMap(simpleEmployeeMap);
        //  内部员工（身份证信息）
        List<Long> employeeIds = SalaryEntityUtil.properties(requestWrapper.getSalaryArchiveList(), SalaryArchivePO::getEmployeeId, Collectors.toList());
        List<DataCollectionEmployee> simpleUserInfos = getSalaryEmployeeService(user).listByIds(employeeIds);
        Map<String, DataCollectionEmployee> simpleUserInfoMap = SalaryEntityUtil.convert2Map(simpleUserInfos, DataCollectionEmployee::getIdNo);
        requestWrapper.setUserInfoIdNoMap(simpleUserInfoMap);
        //  外部员工信息
        List<ExtEmpPO> extEmployeePOS = getExtEmpService(user).listAll();
        Map<String, Long> extEmployeePOMap = SalaryEntityUtil.convert2Map(extEmployeePOS, ExtEmpPO::getIdNo, ExtEmpPO::getId);
        requestWrapper.setExtEmployeeIdCardMap(extEmployeePOMap);
    }

    private void setExistedDataMap(AddUpDeductionOnlineRequestWrapper requestWrapper) {
        Set<Long> taxAgentIds = SalaryEntityUtil.properties(requestWrapper.getSalaryArchiveList(), SalaryArchivePO::getTaxAgentId);
        List<AddUpDeduction> poList = getAddUpDeductionMapper().listSome(AddUpDeduction.builder().declareMonth(requestWrapper.getRequestPOList().get(0).getTaxYearMonth()).taxAgentIds(taxAgentIds).build());
        requestWrapper.setExistedDataMap(SalaryEntityUtil.convert2Map(poList, e -> e.getTaxAgentId() + "-" + e.getEmployeeId(), AddUpDeduction::getId));
    }

    private AddUpDeductionRequestResultDTO getQuerySpecialAmountFeedback(AddUpDeductionOnlineRequestWrapper requestWrapper) {
        for (AddUpDeductionRequestPO requestPO : requestWrapper.getRequestPOList()) {
            QuerySpecialAmountFeedbackResponse response = getQuerySpecialAmountFeedbackResponse(requestWrapper.getApiConfig(), requestPO);
            //  校验请求结果
            String responseCode = Optional.ofNullable(response).map(QuerySpecialAmountFeedbackResponse::getHead).map(SzyhResponseHead::getCode).orElse(null);
            String msg = Optional.ofNullable(response).map(QuerySpecialAmountFeedbackResponse::getHead).map(SzyhResponseHead::getMsg).orElse(null);
            if (SzyhApiConstant.HANDLING_CODE.equals(responseCode)||SzyhApiConstant.TASK_HANDLING_CODE.equals(responseCode)) {
                //  如果接口仍在处理中，则继续轮询
                return AddUpDeductionRequestResultDTO.builder().finish(false).msg(msg).build();
            }
            //  获取返回的人员信息列表
            if (!SzyhApiConstant.SUCCESS_CODE.equals(responseCode)) {
                log.info("getQuerySpecialAmountFeedback not success error：{}", JSON.toJSONString(response));
                throw new SalaryRunTimeException(msg);
            }
            List<QuerySpecialAmountFeedbackResponse.Feedback> feedbacks = Optional.of(response)
                    .map(QuerySpecialAmountFeedbackResponse::getBody)
                    .map(QuerySpecialAmountFeedbackResponse.Body::getRyxxlb)
                    .orElse(new ArrayList<>());
            if (feedbacks.isEmpty()) {
                log.info("getQuerySpecialAmountFeedback empty data error：{}", JSON.toJSONString(response));
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(175338, "税局接口错误，未返回有效数据"));
            }
            requestWrapper.getRequestFeedBackMap().put(requestPO.getOuterRequestId(), feedbacks);
            requestWrapper.getRequestPoMap().put(requestPO.getOuterRequestId(), requestPO);
        }
        return AddUpDeductionRequestResultDTO.builder().finish(true).build();
    }

    private void persistFeedbackData(AddUpDeductionOnlineRequestWrapper requestWrapper) {
        if (!requestWrapper.getInsertList().isEmpty()) {
            List<List<AddUpDeduction>> insertPartition = Lists.partition(requestWrapper.getInsertList(), 100);
            insertPartition.forEach(list -> {
                list = encryptUtil.encryptList(list, AddUpDeduction.class);
                getAddUpDeductionMapper().insertData(list);
            });
        }
        if (!requestWrapper.getUpdateList().isEmpty()) {
            List<List<AddUpDeduction>> updatePartition = Lists.partition(requestWrapper.getUpdateList(), 100);
            updatePartition.forEach(list -> {
                list = encryptUtil.encryptList(list, AddUpDeduction.class);
                getAddUpDeductionMapper().updateData(list);
            });
        }
        if (!requestWrapper.getFailPOList().isEmpty()) {
            List<List<AddUpDeductionRequestFailPO>> failPartition = Lists.partition(requestWrapper.getFailPOList(), 100);
            failPartition.forEach(list -> getAddUpDeductionRequestFailMapper().batchInsert(list));
        }
    }

    private void setBaseInfo2PO(AddUpDeductionOnlineRequestWrapper wrapper, Long employeeId, AddUpDeductionRequestPO requestPO, AddUpDeduction po) {
        po.setId(IdGenerator.generate());
        po.setDeclareMonth(wrapper.getRequestPOList().get(0).getTaxYearMonth());
        po.setTaxAgentId(requestPO.getTaxAgentId());
        po.setEmployeeId(employeeId);
        po.setCreateTime(new Date());
        po.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue());
//        po.setModifier(wrapper.getCurrentEmployeeId());
        po.setTenantKey(wrapper.getTenantKey());
        po.setCreator(wrapper.getCurrentEmployeeId());
    }

    public void updateRequestStatus(List<AddUpDeductionRequestPO> requestPOList, Integer oldStatus, Integer newStatus) {
        for (AddUpDeductionRequestPO requestPO : requestPOList) {
            int i = getAddUpDeductionRequestMapper().updateRequestStatusLockVersion(AddUpDeductionRequestPO.builder()
                    .requestStatus(newStatus)
                    .lockVersion(requestPO.getLockVersion() + 1)
                    .updateTime(new Date())
                    .oldStatus(oldStatus)
                    .id(requestPO.getId())
                    .oldLockVersion(requestPO.getLockVersion())
                    .build()
            );
//            SalaryAssert.isTrue(update, SalaryI18nUtil.getI18nLabel(95828, "服务异常，请稍后重试"));
        }
    }

    public QuerySpecialAmountFeedbackResponse getQuerySpecialAmountFeedbackResponse(TaxDeclarationApiConfigPO apiConfig, AddUpDeductionRequestPO requestPO) {
        String url = apiConfig.getHost() + SzyhApiConstant.GET_QUERY_SPECIAL_AMOUNT_FEEDBACK;
        Map<String, String> params = new HashMap<>(1);
        params.put("requestId", requestPO.getOuterRequestId());
        Map<String, String> header = SingnatureData.initHeader(Collections.emptyMap(), apiConfig.getAppKey(), apiConfig.getAppSecret());
        log.info("GET_QUERY_SPECIAL_AMOUNT_FEEDBACK params = {}", params);
        String res = HttpUtil.getRequest(url, header, params);
        log.info("GET_QUERY_SPECIAL_AMOUNT_FEEDBACK res = {}", res);
        return JsonUtil.parseObject(res, QuerySpecialAmountFeedbackResponse.class);
    }

    @Data
    public static class AddUpDeductionOnlineRequestWrapper {
        private String tenantKey;
        private Long currentEmployeeId;
        //  单次请求对应的反馈数据map
        private Map<String, List<QuerySpecialAmountFeedbackResponse.Feedback>> requestFeedBackMap;
        private Map<String, AddUpDeductionRequestPO> requestPoMap;
        //  查询薪资档案（定薪、待停薪、停薪）
        private List<SalaryArchivePO> salaryArchiveList;
        private Map<Long, String> taxAgentMap;
        //  员工信息map(身份证号 -> 员工ID)
        private Map<String, DataCollectionEmployee> userInfoIdNoMap;
        //  员工信息map(员工ID -> 身份证)
        private Map<Long, DataCollectionEmployee> userInfoUserIdMap;
        //  员工详细信息map(key = 员工ID)
        private Map<Long, DataCollectionEmployee> simpleEmployeeMap;
        //  获取当前库中累计附加扣除的数据
        private Map<String, Long> existedDataMap;
        //  需要新增的数据
        private List<AddUpDeduction> insertList;
        //  需要更新的数据
        private List<AddUpDeduction> updateList;
        //  失败数据（分页）
        private List<AddUpDeductionRequestFailListDTO> failDTOList;
        //  失败数据（持久化）
        private List<AddUpDeductionRequestFailPO> failPOList;
        //  请求详细信息列表
        private List<AddUpDeductionRequestPO> requestPOList;
        //  外部人员(身份证 -> id)
        private Map<String, Long> extEmployeeIdCardMap;
        //  外部人员(id -> 实体)
        private Map<Long, ExtEmpPO> extEmployeePOMap;
        //  api配置
        private TaxDeclarationApiConfigPO apiConfig;

        public AddUpDeductionOnlineRequestWrapper(List<AddUpDeductionRequestPO> requestPOList,
                                                  List<SalaryArchivePO> salaryArchiveList,
                                                  List<TaxAgentPO> taxAgents,
                                                  Long currentEmployeeId) {
            this.requestFeedBackMap = new HashMap<>();
            this.requestPoMap = new HashMap<>();
            this.insertList = new ArrayList<>();
            this.updateList = new ArrayList<>();
            this.failDTOList = new ArrayList<>();
            this.failPOList = new ArrayList<>();
            this.salaryArchiveList = salaryArchiveList;
            this.requestPOList = requestPOList;
            this.tenantKey = DEFAULT_TENANT_KEY;
            this.currentEmployeeId = currentEmployeeId;
            this.taxAgentMap = SalaryEntityUtil.convert2Map(taxAgents, TaxAgentPO::getId, TaxAgentPO::getName);
        }

        public AddUpDeductionRequestFailListDTO buildAddUpDeductionRequestFailListDTO(AddUpDeductionRequestFailPO failPO) {
            DataCollectionEmployee userInfo = this.userInfoUserIdMap.get(failPO.getEmployeeId());
            ExtEmpPO extEmployeePO = this.extEmployeePOMap.get(failPO.getEmployeeId());
            DataCollectionEmployee simpleEmployee = this.simpleEmployeeMap.get(failPO.getEmployeeId());
            String departmentName = Optional.ofNullable(simpleEmployee).map(DataCollectionEmployee::getDepartmentName).orElse("");

            AddUpDeductionRequestFailListDTO listDTO = AddUpDeductionRequestFailListDTO.builder()
                    .id(failPO.getId().toString())
                    .employeeId(failPO.getEmployeeId())
                    .employeeType(EmployeeTypeEnum.parseByValue(failPO.getEmployeeType()).toString())
                    .employeeName(Optional.ofNullable(simpleEmployee).map(DataCollectionEmployee::getUsername)
                            .orElse(Optional.ofNullable(extEmployeePO).map(ExtEmpPO::getUsername)
                                    .orElse("")))
                    .jobNum(Optional.ofNullable(simpleEmployee).map(DataCollectionEmployee::getWorkcode).orElse(""))
                    .idNo(Optional.ofNullable(userInfo).map(DataCollectionEmployee::getIdNo)
                            .orElse(Optional.ofNullable(extEmployeePO).map(ExtEmpPO::getIdNo)
                                    .orElse("")))
                    .departmentName(Optional.ofNullable(departmentName).orElse(""))
                    .failReason(failPO.getReason())
                    .taxAgentName(this.taxAgentMap.get(failPO.getTaxAgentId()))
                    .build();
            Pattern pattern = Pattern.compile("\\[+[\\u4e00-\\u9fa5]*+]+\\|+\\[+[0-9]*+]");
            Matcher matcher = pattern.matcher(Optional.ofNullable(failPO.getReason()).orElse(""));
            if (matcher.find()) {
                String[] split = failPO.getReason().split("\\|");
                listDTO.setEmployeeName(split[0].substring(split[0].indexOf('[') + 1, split[0].indexOf(']')));
                listDTO.setIdNo(split[1].substring(split[1].indexOf('[') + 1, split[1].indexOf(']')));
            }
            return listDTO;
        }
    }

}