package com.engine.salary.service.impl;

import cn.hutool.core.codec.Base64Encoder;
import cn.weaver.ecology.framework.rpc.annotation.RpcReference;
import com.alibaba.fastjson.JSONArray;
import com.api.formmode.mybatis.util.SqlProxyHandle;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.biz.SalarySendBiz;
import com.engine.salary.biz.SalarySendInfoBiz;
import com.engine.salary.biz.SalarySobBiz;
import com.engine.salary.constant.SalaryItemConstant;
import com.engine.salary.constant.SalaryTemplateSalaryItemSetGroupConstant;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.salaryBill.dto.*;
import com.engine.salary.entity.salaryBill.param.*;
import com.engine.salary.entity.salaryBill.po.SalarySendInfoPO;
import com.engine.salary.entity.salaryBill.po.SalarySendPO;
import com.engine.salary.entity.salaryBill.po.SalaryTemplatePO;
import com.engine.salary.entity.salaryacct.bo.SalaryAcctResultBO;
import com.engine.salary.entity.salaryacct.po.SalaryAcctEmployeePO;
import com.engine.salary.entity.salaryacct.po.SalaryAcctRecordPO;
import com.engine.salary.entity.salaryacct.po.SalaryAcctResultPO;
import com.engine.salary.entity.salaryarchive.po.TaxAgentPO;
import com.engine.salary.entity.salaryformula.dto.SalaryFormulaEmployeeDTO;
import com.engine.salary.entity.salarysob.dto.SalarySobCycleDTO;
import com.engine.salary.entity.salarysob.po.SalarySobPO;
import com.engine.salary.entity.taxrate.TaxAgent;
import com.engine.salary.enums.salaryaccounting.SalaryAcctRecordStatusEnum;
import com.engine.salary.enums.salarybill.SalarySendStatusEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.salaryacct.SalaryAcctEmployeeMapper;
import com.engine.salary.mapper.salaryacct.SalaryAcctRecordMapper;
import com.engine.salary.mapper.salaryacct.SalaryAcctResultMapper;
import com.engine.salary.mapper.salarybill.SalarySendMapper;
import com.engine.salary.service.*;
import com.engine.salary.util.JsonUtil;
import com.engine.salary.util.SalaryDateUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.db.MapperProxyFactory;
import com.engine.salary.util.excel.ExcelUtil;
import com.engine.salary.util.page.PageInfo;
import dm.jdbc.util.IdGenerator;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.annotation.Transactional;
import weaver.hrm.User;

import javax.annotation.Resource;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.stream.Collectors;

/**
 * @Description: 工资单发放
 * @Author: wangxiangzhong
 * @Date: 2021-12-11 11:28
 */
public class SalarySendServiceImpl extends Service implements SalarySendService {

    private static final Logger log = LoggerFactory.getLogger(SalarySendServiceImpl.class);

    private SalarySendBiz mapper = new SalarySendBiz();
    private SalarySendInfoBiz salarySendInfoMapper = new SalarySendInfoBiz();


    private SalaryTemplateService getSalaryTemplateService(User user) {
        return ServiceUtil.getService(SalaryTemplateServiceImpl.class, user);
    }

    private SalarySobBiz salarySobMapper = new SalarySobBiz();


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

    private SalaryAcctRecordMapper getSalaryAcctRecordMapper() {
        return SqlProxyHandle.getProxy(SalaryAcctRecordMapper.class);
    }

    private SalaryAcctEmployeeMapper getSalaryAcctEmployeeMapper() {
        return SqlProxyHandle.getProxy(SalaryAcctEmployeeMapper.class);
    }

//    @Resource
    private SalaryAcctResultMapper getSalaryAcctResultMapper() {
        return SqlProxyHandle.getProxy(SalaryAcctResultMapper.class);
    }

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

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

//    @RpcReference
//    private FileDownloadClient fileDownloadClient;
//    /**
//     * 同步用RpcReference
//     */
//    @RpcReference
//    private SystemMessageRest systemMessageRest;
//    /**
//     * 异步用Autowired
//     */
//    @Autowired
//    private AsyncSystemMessageRest asyncSystemMessageRest;
//    @RpcReference
//    private MailBaseService mailBaseService;
//    @Resource
//    private SalaryBatchService salaryBatchService;
//    @Autowired
//    private LoggerTemplate salarySendLoggerTemplate;
//    @Autowired
//    private HrmCommonEmployeeService hrmCommonEmployeeService;
//    @Autowired
//    private ExecutorService taskExecutor;

    @Override
    public SalarySendPO getById(Long salarySendId) {
        return mapper.getById(salarySendId);
    }

    @Override
    public List<Long> findReAccountingIdsByAcctIds(List<Long> salaryAccountingIds, String tenantKey) {
        // 校验salaryAccountingId
        if (CollectionUtils.isEmpty(salaryAccountingIds)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100497, "核算id必传"));
        }

//        List<SalarySendPO> salarySends = new LambdaQueryChainWrapper<>(mapper)
//            .eq(SalarySendPO::getDeleteType, 0)
//            .eq(SalarySendPO::getSendNum, 0)
//            .in(SalarySendPO::getSalaryAccountingId, salaryAccountingIds)
//            .list();

        Map<String, Object> condition = new HashMap<>();
        condition.put("deleteType", 0);
        condition.put("sendNum", 0);
        condition.put("salaryAccountingIds", salaryAccountingIds);
        List<SalarySendPO> salarySends = mapper.listSomeWithCondition(condition);

        return salarySends.stream().map(SalarySendPO::getSalaryAccountingId).collect(Collectors.toList());
    }

