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

package com.engine.salary.service.impl;

import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSONArray;
import com.api.formmode.mybatis.util.SqlProxyHandle;
import com.cloudstore.dev.api.bean.MessageBean;
import com.cloudstore.dev.api.bean.MessageType;
import com.cloudstore.dev.api.util.Util_Message;
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.constant.SalaryItemConstant;
import com.engine.salary.constant.SalaryTemplateSalaryItemSetGroupConstant;
import com.engine.salary.encrypt.salaryacct.SalaryAcctResultPOEncrypt;
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.salaryformula.dto.SalaryFormulaEmployeeDTO;
import com.engine.salary.entity.salaryitem.po.SalaryItemPO;
import com.engine.salary.entity.salarysob.dto.SalarySobCycleDTO;
import com.engine.salary.entity.salarysob.po.SalarySobPO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.salaryaccounting.SalaryAcctRecordStatusEnum;
import com.engine.salary.enums.salaryarchive.SalaryArchiveFieldTypeEnum;
import com.engine.salary.enums.salarybill.SalarySendStatusEnum;
import com.engine.salary.enums.salarybill.SalaryTemplateReplenishRuleEnum;
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.SalarySendInfoMapper;
import com.engine.salary.mapper.salarybill.SalarySendMapper;
import com.engine.salary.service.*;
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.JsonUtil;
import com.engine.salary.util.SalaryDateUtil;
import com.engine.salary.util.SalaryEntityUtil;
import com.engine.salary.util.SalaryI18nUtil;
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 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.commons.lang3.math.NumberUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import weaver.hrm.User;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
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 SalarySendMapper getSalarySendMapper() {
        return SqlProxyHandle.getProxy(SalarySendMapper.class);
    }


    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);
    }

    //
    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);
    }

    private SalarySendInfoMapper getSalarySendInfoMapper() {
        return SqlProxyHandle.getProxy(SalarySendInfoMapper.class);
    }

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

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

    private SalaryItemService getSalaryItemService(User user) {
        return ServiceUtil.getService(SalaryItemServiceImpl.class, user);
    }

    private SalaryAcctEmployeeService getSalaryAcctEmployeeService(User user) {
        return ServiceUtil.getService(SalaryAcctEmployeeServiceImpl.class, user);
    }

    private SalaryAcctResultService getSalaryAcctResultService(User user) {
        return ServiceUtil.getService(SalaryAcctResultServiceImpl.class, user);
    }


