package com.engine.salary.service.impl;
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.cache.SalaryCacheKey;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.progress.ProgressDTO;
import com.engine.salary.entity.salaryBill.bo.SalaryBillBO;
import com.engine.salary.entity.salaryBill.bo.SalaryTemplateBO;
import com.engine.salary.entity.salaryBill.dto.SalaryBillSendDTO;
import com.engine.salary.entity.salaryBill.dto.SalarySendInfoListDTO;
import com.engine.salary.entity.salaryBill.dto.SalaryTemplateSalaryItemSetListDTO;
import com.engine.salary.entity.salaryBill.param.SalarySendGrantParam;
import com.engine.salary.entity.salaryBill.param.SalarySendInfoQueryParam;
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.po.SalaryAcctEmployeePO;
import com.engine.salary.entity.salaryacct.po.SalaryAcctResultPO;
import com.engine.salary.entity.salarysob.po.SalarySobPO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.salarybill.MessageChannelEnum;
import com.engine.salary.enums.salarybill.SalarySendStatusEnum;
import com.engine.salary.enums.salarysend.SalarySendGrantTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.salarybill.SalarySendInfoMapper;
import com.engine.salary.mapper.salarybill.SalarySendMapper;
import com.engine.salary.service.*;
import com.engine.salary.util.JsonUtil;
import com.engine.salary.util.SalaryEntityUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.google.common.collect.Lists;
import com.weaver.util.threadPool.ThreadPoolUtil;
import com.weaver.util.threadPool.constant.ModulePoolEnum;
import com.weaver.util.threadPool.entity.LocalRunnable;
import lombok.extern.slf4j.Slf4j;
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 weaver.hrm.User;
import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
/**
* 工资单发放
* Copyright: Copyright (c) 2022
* Company: 泛微软件
*
* @author qiantao
* @version 1.0
**/
@Slf4j
public class SalaryBillServiceImpl extends Service implements SalaryBillService {
private SalarySendMapper getSalarySendMapper() {
return SqlProxyHandle.getProxy(SalarySendMapper.class);
}
private SalarySendInfoMapper getSalarySendInfoMapper() {
return SqlProxyHandle.getProxy(SalarySendInfoMapper.class);
}
private SalaryTemplateService getSalaryTemplateService(User user) {
return ServiceUtil.getService(SalaryTemplateServiceImpl.class, user);
}
private SalarySendService getSalarySendService(User user) {
return ServiceUtil.getService(SalarySendServiceImpl.class, user);
}
private SalarySobService getSalarySobService(User user) {
return ServiceUtil.getService(SalarySobServiceImpl.class, user);
}
private SalaryAcctResultService getSalaryAcctResultService(User user) {
return ServiceUtil.getService(SalaryAcctResultServiceImpl.class, user);
}
private SalaryAcctEmployeeService getSalaryAcctEmployeeService(User user) {
return ServiceUtil.getService(SalaryAcctEmployeeServiceImpl.class, user);
}
private TaxAgentService getTaxAgentService(User user) {
return ServiceUtil.getService(TaxAgentServiceImpl.class, user);
}
private SalarySendRangeService getSalarySendRangeService(User user) {
return ServiceUtil.getService(SalarySendRangeServiceImpl.class, user);
}
private SalaryAcctRecordService getSalaryAcctRecordService(User user) {
return ServiceUtil.getService(SalaryAcctRecordServiceImpl.class, user);
}
private SalaryEmployeeService getSalaryEmployeeService(User user) {
return ServiceUtil.getService(SalaryEmployeeServiceImpl.class, user);
}
private SalarySendInfoBiz salarySendInfoMapper = new SalarySendInfoBiz();
private SalarySendBiz mapper = new SalarySendBiz();
private SalaryEmployeeService salaryEmployeeService;
private SalarySobItemService salarySobItemService;
private ProgressService getProgressService(User user) {
return ServiceUtil.getService(ProgressServiceImpl.class, user);
}
/**
* 工资单发放 start
**********************************************************************/
@Override
public void grant(SalarySendGrantParam param) {
// 1.检查和获取工资单发放
SalarySendPO salarySend = checkAndGetSalarySend(param.getSalarySendId());
// // 已经冻结不能操作
// if (salarySend.getSendStatus().equals(NumberUtils.INTEGER_ONE)) {
// return;
// }
// 获取默认模板
SalarySobPO salarySob = getSalarySobService(user).getById(salarySend.getSalarySobId());
List salaryTemplates = salarySob == null ? Lists.newArrayList() : getSalaryTemplateService(user).getDefaultTemplates(Arrays.asList(salarySend.getSalarySobId(), salarySob.getId()));
if (CollectionUtils.isEmpty(salaryTemplates)) {
throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100518, "没有默认模板，无法发送"));
}
SalaryTemplatePO salaryTemplate = salaryTemplates.get(0);
// 发送通道
Set sendChannels = SalaryBillBO.buildSendChannels(salaryTemplate);
if (CollectionUtils.isEmpty(sendChannels)) {
throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(149767, "工资单模板至少开启一个发送通道"));
}
boolean isReplenish = NumberUtils.INTEGER_ONE.equals(salarySend.getSalaryAcctType());
if (isReplenish && StringUtils.isEmpty(salaryTemplate.getReplenishName())) {
throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(204428, "请完善补发工资单模板设置"));
}
// 2.检查是否正在发送中
ProgressDTO salaryBillProgress = getProgressService(user).getProgress(SalaryCacheKey.SALARY_GRANT_PROGRESS + "_" + param.getSalarySendId());
if (Objects.nonNull(salaryBillProgress) && salaryBillProgress.isStatus()
&& Optional.ofNullable(salaryBillProgress.getProgress()).orElse(BigDecimal.ZERO).compareTo(BigDecimal.ONE) < 0) {
throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(136104, "有其他人员正在发送中，请等待其他人员发送结束后再操作"));
}
// 初始化进度
ProgressDTO initProgress = ProgressDTO.builder()
.title(SalaryI18nUtil.getI18nLabel(136097, "发送中"))
.totalQuantity(NumberUtils.INTEGER_ZERO)
.calculatedQuantity(NumberUtils.INTEGER_ZERO)
.progress(BigDecimal.ZERO)
.status(true)
.message("")
.build();
getProgressService(user).initProgress(SalaryCacheKey.SALARY_GRANT_PROGRESS + "_" + salarySend.getId(), initProgress);
List ids = param.getIds();
if (param.getSalarySendRangeIds() != null) {
//如果传了范围id，则使用范围id发放
ids = getSalarySendRangeService(user)
.getSendInfoIdsBySendId(salarySend.getId(), param.getSalarySendRangeIds(), SalarySendGrantTypeEnum.GRANT);
if (ids.isEmpty()) {// 由于查出来是空的，会导致全部发放，在此进行拦截
throw new SalaryRunTimeException("工资发放范围内没有匹配员工");
}
}
// 异步执行
List finalIds = ids;
LocalRunnable localRunnable = new LocalRunnable() {
@Override
public void execute() {
handleGrant(salarySend, finalIds, salarySob, salaryTemplate);
}
};
ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "salaryBillGrant", localRunnable);
}
/**
* 处理发送
* 注意：
* 1.IM和云桥通道是发送完成后，只需要在预览时获取核算数据，所以发送时可以忽略获取核算数据；
* 2.邮件通道需要在发送时获取，拼凑成html代码，有图片会转化为base64编码变慢，且图片越大越慢
*
* @param salarySend
* @param ids
* @param salarySob
* @param salaryTemplate
*/
private void handleGrant(SalarySendPO salarySend, List ids, SalarySobPO salarySob, SalaryTemplatePO salaryTemplate) {
try {
TaxAgentPO taxAgentPO = getTaxAgentService(user).getById(salarySob.getTaxAgentId());
// 1.构建发送参数
SalaryBillSendDTO salaryBillSendParam = buildSendParams(salarySend, taxAgentPO.getName(), salaryTemplate);
// 2.获取可发送的列表，此步最耗时，需要解密核算数据
List> enableSendList = getEnableSendList(salarySend, ids, salaryBillSendParam);
// 3.发送消息：先修改数据再发消息，避免出错后无法撤回
List successIds = sendMessage(enableSendList, salaryBillSendParam);
// 4.发放
grantSendInfo(successIds, salarySend, salaryTemplate);
// 5.更新数量
updateSendNum(salarySend, salarySob);
int total = enableSendList.size();
int successCount = successIds.size();
String messsage = SalaryI18nUtil.getI18nLabel(139208, "发送完成") + ": "
+ SalaryI18nUtil.getI18nLabel(134807, "成功条数") + "[" + (successCount) + "], "
+ SalaryI18nUtil.getI18nLabel(134808, "失败条数") + "[" + (total - successCount) + "]";
// 发送进度完成
getProgressService(user).finish(SalaryCacheKey.SALARY_GRANT_PROGRESS + "_" + salarySend.getId(), true, messsage);
// log.info("工资单发送组装耗时：{}毫秒；工资单发送消息中心耗时：{}毫秒；工资单数据更改总耗时：{}毫秒；工资单发送总耗时：{}毫秒；工资单云桥图片地址：{}", l3 - l2, l4 - l3, l5 - l4, System.currentTimeMillis() - l,
// salaryBillSendParam == null ? "" : salaryBillSendParam.getPicUrl());
} catch (Exception e) {
log.info("发送出错：{}", e.getMessage(), e);
// 发送进度失败
getProgressService(user).fail(SalaryCacheKey.SALARY_GRANT_PROGRESS + "_" + salarySend.getId(), SalaryI18nUtil.getI18nLabel(136118, "工资单发送出错") + ": " + e.getMessage());
} finally {
}
}
/**
* 构建发送参数
*
* @param salarySend
* @param taxAgentName
* @param salaryTemplate
* @return
*/
private SalaryBillSendDTO buildSendParams(SalarySendPO salarySend, String taxAgentName, SalaryTemplatePO salaryTemplate) {
// 发送通道
Set sendChannels = SalaryBillBO.buildSendChannels(salaryTemplate);
if (CollectionUtils.isEmpty(sendChannels)) {
return null;
}
Date salaryMonth = salarySend.getSalaryMonth();
boolean isReplenish = NumberUtils.INTEGER_ONE.equals(salarySend.getSalaryAcctType());
// SalaryTemplateBO.copyShowSet(isReplenish, salaryTemplate);
// 消息标题
// String title = SalaryBillBO.getBillTitle(salaryTemplate.getTheme(), salaryMonth, 0L);
// 云桥企业微信消息图
String domain = "";
// todo 访问本项目中的图片需要登陆才能访问，且变成空白，所以还是得改成公网，或者后续鉴权忽略
// StringUtils.isEmpty(server) || StringUtils.isEmpty(staticPathPattern) ? "https://wx.weaver.com.cn/main/salary/cover.png" : (server+staticPathPattern).replace("**", "salary_bill.png");
String picUrl = domain + String.format("/papi/file/preview?type=imgs&fileId=%s&random=123456", salaryTemplate.getBackground()); // "https://wx.weaver.com.cn/main/salary/cover.png";
String backgroundBase64 = "";
// if (StringUtils.isNotBlank(salaryTemplate.getBackground()) && isEnableEmail) {
// 2.base64码的方式，这种方式可以不管图片地址是否是内外网，缺点是内容太长
// FileData fileByte = fileDownloadClient.getFileByte(Long.valueOf(salaryTemplate.getBackground()));
// backgroundBase64 = Base64Encoder.encode(fileByte.getData());
// 千万不要这样做，否则存入salaryTemplate字段会变的很大： salaryTemplate.setBackground(backgroundBase64);
// }
// 工资单预览实体名
String entityName = SalaryI18nUtil.getI18nLabel(94626, "工资单");
// 获取人员信息项目分类
List salaryItemSetList = JSONArray.parseArray(isReplenish ? salaryTemplate.getReplenishSalaryItemSetting() : salaryTemplate.getSalaryItemSetting(), SalaryTemplateSalaryItemSetListDTO.class);
// 国际化处理
// salaryItemSetList = SalaryTemplateBO.handleI18n(salaryItemSetList);
SalaryTemplateSalaryItemSetListDTO employeeInformation = SalaryTemplateBO.getEmployeeInformation(salaryItemSetList);
Map employeeField = SalaryBillBO.buildEmployeeFieldName();
String remarkI18n = SalaryI18nUtil.getI18nLabel(140036, "发放说明");
if (StringUtils.isNotEmpty(salaryTemplate.getTextContent())) {
String yearI18n = SalaryI18nUtil.getI18nLabel(100325, "年");
String monthI18n = SalaryI18nUtil.getI18nLabel(100326, "月");
salaryTemplate
.setTextContent(salaryTemplate.getTextContent().replace("${salaryMonth}", salaryMonth.getYear() + yearI18n + salaryMonth.getMonth() + monthI18n));
}
return SalaryBillSendDTO.builder()
.salaryDate(salaryMonth)
// 消息标题
// .title(title)
// 消息内容：目前跟title一样
// .text(title)
// 工资单预览实体名
.entityName(entityName)
// 发送通道
.sendChannels(sendChannels)
// 发送者
.sendUser(user)
// 工资单模板
.salaryTemplate(salaryTemplate)
// 工资单背景图base64编码
.backgroundBase64(backgroundBase64)
// 云桥工资单消息图
.picUrl(picUrl)
// 扣缴义务人名称
.taxAgentName(taxAgentName)
// 工资单模板-薪资项目设置
.salaryItemSetList(salaryItemSetList)
// 工资单模板-员工基本信息
.employeeInformation(employeeInformation)
// 工资单模板-对应人员字段
.employeeField(employeeField)
// 工资单模板-发放说明标签国际化
.remarkI18n(remarkI18n)
// 邮件是否可以发送邮件
// .isEnableEmail(isEnableEmail)
// 工资单发放
.salarySend(salarySend)
// 收入所得项目类型
// .incomeCategorys(incomeCategorys)
//薪资项目收入所得类型
// .salaryItemIncomeCategoryMap(salaryItemIncomeCategoryMap)
.build();
}
/**
* 获取可发送数据
*
* @param salarySend
* @param ids
* @return
*/
private List> getEnableSendList(SalarySendPO salarySend, List ids, SalaryBillSendDTO salaryBillSendParam) {
SalarySendInfoQueryParam queryParam = new SalarySendInfoQueryParam();
queryParam.setSalarySendId(salarySend.getId());
// 空就是所有
queryParam.setIds(ids);
queryParam.setSendStatuss(Arrays.asList(SalarySendStatusEnum.UNSEND.getValue(), SalarySendStatusEnum.WITHDRAW.getValue()));
// 2.获取基本数据
List list = Lists.newArrayList();
if (CollectionUtils.isEmpty(ids)) {
list = getSalarySendInfoMapper().list(queryParam);
} else {
List> partition = Lists.partition(ids, 500);
for (List idsPart : partition) {
queryParam.setIds(idsPart);
list.addAll(getSalarySendInfoMapper().list(queryParam));
}
}
// // 是否是合并计税
// boolean isMerge = this.getSalarySendService(user).isMergeBySalarySend(salarySend);
List salaryAcctEmployeeList = this.getSalaryAcctEmployeeService(user).listBySalaryAcctRecordId(salarySend.getSalaryAccountingId());
List acctEmployeeIds = salaryAcctEmployeeList.stream().map(SalaryAcctEmployeePO::getEmployeeId).distinct().collect(Collectors.toList());
list = list.stream().filter(f -> acctEmployeeIds.contains(f.getEmployeeId())).collect(Collectors.toList());
List employeeIds = list.stream().map(SalarySendInfoListDTO::getEmployeeId).collect(Collectors.toList());
// 初始化进度
ProgressDTO initProgress = ProgressDTO.builder()
.title("发送中")
.totalQuantity(employeeIds.size() * 2 + 1)
.calculatedQuantity(NumberUtils.INTEGER_ZERO)
.progress(BigDecimal.ZERO)
.message("")
.build();
getProgressService(user).initProgress(SalaryCacheKey.SALARY_GRANT_PROGRESS + "_" + salarySend.getId(), initProgress);
// 3.组装详情数据
// 获取薪资项目数据
List salaryAcctEmployees = Lists.newArrayList();
List salaryAcctResultValues = Lists.newArrayList();
//是否需要发送邮件
Boolean isEnableEmail = salaryBillSendParam.getSendChannels().contains(MessageChannelEnum.EMAIL);
if (CollectionUtils.isNotEmpty(ids)) {
int partSize = 100;// 分片大小,越小进度条跑得越短平快，但是总体速度更慢
List> partition = Lists.partition(employeeIds, partSize);
for (List part : partition) {
// 更新进度
getProgressService(user).getAndAddCalculatedQty(SalaryCacheKey.SALARY_GRANT_PROGRESS + "_" + salarySend.getId(), part.size());
/** 注意只有邮件才需要加密的核算数据 */
if (isEnableEmail) {
List acctEmployees = getSalaryAcctEmployeeService(user).listBySalaryAcctRecordIdsAndEmployeeIds(Collections.singletonList(salarySend.getSalaryAccountingId()), part);
salaryAcctEmployees.addAll(acctEmployees);
salaryAcctResultValues.addAll(getSalaryAcctResultService(user).listBySalaryAcctEmployeeIds(SalaryEntityUtil.properties(acctEmployees, SalaryAcctEmployeePO::getId, Collectors.toList())));
}
}
} else {
/** 注意只有邮件才需要加密的核算数据 */
if (isEnableEmail) {
salaryAcctEmployees = getSalaryAcctEmployeeService(user).listBySalaryAcctRecordId(salarySend.getSalaryAccountingId());
salaryAcctResultValues = getSalaryAcctResultService(user).listBySalaryAcctRecordIds(Collections.singletonList(salarySend.getSalaryAccountingId()));
}
}
// 外部人员
// List extEmployeeList = extEmployeeService.listAllWithDeleted(currentTenantKey);
return getSalarySendService(user)
.buildDetailList(list, salaryAcctEmployees, salaryAcctResultValues);
}
/**
* 发送消息
*
* @param enableSendList
* @param salaryBillSendParam
*/
private List sendMessage(List> enableSendList, SalaryBillSendDTO salaryBillSendParam) {
if (CollectionUtils.isEmpty(enableSendList)) {
return Collections.emptyList();
}
if (salaryBillSendParam == null) {
return enableSendList.stream().map(e -> Long.valueOf(e.get("id").toString())).collect(Collectors.toList());
}
Set sendChannels = salaryBillSendParam.getSendChannels();
// 获取人员完整信息
Map allEmployeeMap = this.getEmployeeWholeInfo(enableSendList);
List sendInfoUpdateList = Lists.newArrayList();
AtomicInteger index = new AtomicInteger(0);
AtomicInteger part = new AtomicInteger(0);
int total = enableSendList.size();
enableSendList.forEach(e -> {
if (sendChannels.contains(MessageChannelEnum.MSG)) {
SalaryBillBO.sendMsg(salaryBillSendParam, Long.valueOf(e.get("id").toString()), Long.valueOf(e.get("employeeId").toString()));
}
if (sendChannels.contains(MessageChannelEnum.EMAIL)) {
// 构建发送消息
SalaryBillBO.buildEmployeeInfo(salaryBillSendParam, allEmployeeMap.get(e.get("employeeId").toString()));
SalaryBillBO.sendEmail(e, allEmployeeMap, salaryBillSendParam);
}
/** 发送工资单 **********************************************************/
sendInfoUpdateList.add(SalarySendInfoPO.builder()
.id(Long.valueOf(e.get("id").toString()))
.build());
// 更新发送进度
index.addAndGet(1);
part.addAndGet(1);
if (index.get() % 100 == 0 || index.get() >= total) {
getProgressService(user).getAndAddCalculatedQty(SalaryCacheKey.SALARY_GRANT_PROGRESS + "_" + salaryBillSendParam.getSalarySend().getId(), part.get());
part.set(0);
}
});
// 批量修改发送消息id
if (CollectionUtils.isNotEmpty(sendInfoUpdateList)) {
// sqlserver数据库处理，每个分片数量约=2100/插入字段数
List> partition = Lists.partition(sendInfoUpdateList, 500);
// partition.forEach(updatePart -> getSalarySendInfoMapper().batchUpdateMsgId(updatePart));
}
return sendInfoUpdateList.stream().map(SalarySendInfoPO::getId).collect(Collectors.toList());
}
/**
* 获取人员完整信息
*
* @param enableSendList
* @return
*/
private Map getEmployeeWholeInfo(List> enableSendList) {
List ids = enableSendList.stream().map(e -> Long.valueOf(e.get("employeeId").toString())).collect(Collectors.toList());
// 获取所有人员信息
List simpleEmployees = getSalaryEmployeeService(user).getEmployeeByIdsAll(ids);
return SalaryEntityUtil.convert2Map(simpleEmployees, e -> e.getEmployeeId() + "");
}
// /** 工资单发放 end **********************************************************************/
/**
* 检查和获取工资单发放信息
*
* @param salarySendId
* @return
*/
private SalarySendPO checkAndGetSalarySend(Long salarySendId) {
if (salarySendId == null) {
throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100327, "工资单发放Id必传"));
}
SalarySendPO salarySend = this.getSalarySendService(user).getById(salarySendId);
if (salarySend == null) {
throw new SalaryRunTimeException(String.format(SalaryI18nUtil.getI18nLabel(100512, "工资单发放不存在") + "[id:%s]", salarySendId));
}
return salarySend;
}
// /**
// * 分权处理
// *
// * @param salarySend
// * @param ids
// * @param currentEmployeeId
// * @param currentTenantKey
// * @return
// */
// private List getIdsForDevolution(SalarySendPO salarySend, List ids) {
// // 开启分权或且是非薪酬模块总管理员且发送全部
// if (getTaxAgentService(user).isOpenDevolution(currentTenantKey) && !getTaxAgentService(user).isChief(currentEmployeeId) && CollectionUtils.isEmpty(ids)) {
// List salaryAcctEmployees = getSalaryAcctEmployeeService(user)
// .listByRecordIds(Collections.singletonList(salarySend.getSalaryAccountingId()));
//
// List taxAgentIdsAsAdmin = getTaxAgentService(user).listAllTaxAgentsAsAdmin(currentEmployeeId).stream().map(TaxAgentPO::getId)
// .collect(Collectors.toList());
// List taxAgentEmployees = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId).stream()
// .filter(t -> !taxAgentIdsAsAdmin.contains(t.getTaxAgentId())).collect(Collectors.toList());
// Map> taxAgentEmployeesMap = SalaryEntityUtil.convert2Map(taxAgentEmployees, TaxAgentManageRangeEmployeeDTO::getTaxAgentId,
// v -> v.getEmployeeList().stream().map(TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee::getEmployeeId).collect(Collectors.toList()));
//
// List extEmployeeList = extEmployeeService.listCanUse(currentEmployeeId);
// // 工资单发放信息过滤
// List salarySendInfos = new LambdaQueryChainWrapper<>(getSalarySendInfoMapper())
// /** 注意：需要啥就加载啥，避免加载大字段salaryTemplate */
// .select(SalarySendInfoPO::getId, SalarySendInfoPO::getEmployeeId, SalarySendInfoPO::getCreator)
// .eq(SalarySendInfoPO::getDeleteType, 0)
// .eq(SalarySendInfoPO::getTenantKey)
// .eq(SalarySendInfoPO::getSalarySendId, salarySend.getId())
// .list();
//
// List acctEmployeeIds = salaryAcctEmployees.stream().filter(f ->
// // 作为管理员
// taxAgentIdsAsAdmin.contains(f.getTaxAgentId())
// // 作为分管理员
// || TaxAgentBO.checkTaxAgentAndEmployee(taxAgentEmployeesMap, f.getTaxAgentId(), f.getEmployeeId())
// // 外部人员
// || extEmployeeList.stream().anyMatch(t -> t.getTaxAgentId().equals(f.getTaxAgentId()) && t.getId().equals(f.getEmployeeId()))
// ).map(SalaryAcctEmployeePO::getEmployeeId).collect(Collectors.toList());
//
// ids = salarySendInfos.stream().filter(f -> acctEmployeeIds.contains(f.getEmployeeId()) || currentEmployeeId.equals(f.getCreator())).map(SalarySendInfoPO::getId)
// .distinct().collect(Collectors.toList());
// }
// return ids;
// }
/**
* 发放工资单更新信息
*
* @param ids
* @param salarySend
* @param salaryTemplate
*/
private void grantSendInfo(List ids, SalarySendPO salarySend, SalaryTemplatePO salaryTemplate) {
List> partition = Lists.partition(ids, 500);
Date sendTime = new Date();
SalarySendInfoPO po = new SalarySendInfoPO();
po.setSendStatus(SalarySendStatusEnum.ALREADYSEND.getValue());
po.setSendTime(sendTime);
po.setSalaryTemplate(JsonUtil.toJsonString(salaryTemplate));
partition.forEach(idsp -> {
salarySendInfoMapper.updateGrantWithdraw(po, salarySend.getId(), Arrays.asList(SalarySendStatusEnum.UNSEND.getValue(), SalarySendStatusEnum.WITHDRAW.getValue()), idsp);
});
}
// /**
// * 撤回工资单更新信息
// *
// * @param ids
// * @param salarySend
// * @param currentTenantKey
// */
// private void withdrawSendInfo(List ids, SalarySendPO salarySend) {
// List> partition = Lists.partition(ids, DbCrudConstant.DEF_PART_SIZE);
// partition.forEach(part -> new LambdaUpdateChainWrapper<>(getSalarySendInfoMapper())
// .eq(SalarySendInfoPO::getDeleteType, 0)
// .eq(SalarySendInfoPO::getTenantKey)
// .eq(SalarySendInfoPO::getSalarySendId, salarySend.getId())
// .eq(SalarySendInfoPO::getSendStatus, SalarySendStatusEnum.ALREADYSEND.getValue())
// .in(SalarySendInfoPO::getId, part)
// .set(SalarySendInfoPO::getSendStatus, SalarySendStatusEnum.WITHDRAW.getValue())
// .update());
// }
//
/**
* 更新发送数量
*
* @param salarySend
* @param salarySob
*/
private void updateSendNum(SalarySendPO salarySend, SalarySobPO salarySob) {
List list = salarySendInfoMapper.listSome(SalarySendInfoPO.builder().salarySendId(salarySend.getId()).build());
List 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(new Date());
mapper.updateById(salarySendNew);
}
// /**
// * 工资单撤回 start
// **********************************************************************/
// @Override
// @Transactional(rollbackFor = Exception.class)
// public void withdraw(SalarySendWithdrawParam param, boolean isRange, List rangeIds) {
// // 1.检查和获取工资单发放
// SalarySendPO salarySend = checkAngGetSalarySend(param.getSalarySendId());
//// // 已经冻结不能操作
//// if (salarySend.getSendStatus().equals(NumberUtils.INTEGER_ONE)) {
//// return;
//// }
//
// // 检查是否正在撤回中
// SalaryBillProgressDTO salaryBillProgress = getProgressService(user)
// .getProgress(SalaryCacheKey.SALARY_WITHDRAW_PROGRESS, "" + salarySend.getId());
// if (Objects.nonNull(salaryBillProgress) && salaryBillProgress.isStatus()
// && Optional.ofNullable(salaryBillProgress.getProgress()).orElse(BigDecimal.ZERO).compareTo(BigDecimal.ONE) < 0) {
// throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(136105, "有其他人员正在撤回中，请等待其他人员撤回结束后再操作"));
// }
//
// // 初始化进度
// SalaryBillProgressDTO initProgress = getProgressService(user)
// .buildInitProgress("撤回中", 136106, NumberUtils.INTEGER_ONE, NumberUtils.INTEGER_ZERO, BigDecimal.ZERO);
// getProgressService(user).initProgress(SalaryCacheKey.SALARY_WITHDRAW_PROGRESS, "" + salarySend.getId(), initProgress);
//
// List ids = isRange ? getSalarySendRangeService(user).getSendInfoIdsBySalarySendIdAndOperateType(salarySend.getId(), rangeIds, SalarySendOperateTypeEnum.WITHDRAW) : param.getIds();
// // 异步执行撤回
// LocalRunnable localRunnable = new LocalRunnable() {
// @Override
// public void execute() {
// handleWithdraw(salarySend, ids);
// }
// };
// ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "salaryBillWithdraw", localRunnable);
// }
//
// /**
// * 处理撤回
// *
// * @param salarySend
// * @param ids
// * @param currentEmployeeId
// * @param currentTenantKey
// */
// private void handleWithdraw(SalarySendPO salarySend, List ids) {
// try {
// DSTenantKeyThreadVar.tenantKey.set(currentTenantKey);
//
// // 开启分权或且是非薪酬模块总管理员且发送全部,谁能进来就是能看全部
// // ids = getIdsForDevolution(salarySend, ids);
//
// // 获取可撤回的工资单
// List enableWithdrawList = Lists.newArrayList();
// if (CollectionUtils.isEmpty(ids)) {
// List salaryAcctEmployees = this.getSalarySendService(user).getSalaryAcctEmployees(salarySend.getSalaryAccountingId(), null);
// List acctEmployeeIds = salaryAcctEmployees.stream().map(SalaryAcctEmployeePO::getEmployeeId).distinct().collect(Collectors.toList());
// List> partition = Lists.partition(acctEmployeeIds, DbCrudConstant.DEF_PART_SIZE);
// for (List part : partition) {
// enableWithdrawList.addAll(new LambdaQueryChainWrapper<>(getSalarySendInfoMapper())
// /** 注意：需要啥就加载啥，避免加载大字段salaryTemplate */
// .select(SalarySendInfoPO::getId, SalarySendInfoPO::getSendMsgId)
// .eq(SalarySendInfoPO::getDeleteType, 0)
// .eq(SalarySendInfoPO::getTenantKey)
// .eq(SalarySendInfoPO::getSalarySendId, salarySend.getId())
// .eq(SalarySendInfoPO::getSendStatus, SalarySendStatusEnum.ALREADYSEND.getValue())
// .in(SalarySendInfoPO::getEmployeeId, part)
// .list());
// }
// } else {
// List> partition = Lists.partition(ids, DbCrudConstant.DEF_PART_SIZE);
// for (List part : partition) {
// enableWithdrawList.addAll(new LambdaQueryChainWrapper<>(getSalarySendInfoMapper())
// /** 注意：需要啥就加载啥，避免加载大字段salaryTemplate */
// .select(SalarySendInfoPO::getId, SalarySendInfoPO::getSendMsgId)
// .eq(SalarySendInfoPO::getDeleteType, 0)
// .eq(SalarySendInfoPO::getTenantKey)
// .eq(SalarySendInfoPO::getSalarySendId, salarySend.getId())
// .eq(SalarySendInfoPO::getSendStatus, SalarySendStatusEnum.ALREADYSEND.getValue())
// .in(SalarySendInfoPO::getId, part)
// .list());
// }
// }
//
// // 初始化进度
// SalaryBillProgressDTO initProgress = getProgressService(user)
// .buildInitProgress("撤回中", 136106, enableWithdrawList.size() * 2 + 1, enableWithdrawList.size(), new BigDecimal("0.5"));
// getProgressService(user).initProgress(SalaryCacheKey.SALARY_WITHDRAW_PROGRESS, "" + salarySend.getId(), initProgress);
//
// // 1.撤回消息：先修改数据再发消息，避免出错后无法撤回
// String text = SalaryI18nUtil.getI18nLabel(184533, "此工资单已被撤回，如有问题，请联系管理员");
// String title = SalaryI18nUtil.getI18nLabel(94626, "工资单");
// List sendInfoUpdateIds = Lists.newArrayList();
//
// AtomicInteger index = new AtomicInteger(0);
// AtomicInteger part = new AtomicInteger(0);
// int total = enableWithdrawList.size();
// enableWithdrawList.forEach(e -> {
// if (!e.getSendMsgId().equals(0L)) {
// CancleMessageEntity cme = SalaryBillBO.buildCancleMessageEntity(e.getSendMsgId(), text, title);
// /** 撤回工资单 **********************************************************/
// WeaResult