//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public WeaResult<Boolean> generateSalaryBill(Long salaryAccountingId, Long currentEmployeeId, String currentTenantKey) {
//        // 校验salaryAccountingId
//        if (salaryAccountingId == null) {
//            return WeaResult.fail(SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100497, "核算id必传"));
//        }
//
//        List<SalaryAcctRecordPO> acctRecords = new LambdaQueryChainWrapper<>(salaryAcctRecordMapper)
//            .eq(SalaryAcctRecordPO::getDeleteType, 0)
//            .eq(SalaryAcctRecordPO::getTenantKey, currentTenantKey)
//            .eq(SalaryAcctRecordPO::getId, salaryAccountingId)
//            .eq(SalaryAcctRecordPO::getStatus, SalaryAcctRecordStatusEnum.ARCHIVED.getValue()).list();
//        // 检查核算的归档记录
//        if (CollectionUtils.isEmpty(acctRecords)) {
//            return WeaResult.fail(SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100498, "核算记录不存在"));
//        }
//
//        List<SalarySendPO> salarySends = new LambdaQueryChainWrapper<>(mapper)
//            .eq(SalarySendPO::getDeleteType, 0)
//            .eq(SalarySendPO::getTenantKey, currentTenantKey)
//            .eq(SalarySendPO::getSalaryAccountingId, salaryAccountingId).list();
//        if (CollectionUtils.isNotEmpty(salarySends)) {
//            return WeaResult.fail(SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100499, "工资单已生成过，不可再重复生成"));
//        }
//
//        List<SalaryAcctEmployeePO> salaryAcctEmployees = new LambdaQueryChainWrapper<>(salaryAcctEmployeeMapper)
//            .eq(SalaryAcctEmployeePO::getDeleteType, 0)
//            .eq(SalaryAcctEmployeePO::getTenantKey, currentTenantKey)
//            .eq(SalaryAcctEmployeePO::getSalaryAcctRecordId, salaryAccountingId).list();
//
//        Long salarySendId = IdGenerator.generate();
//
//        SalaryAcctRecordPO salaryAcctRecord = acctRecords.get(0);
//
//        List<SalarySendInfoPO> salarySendInfos = org.apache.commons.collections4.CollectionUtils.emptyIfNull(salaryAcctEmployees).stream().map(m ->
//            SalarySendInfoPO.builder()
//                .id(IdGenerator.generate())
//                .salarySendId(salarySendId)
//                .employeeId(m.getEmployeeId())
//                .salaryMonth(m.getSalaryMonth())
//                .taxAgentId(m.getTaxAgentId())
//                .salaryAcctRecordId(m.getSalaryAcctRecordId())
//                .sendStatus(SalarySendStatusEnum.UNSEND.getValue())
//                .salaryTemplate("")
//                .creator(currentEmployeeId)
//                .createTime(LocalDateTime.now())
//                .updateTime(LocalDateTime.now())
//                .tenantKey(currentTenantKey)
//                .build()
//        ).collect(Collectors.toList());
//
//        SalarySendPO salarySend = SalarySendPO.builder()
//            .id(salarySendId)
//            .salaryMonth(salaryAcctRecord.getSalaryMonth())
//            .salaryAccountingId(salaryAccountingId)
//            .salarySobId(salaryAcctRecord.getSalarySobId())
//            .sendNum(0)
//            .sendTotal(salarySendInfos.size())
//            .lastSendTime(LocalDateTime.now())
//            .creator(currentEmployeeId)
//            .createTime(LocalDateTime.now())
//            .updateTime(LocalDateTime.now())
//            .tenantKey(currentTenantKey)
//            .build();
//        // 插入工资单发放记录
//        mapper.insert(salarySend);
//        // 插入工资单人员记录
//        salarySendInfoMapper.batchInsert(salarySendInfos, currentTenantKey);
//
//        return WeaResult.success(Boolean.TRUE);
//    }