//    @RpcReference
//    private FileDownloadClient fileDownloadClient;
//    /**
//     * 同步用RpcReference
//     */
//    @RpcReference
//    private SystemMessageRest systemMessageRest;
//    /**
//     * 异步用Autowired
//     */
//    @Autowired
//    private AsyncSystemMessageRest asyncSystemMessageRest;
//    @RpcReference
//    private MailBaseService mailBaseService;
//    
//    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
    public String generateSalaryBill(Long salaryAccountingId) {
        // 校验salaryAccountingId
        if (salaryAccountingId == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100497, "核算id必传"));
        }

        SalaryAcctRecordPO recordPo = new SalaryAcctRecordPO();
        recordPo.setDeleteType(0);
        recordPo.setId(salaryAccountingId);
        recordPo.setStatus(SalaryAcctRecordStatusEnum.ARCHIVED.getValue());
        List<SalaryAcctRecordPO> acctRecords = getSalaryAcctRecordMapper().listSome(recordPo);
        // 检查核算的归档记录
        if (CollectionUtils.isEmpty(acctRecords)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100498, "核算记录不存在"));
        }


        List<SalaryAcctEmployeePO> salaryAcctEmployees = getSalaryAcctEmployeeService(user).listBySalaryAcctRecordIds(Collections.singletonList(salaryAccountingId));
        // 根据人员id去重
        salaryAcctEmployees = salaryAcctEmployees.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(SalaryAcctEmployeePO::getEmployeeId))), ArrayList::new));

        // 1.回算：如果是回算，todo 要等原始核算发完或者上一个回算记录发完才行，目前最多只有一个回算记录
        if (acctRecords.get(0).getBackCalcStatus().equals(NumberUtils.INTEGER_ONE)) {
            SalarySendPO sendPO = new SalarySendPO();
            sendPO.setDeleteType(0);
            sendPO.setSalaryAccountingId(salaryAccountingId);
            List<SalarySendPO> salarySends = mapper.listSome(sendPO);
            if (CollectionUtils.isEmpty(salarySends)) {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel( 139700, "还没有正常核算，不能进行回算"));
            }
            // todo 一般只有一个未冻结,同一个原始核算id，后面如果有多级回算，就会换成不同核算id
            SalarySendPO salarySend = salarySends.stream().filter(s -> s.getSendStatus().equals(NumberUtils.INTEGER_ZERO)).findFirst().orElse(null);

            // 根据工资单补发模板规则过滤人员,已发补发的合计项目不等于0的进行过滤
            SalarySobPO salarySob = getSalarySobService(user).getById(acctRecords.get(0).getSalarySobId());
            List<SalaryTemplatePO> salaryTemplates = getSalaryTemplateService(user)
                    .getDefaultTemplates(Arrays.asList(acctRecords.get(0).getSalarySobId(), salarySob == null ? 0L : salarySob.getId()));
            // 如果有默认模板，且规则不是全部
            if (CollectionUtils.isNotEmpty(salaryTemplates) && StringUtils.isEmpty(salaryTemplates.get(0).getReplenishRule())) {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel( 140649, "请维护补发工资单模板信息"));
            }
            Long backCalcItemId =
                    CollectionUtils.isNotEmpty(salaryTemplates) && !SalaryTemplateReplenishRuleEnum.ALL.getValue().equals(salaryTemplates.get(0).getReplenishRule()) ? Long
                            .parseLong(salaryTemplates.get(0).getReplenishRule()) : 0L;
            SalaryItemPO salaryItem = getSalaryItemService(user).getById(backCalcItemId);
            if (salaryItem != null && salaryItem.getDataType().equals(SalaryArchiveFieldTypeEnum.NUMBER.getValue())) {
                // 目前是单个薪资项目
                List<SalaryAcctResultPO> salaryAcctResultValues = getSalaryAcctResultService(user).listBySalaryAcctRecordIdsAndSalaryItemIds(Collections.singleton(salaryAccountingId), Collections.singleton(backCalcItemId));
                Set<Long> salaryAcctEmployeeIds = salaryAcctResultValues.stream()
                        .filter(salaryAcctResultPO -> SalaryEntityUtil.empty2Zero(salaryAcctResultPO.getResultValue()).compareTo(BigDecimal.ZERO)
                                != 0)
                        .map(SalaryAcctResultPO::getSalaryAcctEmpId)
                        .collect(Collectors.toSet());
                salaryAcctEmployees = salaryAcctEmployees.stream().filter(se -> salaryAcctEmployeeIds.contains(se.getId())).collect(Collectors.toList());
            }

            // 将未冻结的给冻结掉
            if (salarySend != null) {
                salarySend.setSendStatus(NumberUtils.INTEGER_ONE);
                this.mapper.updateById(salarySend);
            }
            // 2.正常核算
        } else {
            SalarySendPO sendPO = new SalarySendPO();
            sendPO.setDeleteType(0);
            sendPO.setSalaryAccountingId(salaryAccountingId);
            List<SalarySendPO> salarySends = mapper.listSome(sendPO);
            if (CollectionUtils.isNotEmpty(salarySends)) {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100499, "工资单已生成过，不可再重复生成"));
            }
        }


        Long salarySendId = IdGenerator.generate();
        SalaryAcctRecordPO salaryAcctRecord = acctRecords.get(0);
        // 工资单模板类型：0，正常核算，1是回算，todo 后续可能还有别的算，需要改这里
        Integer templateType = salaryAcctRecord.getBackCalcStatus();

        // 构建工资单发放数据
        List<SalarySendInfoPO> salarySendInfos = 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("")
                        .salaryAcctType(templateType)
                        .creator((long) user.getUID())
                        .createTime(new Date())
                        .updateTime(new Date())
                        .build()
        ).collect(Collectors.toList());

        SalarySendPO salarySend = SalarySendPO.builder()
                .id(salarySendId)
                .salaryMonth(salaryAcctRecord.getSalaryMonth())
                .salaryAccountingId(salaryAccountingId)
                .salarySobId(salaryAcctRecord.getSalarySobId())
                .sendNum(0)
                .sendTotal(salarySendInfos.size())
                .sendStatus(NumberUtils.INTEGER_ZERO) // 未冻结
                .salaryAcctType(templateType)
                .lastSendTime(new Date())
                .creator((long) user.getUID())
                .createTime(new Date())
                .updateTime(new Date())
                .build();
        // 插入工资单发放记录
        mapper.insert(salarySend);
        // 插入工资单人员记录
        salarySendInfoMapper.batchInsert(salarySendInfos);

        return "";
    }

    @Override
    public void revokeSalaryBill(SalaryAcctRecordPO salaryAcctRecord) {
        // 校验salaryAccountingId
//        if (salaryAcctRecord == null) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100497, "核算id必传"));
//        }
//
//        SalaryAcctRecordPO po = SalaryAcctRecordPO.builder().id(salaryAccountingId).build();
//        List<SalaryAcctRecordPO> acctRecords = getSalaryAcctRecordMapper().listSome(po);
        // 检查核算的归档记录
        if (salaryAcctRecord == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100498, "核算记录不存在"));
        }

        SalarySendPO build = SalarySendPO.builder().salaryAccountingId(salaryAcctRecord.getId()).deleteType(0).build();
        List<SalarySendPO> salarySends = getSalarySendMapper().listSome(build);
        if (CollectionUtils.isEmpty(salarySends)) {
            return;
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100505, "工资单不存在"));
        }

        SalarySendPO salarySend;
        if (salaryAcctRecord.getBackCalcStatus() != null &&  salaryAcctRecord.getBackCalcStatus().equals(NumberUtils.INTEGER_ONE)) {
            // todo 一般只有一个未冻结,同一个原始核算id，后面如果有多级回算，就会换成不同核算id
            salarySend = salarySends.stream().filter(s -> s.getSendStatus().equals(NumberUtils.INTEGER_ZERO)).findFirst().orElse(null);
            if (salarySend != null && salarySend.getSendNum() < salarySend.getSendTotal()) {
                throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(139702, "正常原始核算或上一个回算尚未全部发送完成，不能进行撤回"));
            }
            if (salarySend != null) {
                // 将上一版本未冻结的给冻结掉
                salarySend.setSendStatus(NumberUtils.INTEGER_ONE);
                getSalarySendMapper().updateIgnoreNull(salarySend);
            }
            // 已经回算的删除 todo 以后多级回算注意要修改
            salarySend = salarySends.stream().filter(s -> s.getSalaryAcctType() != null && s.getSalaryAcctType().equals(NumberUtils.INTEGER_ONE)).findFirst().orElse(null);
            handleDelSalaryBill(salarySend);
            // 2.正常核算处理
        } else {
            salarySend = salarySends.stream().filter(s -> s.getSendStatus().equals(NumberUtils.INTEGER_ZERO)).findFirst().orElse(null);
            handleDelSalaryBill(salarySend);
        }
    }


    private void handleDelSalaryBill(SalarySendPO salarySend) {
        if (salarySend == null) {
            return;
        }
        // 已发送工资单
        SalarySendInfoPO sendInfo = SalarySendInfoPO.builder()
                .deleteType(0)
                .salarySendId(salarySend.getId())
                .sendStatus(SalarySendStatusEnum.ALREADYSEND.getValue())
                .salaryAcctType(NumberUtils.INTEGER_ZERO).build();
        List<SalarySendInfoPO> salarySendInfos = getSalarySendInfoMapper().listSome(sendInfo);
        if (salarySend.getSendNum() > 0 || CollectionUtils.isNotEmpty(salarySendInfos)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100507, "工资单已经发放，不可撤销,可以进行回算"));
        }
        // 删除工资单
        SalarySendPO salarySendPO = SalarySendPO.builder()
                .id(salarySend.getId())
                .sendNum(0)
                .deleteType(1)
                .build();
        getSalarySendMapper().updateIgnoreNull(salarySendPO);
        // 删除工资单发放
        SalarySendInfoPO infoPO = SalarySendInfoPO.builder()
                .salarySendId(salarySend.getId())
                .deleteType(1)
                .build();
        getSalarySendInfoMapper().updateGrantWithdraw(infoPO, salarySend.getId(), null, null);

    }

    @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)) {
            // 是否是回算
            SalaryAcctRecordPO salaryAcctRecord = getSalaryAcctRecordService(user).getById(salarySend.getSalaryAccountingId());
            boolean isReplenish = salaryAcctRecord != null && Objects.equals(salaryAcctRecord.getBackCalcStatus(), (NumberUtils.INTEGER_ONE));
            if(isReplenish){
                template = salaryTemplates.get(0).getReplenishName();
            }else{
                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<SalaryAcctResultPO> salaryAcctResultPOS = getSalaryAcctResultMapper().listSome(acctPo);
        SalaryAcctResultPOEncrypt.decryptList(salaryAcctResultPOS);
        List<Map<String, Object>> salaryAcctResultS = salaryAcctResultPOS.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()
                    .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);
                        }
                    });
        });


        /**
         * 过滤空
         */
        if (Objects.equals(1, salaryTemplate.getSalaryItemNullStatus())) {
            for (SalaryTemplateSalaryItemSetListDTO itemSetListDTO : itemSetListDTOS) {
                List<SalaryTemplateSalaryItemListDTO> items = itemSetListDTO.getItems();
                List<SalaryTemplateSalaryItemListDTO> collect = items.stream().filter(item -> StringUtils.isNotBlank(item.getSalaryItemValue())).collect(Collectors.toList());
                itemSetListDTO.setItems(collect);
            }
        }

        /**
         * 过滤0
         */
        if (Objects.equals(1, salaryTemplate.getSalaryItemZeroStatus())) {
            for (SalaryTemplateSalaryItemSetListDTO itemSetListDTO : itemSetListDTOS) {
                List<SalaryTemplateSalaryItemListDTO> items = itemSetListDTO.getItems();
                List<SalaryTemplateSalaryItemListDTO> collect = items.stream()
                        .filter(item -> SalaryEntityUtil.string2BigDecimal(item.getSalaryItemValue()) == null
                                || BigDecimal.ZERO.compareTo(SalaryEntityUtil.string2BigDecimal(item.getSalaryItemValue())) != 0)
                        .collect(Collectors.toList());
                itemSetListDTO.setItems(collect);
            }
        }

        TaxAgentPO taxAgentPO = getTaxAgentService(user).getById(salarySendInfo.getTaxAgentId());
        DataCollectionEmployee simpleEmployee = getSalaryEmployeeService(user).getEmployeeById(salarySendInfo.getEmployeeId());
        buildEmployeeInfo(employeeInformation, simpleEmployee, taxAgentPO.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) {

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

        SalaryPageUtil.start(queryParam.getCurrent(), queryParam.getPageSize());
        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) {
        //排序配置
        OrderRuleVO orderRule = getSalarySysConfService(user).orderRule();
        queryParam.setOrderRule(orderRule);
        Set<Long> otherSalaryAcctRecordIds = null;
        if (queryParam.getMergeCountTax() != null && queryParam.getMergeCountTax()) {
            //查询关联的核酸id，这里认为一次发放只对应一条核算记录
            Long salaryAccRecordId =
                    salarySendInfoMapper.listSalaryAccRecordIds(queryParam).stream().findFirst().orElse(null);
            // 查询合并计税的其他薪资核算记录
            List<SalaryAcctRecordPO> otherSalaryAcctRecordPOS =
                    getSalaryAcctRecordService(user).listById4OtherConsolidatedTax(salaryAccRecordId);
            if (CollectionUtils.isEmpty(otherSalaryAcctRecordPOS)) {
                return new PageInfo<>();
            }
            // 查询合并计税的薪资核算人员
            otherSalaryAcctRecordIds = SalaryEntityUtil.properties(otherSalaryAcctRecordPOS, SalaryAcctRecordPO::getId);
            if (otherSalaryAcctRecordIds.isEmpty()) {
                return new PageInfo<>();
            }
        }
        SalaryPageUtil.start(queryParam.getCurrent(), queryParam.getPageSize());
        List<SalarySendDetailListDTO> list = salarySendInfoMapper.detailList(queryParam, otherSalaryAcctRecordIds);
        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())
                    .jobcall(simpleEmployee.getJobcall())
                    .companystartdate(simpleEmployee.getCompanystartdate())
                    .sex("0".equals(simpleEmployee.getSex()) ? "男" : "女")
                    .mobile(StringUtils.isEmpty(simpleEmployee.getMobile()) ? "" : simpleEmployee.getMobile())
                    .jobtitleName(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);
        SalaryAcctResultPOEncrypt.decryptList(salaryAccountingResults);
        // 动态列
        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,  boolean isReplenish) {
        List<SalaryTemplateSalaryItemListDTO> salaryItems = new ArrayList<>();

        if (salaryTemplate == null) {
            return salaryItems;
        }
        // 正常模板
        if (!isReplenish && 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());
            });
        }
        // 补发模板
        if (isReplenish && StringUtils.isNotEmpty(salaryTemplate.getReplenishSalaryItemSetting())) {
            List<SalaryTemplateSalaryItemSetListDTO> salaryTemplateShowSetData = JsonUtil.parseList(salaryTemplate.getReplenishSalaryItemSetting(),
                    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 (Objects.equals(salarySend.getSendStatus() , NumberUtils.INTEGER_ONE)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "工资单已冻结"));
        }
        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);
        //需要发送工资的人

        List<SalarySendInfoPO> sendList = list.stream().filter(e -> e.getSendStatus().equals(SalarySendStatusEnum.ALREADYSEND.getValue())).collect(Collectors.toList());
        int sendNum = sendList.size();
        int sendTotal = list.size();
        SalarySendPO salarySendNew = new SalarySendPO();
        try {
            BeanUtils.copyProperties(salarySendNew, salarySend);
        } 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();
