946 lines
46 KiB
Java
946 lines
46 KiB
Java
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.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.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.service.*;
|
|
import com.engine.salary.util.JsonUtil;
|
|
import com.engine.salary.util.SalaryDateUtil;
|
|
import com.engine.salary.util.SalaryI18nUtil;
|
|
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 weaver.hrm.User;
|
|
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
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 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
|
|
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, "核算记录不存在"));
|
|
}
|
|
|
|
|
|
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, "工资单已生成过，不可再重复生成"));
|
|
}
|
|
|
|
SalaryAcctEmployeePO employeePO = new SalaryAcctEmployeePO();
|
|
employeePO.setDeleteType(0);
|
|
employeePO.setSalaryAcctRecordId(salaryAccountingId);
|
|
List<SalaryAcctEmployeePO> salaryAcctEmployees = getSalaryAcctEmployeeMapper().listSome(employeePO);
|
|
|
|
Long salarySendId = IdGenerator.generate();
|
|
|
|
SalaryAcctRecordPO salaryAcctRecord = acctRecords.get(0);
|
|
|
|
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("")
|
|
.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())
|
|
.lastSendTime(new Date())
|
|
.creator((long) user.getUID())
|
|
.createTime(new Date())
|
|
.updateTime(new Date())
|
|
.build();
|
|
// 插入工资单发放记录
|
|
mapper.insert(salarySend);
|
|
// 插入工资单人员记录
|
|
salarySendInfoMapper.batchInsert(salarySendInfos);
|
|
|
|
return "";
|
|
}
|
|
|
|
// @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(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(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();
|
|
// }
|
|
// });
|
|
|
|
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(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);
|
|
|
|
// // 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));
|
|
// }
|
|
}
|