//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void revokeSalaryBill(Long salaryAccountingId, Long currentEmployeeId, String currentTenantKey) {
//        // 校验salaryAccountingId
//        if (salaryAccountingId == null) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100497, "核算id必传"));
//        }
//
//        List<SalaryAcctRecordPO> acctRecords = new LambdaQueryChainWrapper<>(salaryAcctRecordMapper)
//            .eq(SalaryAcctRecordPO::getDeleteType, 0)
//            .eq(SalaryAcctRecordPO::getTenantKey, currentTenantKey)
//            .eq(SalaryAcctRecordPO::getId, salaryAccountingId)
//            .list();
//        // 检查核算的归档记录
//        if (CollectionUtils.isEmpty(acctRecords)) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100498, "核算记录不存在"));
//        }
//
//        List<SalarySendPO> salarySends = new LambdaQueryChainWrapper<>(mapper)
//            .eq(SalarySendPO::getDeleteType, 0)
//            .eq(SalarySendPO::getTenantKey, currentTenantKey)
//            .eq(SalarySendPO::getSalaryAccountingId, salaryAccountingId).list();
//        if (CollectionUtils.isEmpty(salarySends)) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100505, "工资单不存在"));
//        }
//
//        SalarySendPO salarySend = salarySends.get(0);
//        // 已发送工资单
//        List<SalarySendInfoPO> salarySendInfos = new LambdaQueryChainWrapper<>(salarySendInfoMapper)
//            .eq(SalarySendInfoPO::getDeleteType, 0)
//            .eq(SalarySendInfoPO::getTenantKey, currentTenantKey)
//            .eq(SalarySendInfoPO::getSalarySendId, salarySend.getId())
//            .eq(SalarySendInfoPO::getSendStatus, SalarySendStatusEnum.ALREADYSEND.getValue()).list();
//        if (salarySend.getSendNum() > 0 || CollectionUtils.isNotEmpty(salarySendInfos)) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100507, "工资单已经发放，不可撤销"));
//        }
//        // 删除工资单
//        new LambdaUpdateChainWrapper<>(mapper)
//            .eq(SalarySendPO::getDeleteType, 0)
//            .eq(SalarySendPO::getTenantKey, currentTenantKey)
//            .eq(SalarySendPO::getId, salarySend.getId())
//            .set(SalarySendPO::getSendNum, 0)
//            .set(SalarySendPO::getDeleteType, 1).update();
//        // 删除工资单发放
//        new LambdaUpdateChainWrapper<>(salarySendInfoMapper)
//            .eq(SalarySendInfoPO::getDeleteType, 0)
//            .eq(SalarySendInfoPO::getTenantKey, currentTenantKey)
//            .eq(SalarySendInfoPO::getSalarySendId, salarySend.getId())
//            .set(SalarySendInfoPO::getDeleteType, 1).update();
//    }

    @Override
    public PageInfo<SalarySendListDTO> listPage(SalarySendQueryParam queryParam) {
        List<SalarySendListDTO> list = mapper.list(queryParam);
        PageInfo<SalarySendListDTO> pageInfo = new PageInfo<>(list, SalarySendListDTO.class);
        return pageInfo;
    }

    @Override
    public SalarySendBaseInfoDTO getBaseInfo(Long id) {
        SalarySendPO salarySend = mapper.getById(id);
        if (salarySend == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100512, "工资单发放不存在"));
        }
        Long salaryAcctId = salarySend.getSalaryAccountingId();
        SalarySobCycleDTO salarySobCycleDTO = getSalaryAcctRecordService(user).getSalarySobCycleById(salaryAcctId);

        String template = "";
        // 获取默认模板
        List<SalaryTemplatePO> salaryTemplates = getSalaryTemplateService(user).getDefaultTemplates(Collections.singletonList(salarySend.getSalarySobId()));
        if (CollectionUtils.isNotEmpty(salaryTemplates)) {
            template = salaryTemplates.get(0).getName();
        }

        return SalarySendBaseInfoDTO.builder()
            .salaryMonth(salarySobCycleDTO == null ? null : salarySobCycleDTO.getSalaryMonth())
            .template(template)
            .salarySobCycle(salarySobCycleDTO)
            .sendNum(salarySend.getSendNum())
            .sendTotal(salarySend.getSendTotal())
            .build();
    }

    @Override
    public Map<String, Object> mySalaryBill(Long salaryInfoId, Long currentEmployeeId) {
//        List<SalarySendInfoPO> salarySendInfos = new LambdaQueryChainWrapper<>(salarySendInfoMapper)
//            .eq(SalarySendInfoPO::getDeleteType, 0)
//            .eq(SalarySendInfoPO::getTenantKey, currentTenantKey)
//            .eq(SalarySendInfoPO::getId, salaryInfoId).list();

        SalarySendInfoPO po = new SalarySendInfoPO();
        po.setDeleteType(0);
        po.setId(salaryInfoId);

        List<SalarySendInfoPO> salarySendInfos = salarySendInfoMapper.listSome(po);
        if (CollectionUtils.isEmpty(salarySendInfos)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100511, "工资单信息不存在"));
        }
        SalarySendInfoPO salarySendInfo = salarySendInfos.get(0);
//        List<SalarySendPO> salarySends = new LambdaQueryChainWrapper<>(mapper)
//            .eq(SalarySendPO::getDeleteType, 0)
//            .eq(SalarySendPO::getTenantKey, currentTenantKey)
//            .eq(SalarySendPO::getId, salarySendInfo.getSalarySendId()).list();

        SalarySendPO sendPo = new SalarySendPO();
        sendPo.setDeleteType(0);
        sendPo.setId(salarySendInfo.getSalarySendId());
        List<SalarySendPO> salarySends = mapper.listSome(sendPo);
        if (CollectionUtils.isEmpty(salarySends)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100512, "工资单发放不存在"));
        }
        SalarySendPO salarySend = salarySends.get(0);
        Date salaryMonth = salarySend.getSalaryMonth();
        // 获取模板
        String salaryTemplateContent = salarySendInfo.getSalaryTemplate();
        if (StringUtils.isBlank(salaryTemplateContent)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100513, "没有默认模板，无法查看"));
        }

        SalaryTemplatePO salaryTemplate = buildSalaryTemplateContent(salaryTemplateContent);

//        if (StringUtils.isNotBlank(salaryTemplate.getBackground())) {
//            FileData fileByte = fileDownloadClient.getFileByte(Long.valueOf(salaryTemplate.getBackground()), currentTenantKey);
//            String encode = Base64Encoder.encode(fileByte.getData());
//            salaryTemplate.setBackground(encode);
//        }