//            }
//        });
        List<SalarySendInfoPO> needSendList = Lists.newArrayList();
        enableSendList.forEach(map -> {
            sendList.forEach(item -> {
                if (item.getId() == Long.valueOf(map.get("id").toString()).longValue()) {
                    needSendList.add(item);
                }
            });
        });

        // 发送消息
        sendMessage(true, needSendList, param, salarySend);

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

        return map;
    }

    /**
     * 发送消息
     *
     * @param sendFlag   true 发送 false 撤回
     * @param list
     * @param param
     * @param salarySend
     */
    private void sendMessage(boolean sendFlag, List<SalarySendInfoPO> list, SalarySendGrantParam param, SalarySendPO salarySend) {
        Date salaryMonth = salarySend.getSalaryMonth();
        String month = DateUtil.format(salaryMonth, "yyyy-MM");
        new Thread() {
            public void run() {
                List<Long> collect = new ArrayList<>();
                if (CollectionUtils.isNotEmpty(param.getIds())) {
                    collect = new ArrayList<>(param.getIds());
                } else {
                    collect = list.stream().map(item -> item.getId()).collect(Collectors.toList());
                }

                collect.forEach(item -> {
                    SalarySendInfoPO po = SalarySendInfoPO.builder().id(item).build();
                    List<SalarySendInfoPO> salarySendInfoPOS = salarySendInfoMapper.listSome(po);
                    if (CollectionUtils.isNotEmpty(salarySendInfoPOS)) {
                        Long employeeId = salarySendInfoPOS.get(0).getEmployeeId();
                        if (sendFlag) {
                            sendPayRollEMMessage(item, employeeId, month);
                        } else {
                            withdrawPayrollEMMessage(item, employeeId);
                        }
                    }
                });
            }
        }.start();
    }

    /**
     * 发送Em消息
     */
    private void sendPayRollEMMessage(Long id, Long employeeId, String month) {
        MessageType messageType = MessageType.newInstance(499); // 消息来源（见文档第四点补充 必填）
        Set<String> userIdList = new HashSet<>(); // 接收人id 必填
        userIdList.add(employeeId.toString());
        String title = month + " 工资单"; // 标题
        String context = "点击查看详情"; // 内容
        String linkUrl = weaver.general.GCONST.getContextPath() + "/spa/hrmSalary/static/index.html#/main/hrmSalary/mobilepayroll?id=" + id; // PC端链接
        String linkMobileUrl = weaver.general.GCONST.getContextPath() + "/spa/hrmSalary/static/index.html#/main/hrmSalary/mobilepayroll?type=phone&id=" + id; // 移动端链接
        try {
            MessageBean messageBean = Util_Message.createMessage(messageType, userIdList, title, context, linkUrl, linkMobileUrl);
            messageBean.setCreater(user.getUID());// 创建人id
            messageBean.setBizState("0");// 需要修改消息为已处理等状态时传入,表示消息最初状态为待处理
            messageBean.setTargetId("499|" + id); //消息来源code +“|”+业务id需要修改消息为已处理等状态时传入
            Util_Message.store(messageBean);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 撤回EM消息
     *
     * @param id
     */
    private void withdrawPayrollEMMessage(Long id, Long employeeId) {
        try {
            MessageBean messageBean = Util_Message.createMessage();
            messageBean.setUserList(new HashSet<>());//接收人id
            messageBean.setUserId(employeeId.intValue());
            messageBean.setTargetId("499|" + id); //code + “|” + 业务id
            //messageBean.setMessageType(MessageType.newInstance(121));//消息来源code(传了代表code也做为删除时的条件，默认不传）
            Util_Message.delMessageTargetid(messageBean);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private List<Map<String, Object>> getEnableSendList(SalarySendPO salarySend, Collection<Long> ids, SalaryTemplatePO salaryTemplate) {
        // 1.根据模板获取薪资项目设置
        SalaryAcctRecordPO salaryAcctRecord = getSalaryAcctRecordService(user).getById(salarySend.getSalaryAccountingId());
        boolean isReplenish = salaryAcctRecord != null && Objects.equals(salaryAcctRecord.getBackCalcStatus(), (NumberUtils.INTEGER_ONE));
        List<SalaryTemplateSalaryItemListDTO> salaryItems = getSalaryItemsSetting(salaryTemplate,isReplenish);
        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, null);
        // 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, ids);

//        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(salarySendNew, salarySend);
        } 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);


        SalarySendGrantParam grantParam = SalarySendGrantParam.builder().ids(param.getIds()).salarySendId(param.getSalarySendId()).build();
        // 撤回消息
        sendMessage(false, list, grantParam, salarySend);
//        // 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);

        // 获取行数据
        //排序配置
        OrderRuleVO orderRule = getSalarySysConfService(user).orderRule();
        queryParam.setOrderRule(orderRule);
        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.根据模板获取薪资项目设置
        SalaryAcctRecordPO salaryAcctRecord = getSalaryAcctRecordService(user).getById(salarySend.getSalaryAccountingId());
        boolean isReplenish = salaryAcctRecord != null && Objects.equals(salaryAcctRecord.getBackCalcStatus(), (NumberUtils.INTEGER_ONE));
        List<SalaryTemplatePO> salaryTemplates = getSalaryTemplateService(user).getDefaultTemplates(Collections.singletonList(salarySend.getSalarySobId()));
        List<SalaryTemplateSalaryItemListDTO> salaryItems = getSalaryItemsSetting(CollectionUtils.isNotEmpty(salaryTemplates) ? salaryTemplates.get(0) : null , isReplenish);

        // 2.获取基本数据
        //排序配置
        OrderRuleVO orderRule = getSalarySysConfService(user).orderRule();
        queryParam.setOrderRule(orderRule);

        List<SalarySendDetailListDTO> list = salarySendInfoMapper.detailList(queryParam, null);

        // 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);
    }

    @Override
    public List<SalarySendCheckDTO> getSalarySendCheckResult(Set<Long> salaryAcctRecordIds) {
        if (CollectionUtils.isEmpty(salaryAcctRecordIds)) {
            return Collections.emptyList();
        }
        Map<String, Object> condition = new HashMap<>();
        condition.put("salaryAccountingIds",salaryAcctRecordIds);
        List<SalarySendPO> salarySendPOS = getSalarySendMapper().listSomeWithCondition(condition);
        Map<Long, SalarySendPO> map = SalaryEntityUtil.convert2Map(salarySendPOS, SalarySendPO::getSalaryAccountingId);

        return salaryAcctRecordIds.stream().map(m -> {
            SalarySendPO salarySend = map.get(m);
            SalarySendCheckDTO salarySendCheck = new SalarySendCheckDTO();
            salarySendCheck.setSalaryAcctId(m);
            // 是否存在已经发送
            salarySendCheck.setAlreadySend(salarySend != null && salarySend.getSendNum() > 0);
            // 是否已经发送完成
            salarySendCheck.setSendFinished(salarySend != null && salarySend.getSendNum() == salarySend.getSendTotal());
            return salarySendCheck;
        }).collect(Collectors.toList());
    }

    @Override
    public void handleHistory() {
        mapper.batchHandleSendStatusHistory();
        mapper.batchHandleSalaryAcctTypeHistory();
    }

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