//         获取薪资项目数据


        SalaryAcctResultPO acctPo = new SalaryAcctResultPO();
        acctPo.setDeleteType(0);
        acctPo.setSalaryAcctRecordId(salarySendInfo.getSalaryAcctRecordId());
        acctPo.setEmployeeId(currentEmployeeId);
        List<Map<String, Object>> salaryAcctResultS = getSalaryAcctResultMapper().listSome(acctPo).stream().map(m -> {
            Map<String, Object> map = new LinkedHashMap<>();
            map.put("salaryItemId", m.getSalaryItemId());
            map.put("resultValue", m.getResultValue());
            return map;
        }).collect(Collectors.toList());

        Map<String, Object> map = new LinkedHashMap<>();
        map.put("tenantName", "");
        map.put("sendTime", SalaryDateUtil.getFormatLocalDateTime(salarySendInfo.getSendTime()));
        List<SalaryTemplateSalaryItemSetListDTO> listDTOS = JSONArray.parseArray(salaryTemplate.getSalaryItemSetting(), SalaryTemplateSalaryItemSetListDTO.class);
        Optional<SalaryTemplateSalaryItemSetListDTO> optionalEmployeeInformation = listDTOS.stream().filter(e -> SalaryTemplateSalaryItemSetGroupConstant.EMPLOYEE_INFO_GROUP_ID.equals(e.getGroupId())).findFirst();
        SalaryTemplateSalaryItemSetListDTO employeeInformation = optionalEmployeeInformation.orElse(null);
        List<SalaryTemplateSalaryItemSetListDTO> itemSetListDTOS = listDTOS.stream().filter(e -> !SalaryTemplateSalaryItemSetGroupConstant.EMPLOYEE_INFO_GROUP_ID.equals(e.getGroupId())).collect(Collectors.toList());
        itemSetListDTOS.stream().forEach(item -> {
            item.getItems().stream()
                .forEach(e -> {
                    if (CollectionUtils.isEmpty(salaryAcctResultS)) {
                        e.setSalaryItemValue("");
                    } else {
                        Object o = salaryAcctResultS.stream()
                                .filter(f -> f.get("salaryItemId") != null && String.valueOf(f.get("salaryItemId")).equals(e.getSalaryItemId())).findFirst()
                                .orElse(new HashMap<>())
                                .get("resultValue");
                        e.setSalaryItemValue(o == null ? "" : (String) o);
                    }
                });
        });
        TaxAgent byId = getTaxAgentService(user).getById(salarySendInfo.getTaxAgentId());
        DataCollectionEmployee simpleEmployee = getSalaryEmployeeService(user).getEmployeeById(salarySendInfo.getEmployeeId());
        buildEmployeeInfo(employeeInformation, simpleEmployee, byId.getName(), SalaryAcctResultBO.buildEmployeeFieldName());
        map.put("employeeInformation", employeeInformation);
        map.put("salaryGroups", itemSetListDTOS);

        salaryTemplate.setTheme(getBillTitle(salaryTemplate.getTheme(), salaryMonth, currentEmployeeId));
        map.put("salaryTemplate", salaryTemplate);
        map.put("salaryAcctResult", salaryAcctResultS);

        return map;
    }

    @Override
    public PageInfo<SalarySendInfoListDTO> salarySendInfoListPage(SalarySendInfoQueryParam queryParam) {
        List<SalarySendInfoListDTO> page = salarySendInfoMapper.list(queryParam);
        PageInfo<SalarySendInfoListDTO> result = new PageInfo<>(page, SalarySendInfoListDTO.class);
        return result;
    }

    @Override
    public PageInfo<SalaryMySalaryBillListDTO> mySalaryBillListPage(SalaryBillQueryParam queryParam) {
        List<SalaryMySalaryBillListDTO> list = salarySendInfoMapper.mySalaryBillList(queryParam);
        PageInfo<SalaryMySalaryBillListDTO> pageInfo = new PageInfo<>(list, SalaryMySalaryBillListDTO.class);
        return pageInfo;
    }

    @Override
    public PageInfo<SalarySendDetailListDTO> salarySendInfoDetailListPage(SalarySendDetailQueryParam queryParam) {
        List<SalarySendDetailListDTO> list = salarySendInfoMapper.detailList(queryParam);
        PageInfo<SalarySendDetailListDTO> pageInfo = new PageInfo<>(list, SalarySendDetailListDTO.class);
        return pageInfo;
    }

    /**
     * 获取工资单标题
     * @param theme
     * @param salaryMonth
     * @param currentEmployeeId
     * @return
     */
    private String getBillTitle(String theme, Date salaryMonth, Long currentEmployeeId) {
        String yearI18n = SalaryI18nUtil.getI18nLabel(100325, "年");
        String monthI18n = SalaryI18nUtil.getI18nLabel(100326, "月");
        return theme
                // TODO 设置租户名称
                .replace("${companyName}", "")
                .replace("${salaryMonth}", new SimpleDateFormat("yyyy年MM月").format(salaryMonth));
    }

    /**
     * 根据模板内容转为工资单模板对象
     * 注意：不要通过反序列化，可能会因为历史原因修改字段名称而无法序列化
     * @param salaryTemplateContent
     * @return
     */
    private SalaryTemplatePO buildSalaryTemplateContent(String salaryTemplateContent) {
        Map<String, Object> map = JsonUtil.parseMap(salaryTemplateContent, Object.class);
        return SalaryTemplatePO.builder()
                .id(Long.valueOf(map.getOrDefault("id","0").toString()))
                .name(map.getOrDefault("name","").toString())
                .salarySobId(Long.valueOf(map.getOrDefault("salarySobId","0").toString()))
                .useType(Integer.valueOf(map.getOrDefault("useType","0").toString()))
                .description(map.getOrDefault("description","").toString())
                .emailStatus(Integer.valueOf(map.getOrDefault("emailStatus","0").toString()))
                .sendEmailId(Long.valueOf(map.getOrDefault("sendEmailId","0").toString()))
                .msgStatus(Integer.valueOf(map.getOrDefault("msgStatus","0").toString()))
                .theme(map.getOrDefault("theme","").toString())
                .background(map.getOrDefault("background","").toString())
                .textContent(map.getOrDefault("textContent","").toString())
                .textContentPosition(Integer.valueOf(map.getOrDefault("textContentPosition","0").toString()))
                .salaryItemNullStatus(Integer.valueOf(map.getOrDefault("salaryItemNullStatus","0").toString()))
                .salaryItemZeroStatus(Integer.valueOf(map.getOrDefault("salaryItemZeroStatus","0").toString()))
                .salaryItemSetting(map.getOrDefault("salaryItemSetting","").toString())
                .build();
    }

    /**
     * 构建工资单中的人员信息
     * @param employeeInformation
     * @param simpleEmployee
     * @param taxAgentName
     * @param employeeField
     */
    private void buildEmployeeInfo(SalaryTemplateSalaryItemSetListDTO employeeInformation, DataCollectionEmployee simpleEmployee, String taxAgentName, Map<String, String> employeeField) {
        if (employeeInformation == null) {
            return;
        }
        if (CollectionUtils.isNotEmpty(employeeInformation.getItems())) {
            //获取员工信息的字段名和中文描述的map关系
            SalaryFormulaEmployeeDTO salaryFormulaEmployeeDTO = SalaryFormulaEmployeeDTO.builder().employeeId(simpleEmployee.getEmployeeId())
                    .birthday(simpleEmployee.getBirthday())
                    .departmentName(simpleEmployee.getDepartmentName() )
                    .email(StringUtils.isEmpty(simpleEmployee.getEmail()) ? "" : simpleEmployee.getEmail())
                    .gradeName(simpleEmployee.getJobcall())
                    .hireDate(SalaryDateUtil.getFormatLocalDate(simpleEmployee.getCompanystartdate()))
                    .sex(simpleEmployee.getSex() == "0" ? "男" : "女")
                    .mobile(StringUtils.isEmpty(simpleEmployee.getMobile()) ? "" : simpleEmployee.getMobile())
                    .positionName(simpleEmployee.getJobtitleName())
                    .status(simpleEmployee.getStatus() == null ? "" : simpleEmployee.getStatus())
                    .telephone(StringUtils.isEmpty(simpleEmployee.getTelephone()) ? "" : simpleEmployee.getTelephone())
                    .username(StringUtils.isEmpty(simpleEmployee.getUsername()) ? "" : simpleEmployee.getUsername())
                    .taxAgentName(taxAgentName)
                    .build();
            List<SalaryTemplateSalaryItemListDTO> items = employeeInformation.getItems();
            Set<Map.Entry<String, String>> entries = employeeField.entrySet();
            for (SalaryTemplateSalaryItemListDTO e : items) {
                Optional<Map.Entry<String, String>> entry = entries.stream().filter(f -> Objects.equals(e.getName(), f.getValue())).findFirst();
                if (entry.isPresent()) {
                    String key = entry.get().getKey();
                    if (StringUtils.isNotBlank(key)) {
                        String getter = "get" + key.substring(0, 1).toUpperCase() + key.substring(1);
                        try {
                            Method method = salaryFormulaEmployeeDTO.getClass().getMethod(getter);
                            Object invoke = method.invoke(salaryFormulaEmployeeDTO);
                            e.setSalaryItemValue((String) invoke);
                        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
                            log.error("no such method", e);
                        }
                    }
                }
            }
        }
    }

    /**
     * 组装详情数据
     *
     * @param salaryItems
     * @param list
     * @param salaryAccountingId
     */
    @Override
    public List<Map<String, Object>> buildDetailList(List<SalaryTemplateSalaryItemListDTO> salaryItems, List<SalarySendDetailListDTO> list, Long salaryAccountingId) {
        List<Map<String, Object>> listMaps = new ArrayList<>();
        if (CollectionUtils.isEmpty(list)) {
            return listMaps;
        }
        // 获取薪资项目数据
//        List<SalaryAcctResultPO> salaryAccountingResults = new LambdaQueryChainWrapper<>(salaryAcctResultMapper)
//            .eq(SalaryAcctResultPO::getDeleteType, 0)
//            .eq(SalaryAcctResultPO::getSalaryAcctRecordId, salaryAccountingId).list();

        SalaryAcctResultPO po = new SalaryAcctResultPO();
        po.setDeleteType(0);
        po.setSalaryAcctRecordId(salaryAccountingId);
        List<SalaryAcctResultPO> salaryAccountingResults = getSalaryAcctResultMapper().listSome(po);

        // 动态列
        list.forEach(e -> {
            Map<String, Object> map = new LinkedHashMap<>();
            map.put("id", e.getId());
            map.put("employeeId", e.getEmployeeId());
            map.put("username", e.getUsername());
            map.put("taxAgent", e.getTaxAgent());
            map.put("department", e.getDepartment());
            map.put("mobile", e.getMobile());
            map.put("jobNum", e.getJobNum());
            map.put("email", e.getEmail());
            salaryItems.forEach(i -> {
                Optional<SalaryAcctResultPO> optional = salaryAccountingResults.stream()
                    .filter(r -> r.getEmployeeId().equals(e.getEmployeeId()) && r.getSalaryItemId().equals(Long.valueOf(i.getSalaryItemId()))).findFirst();
                map.put(i.getSalaryItemId() + SalaryItemConstant.DYNAMIC_SUFFIX, optional.isPresent() ? optional.get().getResultValue() : "");
            });

            listMaps.add(map);
        });
        return listMaps;
    }

    /**
     * 通过薪资账套获取模板的薪资项目
     *
     * @param salaryTemplate
     * @return
     */
    @Override
    public List<SalaryTemplateSalaryItemListDTO> getSalaryItemsSetting(SalaryTemplatePO salaryTemplate) {
        List<SalaryTemplateSalaryItemListDTO> salaryItems = new ArrayList<>();

        if (salaryTemplate == null) {
            return salaryItems;
        }
        if (StringUtils.isNotEmpty(salaryTemplate.getSalaryItemSetting())) {
            List<SalaryTemplateSalaryItemSetListDTO> salaryTemplateShowSetData = JsonUtil.parseList(salaryTemplate.getSalaryItemSetting(),
                SalaryTemplateSalaryItemSetListDTO.class);
            salaryTemplateShowSetData.stream().filter(f -> !f.getGroupId().equals(SalaryTemplateSalaryItemSetGroupConstant.EMPLOYEE_INFO_GROUP_ID)).forEach(e -> {
                salaryItems.addAll(e.getItems());
            });
        }
        return salaryItems;
    }

    @Override
    public Map<String, Object> grant(SalarySendGrantParam param) {
        if (param.getSalarySendId() == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100327, "工资单发放Id必传"));
        }

        Long salarySendId = param.getSalarySendId();
        Collection<Long> ids = param.getIds();

        SalarySendPO salarySend = mapper.getById(salarySendId);
        if (salarySend == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100512, "工资单发放不存在"));
        }
        // 获取默认模板
        List<SalaryTemplatePO> salaryTemplates = getSalaryTemplateService(user).getDefaultTemplates(Collections.singletonList(salarySend.getSalarySobId()));
        if (CollectionUtils.isEmpty(salaryTemplates)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100518, "没有默认模板，无法发送"));
        }
        Date sendTime = new Date();
        // 获取可发送的列表
        List<Map<String, Object>> enableSendList = getEnableSendList(salarySend, ids, salaryTemplates.get(0));
        // 1.发放

        SalarySendInfoPO po = new SalarySendInfoPO();
        po.setSendStatus(SalarySendStatusEnum.ALREADYSEND.getValue());
        po.setSendTime(sendTime);
        po.setSalaryTemplate(JsonUtil.toJsonString(salaryTemplates.get(0)));

        salarySendInfoMapper.updateGrantWithdraw(po, salarySendId, Arrays.asList(SalarySendStatusEnum.UNSEND.getValue(), SalarySendStatusEnum.WITHDRAW.getValue()), ids);


        // 2.更新数量
        po = new SalarySendInfoPO();
        po.setDeleteType(0);
        po.setSalarySendId(salarySendId);

        List<SalarySendInfoPO> list = salarySendInfoMapper.listSome(po);

        int sendNum = (int) list.stream().filter(e -> e.getSendStatus().equals(SalarySendStatusEnum.ALREADYSEND.getValue())).count();
        int sendTotal = list.size();
        SalarySendPO salarySendNew = new SalarySendPO();
        try {
            BeanUtils.copyProperties(salarySend, salarySendNew);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        salarySendNew.setSendNum(sendNum);
        salarySendNew.setSendTotal(sendTotal);
        salarySendNew.setLastSendTime(sendTime);

        mapper.updateById(salarySendNew);

//        List<SalarySobPO> salarySobs = new LambdaQueryChainWrapper<>(salarySobMapper)
//            .eq(SalarySobPO::getTenantKey, TenantContext.getCurrentTenantKey())
//            .eq(SalarySobPO::getDeleteType, 0)
//            .eq(SalarySobPO::getId, salarySend.getSalarySobId())
//            .list();

        SalarySobPO salarySobPO = new SalarySobPO();
        salarySobPO.setDeleteType(0);
        salarySobPO.setId(salarySend.getSalarySobId());
        List<SalarySobPO> salarySobs = salarySobMapper.listSome(salarySobPO);

        // 记录日志
//        SalaryLoggerUtil.recordUpdateSingleLog(salarySendLoggerTemplate,
//            salarySend.getId(),
//            salarySend.getSalaryMonth() + "-" + (CollectionUtils.isNotEmpty(salarySobs) ? salarySobs.get(0).getName() : ""),
//            SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 93215, "工资单发放"),
//            SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 93215, "工资单发放"),
//            salarySend,
//            salarySendNew);

        // 3.异步发送消息：先修改数据再发消息，避免出错后无法撤回
        // TODO 异步发送消息
//        String tenantName = TenantContext.getCurrentTenant().getTenantName();
//        taskExecutor.execute(() -> {
//            try {
//                DSTenantKeyThreadVar.tenantKey.set(currentTenantKey);
//                sendMessage(salarySend, enableSendList, salaryTemplates.get(0), tenantName, currentEmployeeId, currentTenantKey);
//            } finally {
//                DSTenantKeyThreadVar.tenantKey.remove();
//            }
//        });

        Map<String, Object> map = new HashMap<>(2);
        map.put("sendNum", sendNum);
        map.put("sendTotal", sendTotal);

        return map;
    }

    private List<Map<String, Object>> getEnableSendList(SalarySendPO salarySend, Collection<Long> ids, SalaryTemplatePO salaryTemplate) {
        // 1.根据模板获取薪资项目设置
        List<SalaryTemplateSalaryItemListDTO> salaryItems = getSalaryItemsSetting(salaryTemplate);
        SalarySendDetailQueryParam queryParam = new SalarySendDetailQueryParam();
        queryParam.setSalarySendId(salarySend.getId());
        // 空就是所有
        queryParam.setIds(ids);
        queryParam.setSendStatuss(Arrays.asList(SalarySendStatusEnum.UNSEND.getValue(), SalarySendStatusEnum.WITHDRAW.getValue()));
        // 2.获取基本数据
        List<SalarySendDetailListDTO> list = salarySendInfoMapper.detailList(queryParam);
        // 3.组装详情数据
        List<Map<String, Object>> listMaps = buildDetailList(salaryItems, list, salarySend.getSalaryAccountingId());
        return listMaps;
    }

//    /**
//     * 发送消息
//     *
//     * @param salarySend
//     * @param enableSendList
//     * @param salaryTemplate
//     * @param currentTenantKey
//     */
//    private void sendMessage(SalarySendPO salarySend, List<Map<String, Object>> enableSendList, SalaryTemplatePO salaryTemplate, String tenantName, Long currentEmployeeId, String currentTenantKey) {
//        if (StringUtils.isNotBlank(salaryTemplate.getBackground())) {
//            FileData fileByte = fileDownloadClient.getFileByte(Long.valueOf(salaryTemplate.getBackground()), currentTenantKey);
//            String encode = Base64Encoder.encode(fileByte.getData());
//            salaryTemplate.setBackground(encode);
//        }
//        // 邮箱打开
//        boolean isEmailOpen = salaryTemplate.getEmailStatus().equals(SalaryTemplateWhetherEnum.TRUE.getValue());
//
//        LocalDate salaryMonth = salarySend.getSalaryMonth();
//        String yearI18n = SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100325, "年");
//        String monthI18n = SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100326, "月");
//        String text = salaryMonth.getYear() +
//                yearI18n +
//            salaryMonth.getMonth().getValue() +
//                monthI18n +
//            SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100520, "工资待发明细");
//
//        UserEntity sendUser = null;
//        // 标题
//        String title = getBillTitle(salaryTemplate.getTheme(), salaryMonth, tenantName, currentEmployeeId, currentTenantKey);
//
//        // 获取所有人员信息
//        List<Long> ids = enableSendList.stream().map(e->Long.valueOf(e.get("employeeId").toString())).collect(Collectors.toList());
//        List<SimpleEmployee> allEmployees = hrmCommonEmployeeService.getEmployeeByIds(ids, currentTenantKey);
//        List<SalaryTemplateSalaryItemSetListDTO> listDTOS = JSONArray.parseArray(salaryTemplate.getSalaryItemSetting(), SalaryTemplateSalaryItemSetListDTO.class);
//        Optional<SalaryTemplateSalaryItemSetListDTO> optionalEmployeeInformation = listDTOS.stream().filter(e -> SalaryTemplateSalaryItemSetGroupConstant.EMPLOYEE_INFO_GROUP_ID.equals(e.getGroupId())).findFirst();
//        SalaryTemplateSalaryItemSetListDTO employeeInformation = optionalEmployeeInformation.orElse(null);
//        Map<String, String> employeeField = SalaryAcctResultBO.buildEmployeeFieldName();
//        enableSendList.forEach(e -> {
//            Optional<SimpleEmployee> optionalSimpleEmployee = allEmployees.stream().filter(f->f.getEmployeeId().equals(Long.valueOf(e.get("employeeId").toString()))).findFirst();
//            if (optionalSimpleEmployee.isPresent()) {
//                buildEmployeeInfo(employeeInformation, optionalSimpleEmployee.get(), e.get("taxAgent").toString(), employeeField);
//            }
//
//            List<UserEntity> receivers = Collections.singletonList(
//                SalarySendBO.buildUser(Long.valueOf(e.get("employeeId").toString()), e.get("email") == null ? "" : e.get("email").toString(), currentTenantKey));
//            Entity entity = SalarySendBO.buildEntity(e.get("id").toString(), SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 94626, "工资单"));
//            EmailEntity emailInfo = new EmailEntity();
//            // 邮箱打开
//            if (isEmailOpen) {
//                String emailContent = SalarySendBO.buildEmailContent(e, employeeInformation, title, salaryTemplate);
//                emailInfo = SalarySendBO.buildEmailInfo(text, emailContent, salaryTemplate.getSendEmailId());
//            }
//            SendMessageEntity message = SalarySendBO.buildSendMessageEntity(text, sendUser, receivers, entity, emailInfo);
//            log.info("开始发送============:{}", JsonUtil.toJsonString(message));
//            // 开始发送
//            log.info("发送结果===:{}", JsonUtil.toJsonString(asyncSystemMessageRest.sendMsg(message)));
//        });
//    }

    @Override
    public Map<String, Object> withdraw(SalarySendWithdrawParam param) {
        if (param.getSalarySendId() == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100327, "工资单发放Id必传"));
        }

        Long salarySendId = param.getSalarySendId();
        Collection<Long> ids = param.getIds();

        SalarySendPO salarySend = mapper.getById(salarySendId);
        if (salarySend == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100512, "工资单发放不存在"));
        }
//        // 获取可撤回的工资单
//        List<SalarySendInfoPO> enableWithdrawList = new LambdaQueryChainWrapper<>(salarySendInfoMapper)
//                .eq(SalarySendInfoPO::getDeleteType, 0)
//                .eq(SalarySendInfoPO::getTenantKey, currentTenantKey)
//                .eq(SalarySendInfoPO::getSalarySendId, salarySendId)
//                .eq(SalarySendInfoPO::getSendStatus, SalarySendStatusEnum.ALREADYSEND.getValue())
//                .in(CollectionUtils.isNotEmpty(ids), SalarySendInfoPO::getId, ids)
//                .list();
        // 撤回
//        new LambdaUpdateChainWrapper<>(salarySendInfoMapper)
//            .eq(SalarySendInfoPO::getDeleteType, 0)
//            .eq(SalarySendInfoPO::getSalarySendId, salarySendId)
//            .eq(SalarySendInfoPO::getSendStatus, SalarySendStatusEnum.ALREADYSEND.getValue())
//            .in(CollectionUtils.isNotEmpty(ids), SalarySendInfoPO::getId, ids)
//            .set(SalarySendInfoPO::getSendStatus, SalarySendStatusEnum.WITHDRAW.getValue())
//            .update();
        SalarySendInfoPO po = new SalarySendInfoPO();
        po.setSendStatus(SalarySendStatusEnum.WITHDRAW.getValue());

        List<Integer> statusList = new ArrayList<>();
        statusList.add(SalarySendStatusEnum.ALREADYSEND.getValue());
        salarySendInfoMapper.updateGrantWithdraw(po, salarySendId, statusList, null);

//        List<SalarySendInfoPO> list = new LambdaQueryChainWrapper<>(salarySendInfoMapper)
//            .eq(SalarySendInfoPO::getDeleteType, 0)
//            .eq(SalarySendInfoPO::getTenantKey, currentTenantKey)
//            .eq(SalarySendInfoPO::getSalarySendId, salarySendId).list();

        po = new SalarySendInfoPO();
        po.setDeleteType(0);
        po.setSalarySendId(salarySendId);
        List<SalarySendInfoPO> list = salarySendInfoMapper.listSome(po);

        int sendNum = (int) list.stream().filter(e -> e.getSendStatus().equals(SalarySendStatusEnum.ALREADYSEND.getValue())).count();
        int sendTotal = list.size();

        SalarySendPO salarySendNew = new SalarySendPO();
        try {
            BeanUtils.copyProperties(salarySend, salarySendNew);
        } catch (Exception e) {
            throw new SalaryRunTimeException("数据转换异常, " + e.getMessage());
        }
        salarySendNew.setSendNum(sendNum);
        salarySendNew.setSendTotal(sendTotal);
        mapper.updateById(salarySendNew);

//        List<SalarySobPO> salarySobs = new LambdaQueryChainWrapper<>(salarySobMapper)
//            .eq(SalarySobPO::getTenantKey, TenantContext.getCurrentTenantKey())
//            .eq(SalarySobPO::getDeleteType, 0)
//            .eq(SalarySobPO::getId, salarySend.getSalarySobId())
//            .list();
        // 记录日志
//        SalaryLoggerUtil.recordUpdateSingleLog(salarySendLoggerTemplate,
//            salarySend.getId(),
//            salarySend.getSalaryMonth() + "-" + (CollectionUtils.isNotEmpty(salarySobs) ? salarySobs.get(0).getName() : ""),
//            SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100521, "撤回工资单发放"),
//            SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 100521, "撤回工资单发放"),
//            salarySend,
//            salarySendNew);

//        // 3.异步发送消息：先修改数据再发消息，避免出错后无法撤回
//        taskExecutor.execute(() -> {
//            try {
//                DSTenantKeyThreadVar.tenantKey.set(currentTenantKey);
//
//                String text = "工资单撤回测试消息文案，不好意思，弄错了";
//                String title = SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmployeeId, 94626, "工资单");
//                enableWithdrawList.forEach(e->{
//                    CancleMessageEntity cme = SalarySendBO.buildCancleMessageEntity(e.getEmployeeId(),
//                            e.getMsgId(),
//                            text,
//                            title,
//                            currentEmployeeId,
//                            currentTenantKey);
//                    log.info("撤回结果===:{}", JsonUtil.toJsonString(asyncSystemMessageRest.cancleMsg(cme)));
//                });
//            } finally {
//                DSTenantKeyThreadVar.tenantKey.remove();
//            }
//        });

        Map<String, Object> map = new HashMap<>(2);
        map.put("sendNum", sendNum);
        map.put("sendTotal", sendTotal);
        return map;
    }

    @Override
    public XSSFWorkbook exportInfoList(SalarySendInfoQueryParam queryParam) {
        // 1.工作簿名称
        String sheetName = SalaryI18nUtil.getI18nLabel(100528, "工资单发放信息");
        List<Object> header = new ArrayList<>();
        header.add(SalaryI18nUtil.getI18nLabel(85429, "姓名"));
        header.add(SalaryI18nUtil.getI18nLabel(86184, "个税扣缴义务人"));
        header.add(SalaryI18nUtil.getI18nLabel(86185, "部门"));
        header.add(SalaryI18nUtil.getI18nLabel(86186, "手机号"));
        header.add(SalaryI18nUtil.getI18nLabel(86317, "工号"));
        header.add(SalaryI18nUtil.getI18nLabel( 86317, "发送状态"));

        List<List<Object>> rows = new ArrayList<>();
        // 2.表头
        rows.add(header);

        // 校验
        SalarySendInfoQueryParam.checkParam(queryParam);

        // 获取行数据
        List<SalarySendInfoListDTO> list = salarySendInfoMapper.list(queryParam);
        list.forEach(e -> {
            // 发放状态
            e.setSendStatus(SalarySendStatusEnum.getDefaultLabelByValue(Integer.valueOf(e.getSendStatus())));
        });

        // 3.添加行记录
        // 3.表数据
        for (SalarySendInfoListDTO dto : list) {
            List<Object> row = new ArrayList<>();
            row.add(dto.getUsername());
            row.add(dto.getTaxAgent());
            row.add(dto.getDepartment());
            row.add(dto.getMobile());
            row.add(dto.getJobNum());
            row.add(dto.getSendStatus());
            rows.add(row);
        }
        return ExcelUtil.genWorkbookV2(rows, sheetName);
    }

//    @BatchExportHandler("exportSalarySendInfo")
//    public void salarySendInfoExportHandler() {
//        BatchCallbackMessage message = BatchExportContext.getBatchCallbackMessage();
//        System.out.println("接受到导出的结果" + JSONObject.toJSONString(message));
//    }

    @Override
    public XSSFWorkbook exportDetailList(SalarySendPO salarySend, SalarySendDetailQueryParam queryParam) {

        // 1.根据模板获取薪资项目设置
        List<SalaryTemplatePO> salaryTemplates = getSalaryTemplateService(user).getDefaultTemplates(Collections.singletonList(salarySend.getSalarySobId()));
        List<SalaryTemplateSalaryItemListDTO> salaryItems = getSalaryItemsSetting(CollectionUtils.isNotEmpty(salaryTemplates) ? salaryTemplates.get(0) : null);

        // 2.获取基本数据
        List<SalarySendDetailListDTO> list = salarySendInfoMapper.detailList(queryParam);

        // 3.组装详情数据
        List<Map<String, Object>> listMaps = buildDetailList(salaryItems, list, salarySend.getSalaryAccountingId());

        // 1.工作簿名称
        String sheetName = SalaryI18nUtil.getI18nLabel(97036, "工资单发放详情");
        List<Object> header = new ArrayList<>();
        header.add(SalaryI18nUtil.getI18nLabel(85429, "姓名"));
        header.add(SalaryI18nUtil.getI18nLabel(86185, "部门"));
        header.add(SalaryI18nUtil.getI18nLabel(86186, "手机号"));
        header.add(SalaryI18nUtil.getI18nLabel(86317, "工号"));
        // 动态列
        if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(salaryItems)) {
            for (SalaryTemplateSalaryItemListDTO salaryItem : salaryItems) {
                header.add(salaryItem.getName());
            }
        }
        List<List<Object>> rows = new ArrayList<>();

        // 2.表头
        rows.add(header);

        // 3.表数据
        for (Map<String, Object> dto : listMaps) {
            List<Object> row = new ArrayList<>();
            row.add(dto.get("username"));
            row.add(dto.get("departmentName"));
            row.add(dto.get("mobile"));
            row.add(dto.get("jobNum"));

            // 动态列
            Map<String, Object> mapColumn = listMaps.get(0);
            for (SalaryTemplateSalaryItemListDTO salaryItem : salaryItems) {
                if (mapColumn.containsKey(salaryItem.getId() + SalaryItemConstant.DYNAMIC_SUFFIX)) {
                    row.add(dto.get(salaryItem.getId() + SalaryItemConstant.DYNAMIC_SUFFIX));
                }
            }

            rows.add(row);
        }
        return ExcelUtil.genWorkbookV2(rows, sheetName);
    }
//
//    @BatchExportHandler("exportSalarySendDetail")
//    public void salarySendDetailExportHandler() {
//        BatchCallbackMessage message = BatchExportContext.getBatchCallbackMessage();
//        System.out.println("接受到导出的结果" + JSONObject.toJSONString(message));
//    }
}