qt
/
weaver-hrm-salary
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
weaver-hrm-salary/src/com/engine/salary/service/impl/EmployeeDeclareExcelService...

1193 lines
75 KiB
Java
Raw Normal View History

人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
package com.engine.salary.service.impl;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
个税日志
2024-03-08 11:14:00 +08:00
import com.engine.salary.config.SalaryElogConfig;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import com.engine.salary.constant.SalaryDefaultTenantConstant;
解决冲突
2024-03-12 18:58:36 +08:00
import com.engine.hrmelog.entity.dto.LoggerContext;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
人员信息报送导入
2023-12-27 16:58:47 +08:00
import com.engine.salary.entity.employeedeclare.bo.EmployeeDeclareBO;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareExcelDTO;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareListDTO;
人员报送导入模板
2023-12-13 17:52:51 +08:00
import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareImportParam;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareListQueryParam;
import com.engine.salary.entity.employeedeclare.po.EmployeeDeclarePO;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
个税日志
2024-03-08 11:14:00 +08:00
import com.engine.salary.enums.OperateTypeEnum;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import com.engine.salary.enums.SalaryOnOffEnum;
import com.engine.salary.enums.datacollection.UseEmployeeTypeEnum;
外籍人员更新
2024-04-11 18:57:56 +08:00
import com.engine.salary.enums.employeedeclare.*;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import com.engine.salary.enums.salaryaccounting.EmployeeTypeEnum;
import com.engine.salary.enums.sicategory.DeleteTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.employeedeclare.EmployeeDeclareMapper;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
import com.engine.salary.service.EmployeeDeclareExcelService;
import com.engine.salary.service.EmployeeDeclareService;
import com.engine.salary.service.SalaryEmployeeService;
import com.engine.salary.service.TaxAgentService;
个税日志
2024-03-08 11:14:00 +08:00
import com.engine.salary.util.*;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import com.engine.salary.util.db.MapperProxyFactory;
import com.engine.salary.util.excel.*;
import com.engine.salary.util.valid.SalaryCardUtil;
人员报送导入模板
2023-12-13 17:52:51 +08:00
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import com.google.common.collect.Maps;
合并240101
2024-02-21 15:35:08 +08:00
import com.engine.salary.util.db.IdGenerator;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
import lombok.extern.slf4j.Slf4j;
人员报送导入模板
2023-12-13 17:52:51 +08:00
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.util.IOUtils;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import org.springframework.beans.BeanUtils;
人员信息报送导入
2023-12-27 16:58:47 +08:00
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import weaver.file.ExcelSheet;
import weaver.file.ImageFileManager;
人员报送导入模板
2023-12-13 17:52:51 +08:00
import weaver.general.Util;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
import weaver.hrm.User;
人员信息报送导入
2023-12-27 16:58:47 +08:00
import java.beans.PropertyDescriptor;
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import java.io.InputStream;
import java.util.*;
人员报送导入模板
2023-12-13 17:52:51 +08:00
import java.util.stream.Collectors;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
人员信息报送-导入
2023-12-26 17:45:06 +08:00
import static com.engine.salary.util.excel.ExcelSupport.EXCEL_TYPE_XLSX;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
/**
人员报送导入模板
2023-12-13 17:52:51 +08:00
* 人员报送（人员）导入导出
* <p>Copyright: Copyright (c) 2023</p>
* <p>Company: 泛微软件</p>
*
* @author qiantao
* @version 1.0
**/
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
@Slf4j
public class EmployeeDeclareExcelServiceImpl extends Service implements EmployeeDeclareExcelService {
private EmployeeDeclareService getEmployeeDeclareService(User user) {
return ServiceUtil.getService(EmployeeDeclareServiceImpl.class, user);
}
人员报送导入模板
2023-12-13 17:52:51 +08:00
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
private SalaryEmployeeService getSalaryEmployeeService(User user) {
return ServiceUtil.getService(SalaryEmployeeServiceImpl.class, user);
}
// private ExtEmployeeService extEmployeeService;
private TaxAgentService getTaxAgentService(User user) {
return ServiceUtil.getService(TaxAgentServiceImpl.class, user);
}
人员信息报送-导入
2023-12-26 17:45:06 +08:00
private EmployeeDeclareMapper getEmployeeDeclareMapper() {
return MapperProxyFactory.getProxy(EmployeeDeclareMapper.class);
}
人员报送导入模板
2023-12-13 17:52:51 +08:00
@Override
public XSSFWorkbook exportTemplate(EmployeeDeclareImportParam importParam) {
// 查询人员
List<EmployeeDeclarePO> employeeDeclares = Collections.emptyList();
if (StringUtils.equalsIgnoreCase(importParam.getExportData(), "true")) {
employeeDeclares = getEmployeeDeclareService(user).listByParam(importParam);
}
身份证最后一位x转大写
2023-12-13 19:34:10 +08:00
String yesI18 = SalaryI18nUtil.getI18nLabel(111111, "是");
String noI18 = SalaryI18nUtil.getI18nLabel(111111, "否");
人员报送导入模板
2023-12-13 17:52:51 +08:00
List<List<Object>> rows = Lists.newArrayList();
for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
EmploymentStatusEnum employmentStatusEnum = SalaryEnumUtil.enumMatchByValue(employeeDeclare.getEmploymentStatus(), EmploymentStatusEnum.class);
EmploymentTypeEnum employmentTypeEnum = SalaryEnumUtil.enumMatchByValue(employeeDeclare.getEmploymentType(), EmploymentTypeEnum.class);
List<Object> row = Lists.newArrayList();
row.add(employeeDeclare.getJobNum());
row.add(employeeDeclare.getEmployeeName());
外籍人员更新
2024-04-11 18:57:56 +08:00
row.add(CardTypeEnum.getByValue(employeeDeclare.getCardType()).getDefaultLabel());
人员报送导入模板
2023-12-13 17:52:51 +08:00
row.add(employeeDeclare.getCardNum());
外籍人员更新
2024-04-11 18:57:56 +08:00
row.add(employeeDeclare.getNationality());
row.add(GenderEnum.getDefaultLabelByValue(employeeDeclare.getGender()).getDefaultLabel());
row.add(employeeDeclare.getBirthplace());
row.add(employeeDeclare.getBirthday());
人员报送导入模板
2023-12-13 17:52:51 +08:00
row.add(employmentStatusEnum == null ? "" : employmentStatusEnum.getDefaultLabel());
row.add(employeeDeclare.getMobile());
外籍人员更新
2024-04-11 18:57:56 +08:00
row.add(employmentTypeEnum == null ? EmploymentTypeEnum.EMPLOYEE.getDefaultLabel() : employmentTypeEnum.getDefaultLabel());
人员信息报送导入
2023-12-27 16:58:47 +08:00
row.add(SalaryDateUtil.getFormatDate(employeeDeclare.getEmploymentDate()));
row.add(SalaryDateUtil.getFormatDate(employeeDeclare.getDismissDate()));
外籍人员更新
2024-04-11 18:57:56 +08:00
row.add(SalaryDateUtil.getFormatDate(employeeDeclare.getEntryDate()));
row.add(SalaryDateUtil.getFormatDate(employeeDeclare.getDepartureDate()));
row.add(employeeDeclare.getTaxReasons());
人员报送导入模板
2023-12-13 17:52:51 +08:00
row.add(Objects.equals(employeeDeclare.getDisability(), 1) ? yesI18 : noI18);
row.add(employeeDeclare.getDisabilityCardNo());
row.add(Objects.equals(employeeDeclare.getMartyrDependents(), 1) ? yesI18 : noI18);
row.add(employeeDeclare.getMartyrDependentsCardNo());
row.add(Objects.equals(employeeDeclare.getLonelyOld(), 1) ? yesI18 : noI18);
row.add(Objects.equals(employeeDeclare.getDeductExpenses(), 1) ? yesI18 : noI18);
rows.add(row);
}
// 组装excel导出数据
ExcelSheetData excelSheetData = new ExcelSheetData();
身份证最后一位x转大写
2023-12-13 19:34:10 +08:00
excelSheetData.setSheetName(SalaryI18nUtil.getI18nLabel(111111, "人员信息采集"));
人员报送导入模板
2023-12-13 17:52:51 +08:00
excelSheetData.setHeaders(getImportHeader());
excelSheetData.setRows(rows);
return ExcelUtil.genWorkbook(excelSheetData);
}
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
人员信息报送导入
2023-12-27 16:58:47 +08:00
@Override
public Map<String, Object> preview(EmployeeDeclareImportParam param) {
//1、参数校验
String imageId = param.getImageId();
if (StringUtils.isBlank(imageId)) {
throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "文件id为空"));
}
Map<String, Object> map = new HashMap<>();
InputStream fileInputStream = null;
try {
fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(param.getImageId()));
Sheet sheet = ExcelSupport.parseFile(fileInputStream, 0, EXCEL_TYPE_XLSX);
List<String> headers = ExcelSupport.getSheetHeader(sheet, 0);
map.put("headers", headers);
map.put("list", ExcelParseHelper.parse2List(sheet, 1));
return map;
} finally {
IOUtils.closeQuietly(fileInputStream);
}
}
人员信息报送-导入
2023-12-26 17:45:06 +08:00
@Override
public Map<String, Object> importData(EmployeeDeclareImportParam param) {
Map<String, Object> apidatas = new HashMap<>();
InputStream fileInputStream = null;
try {
Date now = new Date();
// 个税扣缴义务人id
Long taxAgentId = param.getTaxAgentId();
TaxAgentPO taxAgent = getTaxAgentService(user).getById(taxAgentId);
if (taxAgent == null) {
throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "参数错误，无法找到个税扣缴义务人"));
}
// 税款所属期
人员信息报送导入
2023-12-27 16:58:47 +08:00
String taxCycle = SalaryDateUtil.getFormatDate(param.getTaxCycle());
人员信息报送-导入
2023-12-26 17:45:06 +08:00
Date taxCycleDate = param.getTaxCycle();
// 导出模板中的表头
List<String> headerList = getImportHeader().stream().map(header -> header.toString()).collect(Collectors.toList());
// 查询所有的人员
List<DataCollectionEmployee> simpleEmployees = getSalaryEmployeeService(user).listAll(UseEmployeeTypeEnum.ORG);
// 查询所有的外部人员
List<DataCollectionEmployee> extEmployees = getSalaryEmployeeService(user).listAll(UseEmployeeTypeEnum.EXT);
// 查询人员报送表的人员
List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).listByTaxCycleAndTaxAgentId(SalaryDateUtil.dateStrToLocalDate(taxCycle), taxAgentId);
// 校验字段
String checkType = param.getCheckType();
Map<String, DataCollectionEmployee> extEmployeeMap = Maps.newHashMap();
Map<String, DataCollectionEmployee> simpleEmployeeMap = Maps.newHashMap();
Map<String, EmployeeDeclarePO> employeeDeclareMap = Maps.newHashMapWithExpectedSize(employeeDeclares.size());
if (Objects.equals(checkType, "jobNum")) {
extEmployeeMap = Collections.emptyMap();
simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, DataCollectionEmployee::getWorkcode);
employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getJobNum);
} else {
// 查询所有人员的个人信息
simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, DataCollectionEmployee::getIdNo);
extEmployeeMap = SalaryEntityUtil.convert2Map(extEmployees, DataCollectionEmployee::getIdNo);
employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getCardNum);
}
// 需要新增的报送人员
List<EmployeeDeclarePO> needAddEmployeeDeclares = Lists.newArrayList();
// 需要更新的报送人员
List<EmployeeDeclarePO> needUpdateEmployeeDeclares = Lists.newArrayList();
// 索引(用于计算进度)
int index = 0;
// 失败的数量
int failCount = 0;
// 成功的数量
int successCount = 0;
// 错误行的索引
int failRowIndex = 1;
// 包含错误提示信息的sheet页
List<ExcelSheet> errorExcelSheets = Lists.newArrayList();
String imageId = Util.null2String(param.getImageId());
fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(imageId));
Sheet sheet = ExcelSupport.parseFile(fileInputStream, 0, EXCEL_TYPE_XLSX);
// 表头
List<String> headers = ExcelSupport.getSheetHeader(sheet, 0);
外籍人员更新
2024-04-11 18:57:56 +08:00
人员信息报送-导入
2023-12-26 17:45:06 +08:00
// 检查表头
String isCorrectHeader = checkHeader(headers, headerList);
if (isCorrectHeader != null) {
throw new SalaryRunTimeException(isCorrectHeader);
}
// 数据
List<Map<String, Object>> data = ExcelParseHelper.parse2Map(sheet, 1);
if (CollectionUtils.isEmpty(data)) {
throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "导入数据不能为空"));
}
// 错误提示信息
List<ExcelComment> excelComments = Lists.newArrayList();
List<Map> errorData = new ArrayList<>();
for (int i = 0; i < data.size(); i++) {
//行号
String rowIndex = String.format("第%s行", i + 2);
Map<String, Object> map = data.get(i);
// 数据是否存在错误
boolean isError = false;
EmployeeDeclareExcelDTO employeeDeclareExcel = new EmployeeDeclareExcelDTO();
for (String dataKey : headerList) {
String dataValue = Util.null2String(map.get(dataKey));
外籍人员更新
2024-04-11 18:57:56 +08:00
if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "工号"))) {
人员信息报送-导入
2023-12-26 17:45:06 +08:00
if (StringUtils.equals(checkType, "jobNum") && StringUtils.isEmpty(dataValue)) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "工号不能为空"));
errorData.add(errorMessageMap);
}
employeeDeclareExcel.setJobNum(dataValue);
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "姓名"))) {
if (StringUtils.isEmpty(dataValue)) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "姓名不能为空"));
errorData.add(errorMessageMap);
} else {
employeeDeclareExcel.setEmployeeName(dataValue);
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "证件类型"))) {
if (StringUtils.isEmpty(dataValue)) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
外籍人员更新
2024-04-11 18:57:56 +08:00
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "证件类型不能为空"));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
errorData.add(errorMessageMap);
外籍人员更新
2024-04-11 18:57:56 +08:00
} else {
CardTypeEnum cardTypeEnum = CardTypeEnum.getByDefaultLabel(dataValue);
if (cardTypeEnum == null) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "证件类型填写错误，只能填写居民身份证、外国护照"));
errorData.add(errorMessageMap);
} else {
employeeDeclareExcel.setCardType(cardTypeEnum.getValue());
}
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "证件号码"))) {
if (StringUtils.isEmpty(dataValue)) {
人员信息报送-导入
2023-12-26 17:45:06 +08:00
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
外籍人员更新
2024-04-11 18:57:56 +08:00
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "证件号码不能为空"));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
errorData.add(errorMessageMap);
} else {
人员信息报送身份中号转为大写
2023-12-28 10:10:08 +08:00
// 身份证号全部转为大写
employeeDeclareExcel.setCardNum(dataValue.toUpperCase());
外籍人员更新
2024-04-11 18:57:56 +08:00
// employeeDeclareExcel.setGender(SalaryCardUtil.judgeGender(dataValue).getValue().toString());
// employeeDeclareExcel.setBirthday(SalaryCardUtil.judgeBirthday(dataValue).toString());
人员信息报送-导入
2023-12-26 17:45:06 +08:00
}
外籍人员更新
2024-04-11 18:57:56 +08:00
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "国籍"))) {
employeeDeclareExcel.setNationality(dataValue);
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "性别"))) {
Integer gender = GenderEnum.getValueByDefaultLabel(dataValue);
if (gender == null) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "性别填写有误！"));
errorData.add(errorMessageMap);
} else {
employeeDeclareExcel.setGender(gender);
人员信息报送-导入
2023-12-26 17:45:06 +08:00
}
外籍人员更新
2024-04-11 18:57:56 +08:00
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "出生地"))) {
employeeDeclareExcel.setBirthplace(dataValue);
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "出生日期"))) {
if (StringUtils.isNotBlank(dataValue) && dataValue.length() >= 10) {
dataValue = dataValue.substring(0, 10);
}
if (!SalaryDateUtil.checkDay(dataValue)) {
人员信息报送-导入
2023-12-26 17:45:06 +08:00
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
外籍人员更新
2024-04-11 18:57:56 +08:00
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "日期格式不正确"));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
errorData.add(errorMessageMap);
外籍人员更新
2024-04-11 18:57:56 +08:00
} else {
employeeDeclareExcel.setBirthday(SalaryDateUtil.dateStrToLocalDate(dataValue));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
}
外籍人员更新
2024-04-11 18:57:56 +08:00
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "状态"))) {
人员信息报送-导入
2023-12-26 17:45:06 +08:00
boolean legalDataValue = false;
外籍人员更新
2024-04-11 18:57:56 +08:00
for (EmploymentStatusEnum employmentStatusEnum : EmploymentStatusEnum.values()) {
if (StringUtils.equals(dataValue, employmentStatusEnum.getDefaultLabel())) {
人员信息报送-导入
2023-12-26 17:45:06 +08:00
legalDataValue = true;
外籍人员更新
2024-04-11 18:57:56 +08:00
employeeDeclareExcel.setEmploymentStatus(employmentStatusEnum.getValue());
人员信息报送-导入
2023-12-26 17:45:06 +08:00
break;
}
}
if (!legalDataValue) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
外籍人员更新
2024-04-11 18:57:56 +08:00
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "人员状态只能填写正常或非正常"));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
errorData.add(errorMessageMap);
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "手机号码"))) {
if (StringUtils.isEmpty(dataValue)) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "手机号码不能为空"));
errorData.add(errorMessageMap);
} else if (!SalaryCardUtil.checkMobile(dataValue)) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "手机号码格式不正确"));
errorData.add(errorMessageMap);
} else {
employeeDeclareExcel.setMobile(dataValue);
}
外籍人员更新
2024-04-11 18:57:56 +08:00
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "任职受雇从业类型"))) {
boolean legalDataValue = false;
for (EmploymentTypeEnum employmentTypeEnum : EmploymentTypeEnum.values()) {
if (StringUtils.equals(dataValue, employmentTypeEnum.getDefaultLabel())) {
legalDataValue = true;
employeeDeclareExcel.setEmploymentType(employmentTypeEnum.getValue());
break;
}
}
if (!legalDataValue) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "任职受雇从业类型填写错误"));
errorData.add(errorMessageMap);
}
人员信息报送-导入
2023-12-26 17:45:06 +08:00
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "任职受雇从业日期"))) {
if (StringUtils.isEmpty(dataValue)) {
人员信息报送日期支持yyyy/mm/dd写法
2024-02-01 12:03:24 +08:00
if (!Objects.equals(employeeDeclareExcel.getEmploymentType(), EmploymentTypeEnum.OTHER.getValue().toString())) {
人员信息报送-导入
2023-12-26 17:45:06 +08:00
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "任职受雇从业类型不为「其他」时，任职受雇从业日期为必填"));
errorData.add(errorMessageMap);
}
} else {
人员信息报送导入
2023-12-28 16:44:01 +08:00
if (StringUtils.isNotBlank(dataValue) && dataValue.length() >= 10) {
外籍人员更新
2024-04-11 18:57:56 +08:00
dataValue = dataValue.substring(0, 10);
人员信息报送导入
2023-12-28 16:44:01 +08:00
}
人员信息报送-导入
2023-12-26 17:45:06 +08:00
if (!SalaryDateUtil.checkDay(dataValue)) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "日期格式不正确"));
errorData.add(errorMessageMap);
} else {
外籍人员更新
2024-04-11 18:57:56 +08:00
employeeDeclareExcel.setEmploymentDate(SalaryDateUtil.dateStrToLocalDate(dataValue));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
}
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "离职日期"))) {
if (StringUtils.isEmpty(dataValue)) {
人员信息报送日期支持yyyy/mm/dd写法
2024-02-01 12:03:24 +08:00
if (Objects.equals(employeeDeclareExcel.getEmploymentStatus(), EmploymentStatusEnum.ABNORMAL.getValue().toString())) {
人员信息报送-导入
2023-12-26 17:45:06 +08:00
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "人员状态为非正常时，离职日期必填"));
errorData.add(errorMessageMap);
}
} else {
人员信息报送日期支持yyyy/mm/dd写法
2024-02-01 12:03:24 +08:00
if (StringUtils.isNotBlank(dataValue) && dataValue.length() >= 10) {
外籍人员更新
2024-04-11 18:57:56 +08:00
dataValue = dataValue.substring(0, 10);
人员信息报送日期支持yyyy/mm/dd写法
2024-02-01 12:03:24 +08:00
}
人员信息报送-导入
2023-12-26 17:45:06 +08:00
if (!SalaryDateUtil.checkDay(dataValue)) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "日期格式不正确"));
errorData.add(errorMessageMap);
} else {
外籍人员更新
2024-04-11 18:57:56 +08:00
employeeDeclareExcel.setDismissDate(SalaryDateUtil.dateStrToLocalDate(dataValue));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
}
}
外籍人员更新
2024-04-11 18:57:56 +08:00
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "首次入境时间"))) {
if (StringUtils.isNotBlank(dataValue) && dataValue.length() >= 10) {
dataValue = dataValue.substring(0, 10);
}
if (!SalaryDateUtil.checkDay(dataValue)) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "日期格式不正确"));
errorData.add(errorMessageMap);
} else {
employeeDeclareExcel.setEntryDate(SalaryDateUtil.dateStrToLocalDate(dataValue));
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "预计离境时间"))) {
if (StringUtils.isNotBlank(dataValue) && dataValue.length() >= 10) {
dataValue = dataValue.substring(0, 10);
}
if (!SalaryDateUtil.checkDay(dataValue)) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "日期格式不正确"));
errorData.add(errorMessageMap);
} else {
employeeDeclareExcel.setDepartureDate(SalaryDateUtil.dateStrToLocalDate(dataValue));
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "涉税事由"))) {
employeeDeclareExcel.setTaxReasons(dataValue);
人员信息报送-导入
2023-12-26 17:45:06 +08:00
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "是否残疾"))) {
if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
employeeDeclareExcel.setDisability(SalaryOnOffEnum.ON.getValue());
} else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
employeeDeclareExcel.setDisability(SalaryOnOffEnum.OFF.getValue());
} else {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "是否残疾只能填写是与否"));
errorData.add(errorMessageMap);
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "残疾证号"))) {
if (StringUtils.isEmpty(dataValue)) {
if (Objects.equals(employeeDeclareExcel.getDisability(), SalaryOnOffEnum.ON.getValue())) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "「是否残疾」填「是」时，残疾证号必填"));
errorData.add(errorMessageMap);
}
} else {
employeeDeclareExcel.setDisabilityCardNo(dataValue);
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "是否烈属"))) {
if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
employeeDeclareExcel.setMartyrDependents(SalaryOnOffEnum.ON.getValue());
} else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
employeeDeclareExcel.setMartyrDependents(SalaryOnOffEnum.OFF.getValue());
} else {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "是否烈属只能填写是与否"));
errorData.add(errorMessageMap);
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "烈属证号"))) {
if (StringUtils.isEmpty(dataValue)) {
if (Objects.equals(employeeDeclareExcel.getMartyrDependents(), SalaryOnOffEnum.ON.getValue())) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "「是否烈属」填「是」时，烈属证号必填"));
errorData.add(errorMessageMap);
}
} else {
employeeDeclareExcel.setMartyrDependentsCardNo(dataValue);
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "是否孤老"))) {
if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
employeeDeclareExcel.setLonelyOld(SalaryOnOffEnum.ON.getValue());
} else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
employeeDeclareExcel.setLonelyOld(SalaryOnOffEnum.OFF.getValue());
} else {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "是否孤老只能填写是与否"));
errorData.add(errorMessageMap);
}
} else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(0, "是否扣除减除费用"))) {
if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
employeeDeclareExcel.setDeductExpenses(SalaryOnOffEnum.ON.getValue());
} else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
employeeDeclareExcel.setDeductExpenses(SalaryOnOffEnum.OFF.getValue());
} else {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "是否扣除减除费用只能填写是与否"));
errorData.add(errorMessageMap);
}
}
}
if (!isError) {
if (StringUtils.equals(checkType, "jobNum")) {
EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getJobNum());
if (employeeDeclare == null) {
DataCollectionEmployee extEmployee = extEmployeeMap.get(employeeDeclareExcel.getJobNum());
DataCollectionEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getJobNum());
if (extEmployee == null && simpleEmployee == null) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "系统内的人员不存在该工号"));
errorData.add(errorMessageMap);
} else {
needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
employeeDeclareExcel, taxAgentId, taxCycleDate, now));
}
} else {
EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO();
BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare);
人员信息报送导入
2023-12-28 16:44:01 +08:00
EmployeeDeclarePO employeeDeclarePO = EmployeeDeclareBO.convert2PO(employeeDeclareExcel);
BeanUtils.copyProperties(employeeDeclarePO, newEmployeeDeclare, getNullPropertyNames(employeeDeclarePO));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
newEmployeeDeclare.setNewEmployeeInfo(StringUtils.equals(employeeDeclare.toCompareString(), newEmployeeDeclare.toCompareString()) ? 0 : 1);
newEmployeeDeclare.setUpdateTime(now);
人员信息报送导入，申报状态
2024-01-02 13:46:14 +08:00
needUpdateEmployeeDeclares.add(newEmployeeDeclare);
人员信息报送-导入
2023-12-26 17:45:06 +08:00
if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
newEmployeeDeclare.setDeclareErrorMsg("");
}
}
} else {
EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getCardNum());
if (employeeDeclare == null) {
DataCollectionEmployee extEmployee = extEmployeeMap.get(employeeDeclareExcel.getCardNum());
DataCollectionEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getCardNum());
if (extEmployee == null && simpleEmployee == null) {
isError = true;
Map<String, String> errorMessageMap = Maps.newHashMap();
errorMessageMap.put("message", rowIndex + SalaryI18nUtil.getI18nLabel(0, "系统内的人员不存在该证件号码"));
errorData.add(errorMessageMap);
} else {
needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
employeeDeclareExcel, taxAgentId, taxCycleDate, now));
}
} else {
EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO();
BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare);
人员信息报送导入
2023-12-27 16:58:47 +08:00
EmployeeDeclarePO employeeDeclarePO = EmployeeDeclareBO.convert2PO(employeeDeclareExcel);
BeanUtils.copyProperties(employeeDeclarePO, newEmployeeDeclare, getNullPropertyNames(employeeDeclarePO));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
newEmployeeDeclare.setNewEmployeeInfo(StringUtils.equals(employeeDeclare.toCompareString(), newEmployeeDeclare.toCompareString()) ? 0 : 1);
newEmployeeDeclare.setUpdateTime(now);
if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
newEmployeeDeclare.setDeclareErrorMsg("");
}
needUpdateEmployeeDeclares.add(newEmployeeDeclare);
}
}
}
if (isError) {
failCount++;
failRowIndex++;
continue;
}
successCount++;
}
if (CollectionUtils.isNotEmpty(needAddEmployeeDeclares)) {
getEmployeeDeclareService(user).batchInsert(needAddEmployeeDeclares);
}
if (CollectionUtils.isNotEmpty(needUpdateEmployeeDeclares)) {
needUpdateEmployeeDeclares.stream().forEach(getEmployeeDeclareMapper()::update);
}
个税日志
2024-03-08 11:14:00 +08:00
// 记录日志
needAddEmployeeDeclares.addAll(needUpdateEmployeeDeclares);
if (CollectionUtils.isNotEmpty(needAddEmployeeDeclares)) {
LoggerContext loggerContext = new LoggerContext<>();
loggerContext.setUser(user);
loggerContext.setTargetId(Util.null2String(taxAgentId));
loggerContext.setTargetName(taxAgent.getName() + "-" + SalaryDateUtil.getFormatYearMonth(param.getTaxCycle()));
loggerContext.setOperateType(OperateTypeEnum.EXCEL_IMPORT.getValue());
loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "导入人员信息报送"));
loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "导入人员信息报送：") + taxAgent.getName());
loggerContext.setNewValueList(needAddEmployeeDeclares);
SalaryElogConfig.employeeDeclareLoggerTemplate.write(loggerContext);
}
人员信息报送-导入
2023-12-26 17:45:06 +08:00
apidatas.put("successCount", successCount);
apidatas.put("errorCount", failCount);
人员信息报送导入
2023-12-28 16:44:01 +08:00
apidatas.put("errorData", errorData);
人员信息报送-导入
2023-12-26 17:45:06 +08:00
// 发送导入回调信息
// salaryBatchService.sendImportCallBackInfo(message, successCount, errorCount, errorExcelSheets);
} catch (Exception e) {
log.error("人员报送信息导入失败：{}", e.getMessage(), e);
} finally {
IOUtils.closeQuietly(fileInputStream);
}
return apidatas;
}
人员信息报送导入
2023-12-27 16:58:47 +08:00
外籍人员更新
2024-04-11 18:57:56 +08:00
public static String[] getNullPropertyNames(Object source) {
人员信息报送导入
2023-12-27 16:58:47 +08:00
final BeanWrapper src = new BeanWrapperImpl(source);
PropertyDescriptor[] pds = src.getPropertyDescriptors();
Set<String> emptyNames = new HashSet<>();
外籍人员更新
2024-04-11 18:57:56 +08:00
for (PropertyDescriptor pd : pds) {
人员信息报送导入
2023-12-27 16:58:47 +08:00
Object srcValue = src.getPropertyValue(pd.getName());
// 此处判断可根据需求修改
if (srcValue == null) {
emptyNames.add(pd.getName());
}
}
String[] result = new String[emptyNames.size()];
return emptyNames.toArray(result);
}
人员信息报送-导入
2023-12-26 17:45:06 +08:00
private EmployeeDeclarePO buildEmployeeDeclare(DataCollectionEmployee extEmployee, DataCollectionEmployee simpleEmployee,
EmployeeDeclareExcelDTO employeeDeclareExcel, Long taxAgentId,
Date taxCycle, Date now) {
EmployeeDeclarePO employeeDeclare = EmployeeDeclarePO.builder()
.id(IdGenerator.generate())
.taxAgentId(taxAgentId)
.taxCycle(taxCycle)
.tenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY)
.creator(Long.valueOf(user.getUID()))
.deleteType(DeleteTypeEnum.NOT_DELETED.getValue())
.createTime(now)
人员信息报送导入，申报状态
2024-01-02 13:44:57 +08:00
.updateTime(now)
.declareStatus(DeclareStatusEnum.NOT_DECLARE.getValue())
.build();
人员信息报送导入
2023-12-27 16:58:47 +08:00
EmployeeDeclarePO employeeDeclarePO = EmployeeDeclareBO.convert2PO(employeeDeclareExcel);
BeanUtils.copyProperties(employeeDeclarePO, employeeDeclare, getNullPropertyNames(employeeDeclarePO));
人员信息报送-导入
2023-12-26 17:45:06 +08:00
if (extEmployee != null) {
employeeDeclare.setEmployeeId(extEmployee.getEmployeeId());
employeeDeclare.setEmployeeType(EmployeeTypeEnum.EXT_EMPLOYEE.getValue());
}
if (simpleEmployee != null) {
employeeDeclare.setEmployeeId(simpleEmployee.getEmployeeId());
employeeDeclare.setEmployeeType(EmployeeTypeEnum.ORGANIZATION.getValue());
}
return employeeDeclare;
}
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
@Override
public XSSFWorkbook export(EmployeeDeclareListQueryParam queryParam) {
// 查询需要报送的人员
List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).listByParam(queryParam);
// 转换成dto
List<EmployeeDeclareListDTO> dtoList = getEmployeeDeclareService(user).convert(employeeDeclares);
// 需要导出的数据
导出申报明细
2023-12-08 18:15:56 +08:00
List<List<Object>> excelSheetData = ExcelUtil.getExcelSheetData(EmployeeDeclareListDTO.class, dtoList);
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
个税日志
2024-03-08 11:14:00 +08:00
// 记录日志
TaxAgentPO taxAgent = getTaxAgentService(user).getById(queryParam.getTaxAgentId());
SalaryLoggerUtil.recordExportSingleLog(SalaryElogConfig.employeeDeclareLoggerTemplate,
queryParam.getTaxAgentId(),
SalaryI18nUtil.getI18nLabel(0, "个税扣缴义务人「{0}」税款所属期「{1}」")
.replace("{0}", taxAgent.getName())
.replace("{1}", SalaryDateUtil.getFormatYearMonth(queryParam.getTaxCycle())),
"导出人员信息报送",
"导出人员信息报送",
user);
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
return ExcelUtil.genWorkbookV2(excelSheetData, "人员信息采集");
}
// @Override
// public XSSFWorkbook export4Add(EmployeeDeclareAddListQueryParam queryParam) {
// String tenantKey = simpleEmployee.getTenantKey();
// Long currentEmployeeId = simpleEmployee.getEmployeeId();
// // 查询需要报送的人员
// List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).list4AddByParam(queryParam);
// // 转换成dto
// List<EmployeeDeclareListDTO> dtoList = getEmployeeDeclareService(user).convert(employeeDeclares);
// // 需要导出的数据
// ExcelSheetData excelSheetData = getExcelSheetData(EmployeeDeclareListDTO.class, dtoList);
// CustomExportUtil.customColumnsBuild(false, queryParam.getCustomColumns(), excelSheetData);
// ExportExcelInfo exportExcelInfo = ExportExcelInfo.builder()
// .fileName(SalaryI18nUtil.getI18nLabel(156426, "人员信息采集本月新增") + "-" + SalaryDateUtil.getFormatLocalDate(LocalDateTime.now()))
// .dataType(SalaryI18nUtil.getI18nLabel(156426, "人员信息采集本月新增"))
// .function(excelExportParam.getFunction())
// .handlerName("exportEmployeeDeclare4Add")
// .flag(true)
// .bizId(excelExportParam.getBiz())
// .module(excelExportParam.getModule())
// .userId(simpleEmployee.getEmployeeId())
// .tenantKey(simpleEmployee.getTenantKey())
// .operator(simpleEmployee.getUsername())
// .eteamsId(TenantRpcContext.getEteamsId())
// .build();
// return salaryBatchService.simpleExportExcel(exportExcelInfo, Collections.singletonList(excelSheetData));
// }
//
// @BatchExportHandler("exportEmployeeDeclare4Add")
// private void exportEmployeeDeclare4Add() {
// BatchCallbackMessage message = BatchExportContext.getBatchCallbackMessage();
// log.info("导出结束：{}", JsonUtil.toJsonString(message));
// }
//
// @Override
// public XSSFWorkbook export4Update(EmployeeDeclareListQueryParam queryParam) {
// String tenantKey = simpleEmployee.getTenantKey();
// Long currentEmployeeId = simpleEmployee.getEmployeeId();
// // 查询需要报送的人员
// List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).list4UpdateByParam(queryParam);
// // 转换成dto
// List<EmployeeDeclareListDTO> dtoList = getEmployeeDeclareService(user).convert(employeeDeclares);
// // 需要导出的数据
// ExcelSheetData excelSheetData = getExcelSheetData(EmployeeDeclareListDTO.class, dtoList);
// CustomExportUtil.customColumnsBuild(false, queryParam.getCustomColumns(), excelSheetData);
// ExportExcelInfo exportExcelInfo = ExportExcelInfo.builder()
// .fileName(SalaryI18nUtil.getI18nLabel(156427, "人员信息采集本月信息变动") + "-" + SalaryDateUtil.getFormatLocalDate(LocalDateTime.now()))
// .dataType(SalaryI18nUtil.getI18nLabel(156427, "人员信息采集本月信息变动"))
// .function(excelExportParam.getFunction())
// .handlerName("exportEmployeeDeclare4Update")
// .flag(true)
// .bizId(excelExportParam.getBiz())
// .module(excelExportParam.getModule())
// .userId(simpleEmployee.getEmployeeId())
// .tenantKey(simpleEmployee.getTenantKey())
// .operator(simpleEmployee.getUsername())
// .eteamsId(TenantRpcContext.getEteamsId())
// .build();
// return salaryBatchService.simpleExportExcel(exportExcelInfo, Collections.singletonList(excelSheetData));
// }
//
// @BatchExportHandler("exportEmployeeDeclare4Update")
// private void exportEmployeeDeclare4Update() {
// BatchCallbackMessage message = BatchExportContext.getBatchCallbackMessage();
// log.info("导出结束：{}", JsonUtil.toJsonString(message));
// }
//
// @Override
// public XSSFWorkbook export4Fail(EmployeeDeclareFailListQueryParam queryParam) {
// String tenantKey = simpleEmployee.getTenantKey();
// Long currentEmployeeId = simpleEmployee.getEmployeeId();
// // 查询需要报送的人员
// List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).list4FailByParam(queryParam);
// // 转换成dto
// List<EmployeeDeclareFailListDTO> dtos = getEmployeeDeclareService(user).convert2FailListDTO(employeeDeclares);
// // 需要导出的数据
// ExcelSheetData excelSheetData = getExcelSheetData(EmployeeDeclareFailListDTO.class, dtos);
// ExportExcelInfo exportExcelInfo = ExportExcelInfo.builder()
// .fileName(SalaryI18nUtil.getI18nLabel(156428, "人员信息采集本月报送失败") + "-" + SalaryDateUtil.getFormatLocalDate(LocalDateTime.now()))
// .dataType(SalaryI18nUtil.getI18nLabel(156428, "人员信息采集本月报送失败"))
// .function(excelExportParam.getFunction())
// .handlerName("exportEmployeeDeclare4Fail")
// .flag(true)
// .bizId(excelExportParam.getBiz())
// .module(excelExportParam.getModule())
// .userId(simpleEmployee.getEmployeeId())
// .tenantKey(simpleEmployee.getTenantKey())
// .operator(simpleEmployee.getUsername())
// .eteamsId(TenantRpcContext.getEteamsId())
// .build();
// return salaryBatchService.simpleExportExcel(exportExcelInfo, Collections.singletonList(excelSheetData));
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
// public Map<String, Object> importEmployeeDeclare(EmployeeDeclareImportEmployeeParam param) {
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// try {
人员报送导入模板
2023-12-13 17:52:51 +08:00
// Date now = new Date();
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// // 个税扣缴义务人id
人员报送导入模板
2023-12-13 17:52:51 +08:00
// Long taxAgentId = param.getTaxAgentId();
// TaxAgentPO taxAgent = getTaxAgentService(user).getById(taxAgentId);
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// if (taxAgent == null) {
人员报送导入模板
2023-12-13 17:52:51 +08:00
// throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(111111, "参数错误，无法找到个税扣缴义务人"));
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
// // 税款所属期
人员报送导入模板
2023-12-13 17:52:51 +08:00
// Date taxCycle = param.getTaxCycle();
// if (taxCycle == null) {
// throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(111111, "参数错误，税款所属期参数格式错误"));
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
//
人员报送导入模板
2023-12-13 17:52:51 +08:00
// InputStream fileInputStream = null;
// fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(param.getImageId()));
//
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// // 导出模板中的表头
人员报送导入模板
2023-12-13 17:52:51 +08:00
// List<String> headerList = getImportHeader();
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// // 查询所有的人员
人员报送导入模板
2023-12-13 17:52:51 +08:00
// List<DataCollectionEmployee> simpleEmployees = getSalaryEmployeeService(user).listAll(UseEmployeeTypeEnum.ALL);
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// // 查询人员报送表的人员
人员报送导入模板
2023-12-13 17:52:51 +08:00
// List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).listByTaxCycleAndTaxAgentId(taxCycle, taxAgentId);
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// // 校验字段
// String checkType = Util.null2String(paramMap.getOrDefault("checkType", "jobNum"));
人员报送导入模板
2023-12-13 17:52:51 +08:00
// Map<String, DataCollectionEmployee> simpleEmployeeMap = Maps.newHashMap();
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// Map<String, EmployeeDeclarePO> employeeDeclareMap = Maps.newHashMapWithExpectedSize(employeeDeclares.size());
// if (Objects.equals(checkType, "jobNum")) {
// simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getJobNum);
// employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getJobNum);
// } else {
// // 查询所有人员的个人信息
人员报送导入模板
2023-12-13 17:52:51 +08:00
// List<EmployeeDeclarePO> simpleUserInfos = getSalaryEmployeeService(user).listByEmployeeIds(orgEmployeeIds);
// Map<Long, EmployeeDeclarePO> idKeySimpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getId);
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// for (SimpleUserInfo simpleUserInfo : simpleUserInfos) {
// if (idKeySimpleEmployeeMap.containsKey(simpleUserInfo.getEmployeeId())) {
// simpleEmployeeMap.put(simpleUserInfo.getIdNo(), idKeySimpleEmployeeMap.get(simpleUserInfo.getEmployeeId()));
// }
// }
// employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getCardNum);
//
// }
// // 需要新增的报送人员
// List<EmployeeDeclarePO> needAddEmployeeDeclares = Lists.newArrayList();
// // 需要更新的报送人员
// List<EmployeeDeclarePO> needUpdateEmployeeDeclares = Lists.newArrayList();
// // 索引(用于计算进度)
// int index = 0;
// // 失败的数量
人员报送导入模板
2023-12-13 17:52:51 +08:00
// int errorCount = 0;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// // 成功的数量
// int successCount = 0;
// // 错误行的索引
// int failRowIndex = 1;
人员报送导入模板
2023-12-13 17:52:51 +08:00
// // 错误提示
// List<Map<String, String>> excelComments = new ArrayList<>();
// // 错误excel内容
// List<Map> errorData = new ArrayList<>();
//
// Sheet sheet = ExcelSupport.parseFile(fileInputStream, 0, EXCEL_TYPE_XLSX);
// // 表头
// List<String> headers = ExcelSupport.getSheetHeader(sheet, 0);
//
// // 检查表头
// String isValidHeader = checkHeader(headers, headerList);
// if (StringUtils.isNotBlank(isValidHeader)) {
// Map<String, Object> apidatas = new HashMap<String, Object>();
// apidatas.put("successCount", successCount);
// apidatas.put("errorCount", errorCount);
//
// Map<String, String> errorMessageMap = Maps.newHashMap();
// errorMessageMap.put("message", isValidHeader);
// excelComments.add(errorMessageMap);
// apidatas.put("errorData", excelComments);
// return apidatas;
// }
//
// // 数据
// List<EmployeeDeclareExcelDTO> data = ExcelParseHelper.parse2Map(fileInputStream, EmployeeDeclareExcelDTO.class, 0, 1, 14, "1.xlsx");
// if (CollectionUtils.isEmpty(data)) {
// Map<String, Object> apidatas = new HashMap<String, Object>();
// apidatas.put("successCount", successCount);
// apidatas.put("errorCount", errorCount);
// return apidatas;
// }
//
// for (int i = 0; i < data.size(); i++) {
// EmployeeDeclareExcelDTO employeeDeclareExcelDTO = data.get(i);
//
// employeeDeclareExcelDTO.getEmployeeName()
//
// //筛选导入人员信息可以在人力资源池中匹配到的人员信息
// List<DataCollectionEmployee> employeeSameIds = getSalaryEmployeeService(user).matchImportEmployee(simpleEmployees, userName, deparmentName, mobile, workcode, null);
//
// if (StringUtils.isBlank(userName) && "0".equals(confValue)) {
// //姓名 不能为空
// //错误消息对象
// Map<String, String> errorMessageMap = Maps.newHashMap();
// errorMessageMap.put("message", rowIndex + "姓名不能为空");
// errorData.add(errorMessageMap);
// errorSum += 1;
// } else if (CollectionUtils.isEmpty(employeeSameIds)) {
// Map<String, String> errorMessageMap = Maps.newHashMap();
// errorMessageMap.put("message", rowIndex + "员工信息不存在");
// errorData.add(errorMessageMap);
// errorSum += 1;
// } else if (employeeSameIds.size() > 1) {
// //存在离职和在职状态取在职状态
// employeeSameIds = employeeSameIds.stream()
// .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
// .collect(Collectors.toList());
// if (employeeSameIds.size() != 1) {
// Map<String, String> errorMessageMap = Maps.newHashMap();
// errorMessageMap.put("message", rowIndex + "员工信息不存在或者存在多个员工");
// errorData.add(errorMessageMap);
// errorSum += 1;
// } else {
// Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0).getEmployeeId() : null;
// addUpDeduction.setEmployeeId(employeeId);
// }
// } else {
// Long employeeId = CollectionUtils.isNotEmpty(employeeSameIds) && employeeSameIds.size() == 1 ? employeeSameIds.get(0).getEmployeeId() : null;
// if (employeeId != null && employeeId > 0) {
// addUpDeduction.setEmployeeId(employeeId);
// } else {
// //姓名错误，系统内不存在该姓名
// Map<String, String> errorMessageMap = Maps.newHashMap();
// errorMessageMap.put("message", rowIndex + "姓名错误，系统内不存在该姓名");
// errorData.add(errorMessageMap);
// errorSum += 1;
// }
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
//
//
// // 数据是否存在错误
// boolean isError = false;
// if (StringUtils.equals(employeeDeclareExcelDTO.getJobNum(), SalaryI18nUtil.getI18nLabel(86317, "工号"))) {
// if (StringUtils.isEmpty(employeeDeclareExcelDTO.getJobNum()) ) {
// isError = true;
//
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(136250, "工号不能为空"), failRowIndex, failRowIndex, j, j);
// }
// employeeDeclareExcel.setJobNum(dataValue);
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(85429, "姓名"))) {
// if (StringUtils.isEmpty(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(102838, "姓名不能为空"), failRowIndex, failRowIndex, j, j);
// } else {
// employeeDeclareExcel.setEmployeeName(dataValue);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(105139, "证件类型"))) {
// employeeDeclareExcel.setCardType(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getValue());
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(86318, "证件号码"))) {
// if (StringUtils.isEmpty(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156386, "证件号码不能为空"), failRowIndex, failRowIndex, j, j);
// } else if (!SalaryCardUtil.checkIdNum(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156429, "证件号码格式不正确"), failRowIndex, failRowIndex, j, j);
// } else {
// employeeDeclareExcel.setCardNum(dataValue);
// employeeDeclareExcel.setGender(SalaryCardUtil.judgeGender(dataValue).getValue());
// employeeDeclareExcel.setBirthday(SalaryCardUtil.judgeBirthday(dataValue));
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156394, "人员状态"))) {
// boolean legalDataValue = false;
// for (EmploymentStatusEnum employmentStatusEnum : EmploymentStatusEnum.values()) {
// if (StringUtils.equals(dataValue, employmentStatusEnum.getDefaultLabel())) {
// legalDataValue = true;
// employeeDeclareExcel.setEmploymentStatus(employmentStatusEnum.getValue());
// break;
// }
// }
// if (!legalDataValue) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156430, "人员状态只能填写正常或非正常"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156396, "任职受雇从业类型"))) {
// boolean legalDataValue = false;
// for (EmploymentTypeEnum employmentTypeEnum : EmploymentTypeEnum.values()) {
// if (StringUtils.equals(dataValue, employmentTypeEnum.getDefaultLabel())) {
// legalDataValue = true;
// employeeDeclareExcel.setEmploymentType(employmentTypeEnum.getValue());
// break;
// }
// }
// if (!legalDataValue) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156431, "任职受雇从业类型填写错误"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(187374, "入职年度就业情形"))) {
// employeeDeclareExcel.setEmploymentFirstYear(dataValue);
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(98621, "手机号码"))) {
// if (StringUtils.isEmpty(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(106429, "手机号码不能为空"), failRowIndex, failRowIndex, j, j);
// } else if (!SalaryCardUtil.checkMobile(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160510, "手机号码格式不正确"), failRowIndex, failRowIndex, j, j);
// } else {
// employeeDeclareExcel.setMobile(dataValue);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156409, "任职受雇从业日期"))) {
// if (StringUtils.isEmpty(dataValue)) {
// if (!Objects.equals(employeeDeclareExcel.getEmploymentType(), EmploymentTypeEnum.OTHER.getValue())) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160511, "任职受雇从业类型不为「其他」时，任职受雇从业日期为必填"), failRowIndex, failRowIndex, j, j);
// }
// } else {
// if (!SalaryDateUtil.checkDay(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156432, "日期格式不正确"), failRowIndex, failRowIndex, j, j);
// } else {
// employeeDeclareExcel.setEmploymentDate(LocalDate.parse(dataValue));
// }
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(95228, "离职日期"))) {
// if (StringUtils.isEmpty(dataValue)) {
// if (Objects.equals(employeeDeclareExcel.getEmploymentStatus(), EmploymentStatusEnum.ABNORMAL.getValue())) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160512, "人员状态为非正常时，离职日期必填"), failRowIndex, failRowIndex, j, j);
// }
// } else {
// if (!SalaryDateUtil.checkDay(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156432, "日期格式不正确"), failRowIndex, failRowIndex, j, j);
// } else {
// employeeDeclareExcel.setDismissDate(LocalDate.parse(dataValue));
// }
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156399, "是否残疾"))) {
// if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
// employeeDeclareExcel.setDisability(SalaryOnOffEnum.ON.getValue());
// } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
// employeeDeclareExcel.setDisability(SalaryOnOffEnum.OFF.getValue());
// } else {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156433, "是否残疾只能填写是与否"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156412, "残疾证号"))) {
// if (StringUtils.isEmpty(dataValue)) {
// if (Objects.equals(employeeDeclareExcel.getDisability(), SalaryOnOffEnum.ON.getValue())) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160513, "「是否残疾」填「是」时，残疾证号必填"), failRowIndex, failRowIndex, j, j);
// }
// } else {
// employeeDeclareExcel.setDisabilityCardNo(dataValue);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(187385, "是否烈属"))) {
// if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
// employeeDeclareExcel.setMartyrDependents(SalaryOnOffEnum.ON.getValue());
// } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
// employeeDeclareExcel.setMartyrDependents(SalaryOnOffEnum.OFF.getValue());
// } else {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156433, "是否烈属只能填写是与否"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156413, "烈属证号"))) {
// if (StringUtils.isEmpty(dataValue)) {
// if (Objects.equals(employeeDeclareExcel.getMartyrDependents(), SalaryOnOffEnum.ON.getValue())) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(160514, "「是否烈属」填「是」时，烈属证号必填"), failRowIndex, failRowIndex, j, j);
// }
// } else {
// employeeDeclareExcel.setMartyrDependentsCardNo(dataValue);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156400, "是否孤老"))) {
// if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
// employeeDeclareExcel.setLonelyOld(SalaryOnOffEnum.ON.getValue());
// } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
// employeeDeclareExcel.setLonelyOld(SalaryOnOffEnum.OFF.getValue());
// } else {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156434, "是否孤老只能填写是与否"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156402, "是否扣除减除费用"))) {
// if (StringUtils.equals(dataValue, SalaryOnOffEnum.ON.getDefaultLabel())) {
// employeeDeclareExcel.setDeductExpenses(SalaryOnOffEnum.ON.getValue());
// } else if (StringUtils.equals(dataValue, SalaryOnOffEnum.OFF.getDefaultLabel())) {
// employeeDeclareExcel.setDeductExpenses(SalaryOnOffEnum.OFF.getValue());
// } else {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156435, "是否扣除减除费用只能填写是与否"), failRowIndex, failRowIndex, j, j);
// }
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
// if (!isError) {
// if (StringUtils.equals(checkType, "jobNum")) {
// EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getJobNum());
// if (employeeDeclare == null) {
// ExtEmployeePO extEmployee = extEmployeeMap.get(employeeDeclareExcel.getJobNum());
// SimpleEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getJobNum());
// if (extEmployee == null && simpleEmployee == null) {
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// isError = true;
人员报送导入模板
2023-12-13 17:52:51 +08:00
// String jobNumI18 = SalaryI18nUtil.getI18nLabel(86317, "工号");
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156436, "系统内的人员不存在该工号"), failRowIndex, failRowIndex, headers.indexOf(jobNumI18), headers.indexOf(jobNumI18));
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// } else {
人员报送导入模板
2023-12-13 17:52:51 +08:00
// needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
// employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId));
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
// } else {
// EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO();
// BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare);
// BeanUtils.copyProperties(employeeDeclareExcel, newEmployeeDeclare);
// newEmployeeDeclare.setNewEmployeeInfo(StringUtils.equals(employeeDeclare.toCompareString(), newEmployeeDeclare.toCompareString()) ? 0 : 1)
// .setUpdateTime(now);
// needUpdateEmployeeDeclares.add(newEmployeeDeclare);
// if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
// newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
// newEmployeeDeclare.setDeclareErrorMsg("");
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
// } else {
// EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getCardNum());
// if (employeeDeclare == null) {
// ExtEmployeePO extEmployee = extEmployeeMap.get(employeeDeclareExcel.getCardNum());
// SimpleEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getCardNum());
// if (extEmployee == null && simpleEmployee == null) {
// isError = true;
// String cardNoI18 = SalaryI18nUtil.getI18nLabel(86318, "证件号码");
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156437, "系统内的人员不存在该证件号码"), failRowIndex, failRowIndex, headers.indexOf(cardNoI18), headers.indexOf(cardNoI18));
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// } else {
人员报送导入模板
2023-12-13 17:52:51 +08:00
// needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
// employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId));
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
// } else {
人员报送导入模板
2023-12-13 17:52:51 +08:00
// EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO();
// BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare);
// BeanUtils.copyProperties(employeeDeclareExcel, newEmployeeDeclare);
// newEmployeeDeclare.setNewEmployeeInfo(StringUtils.equals(employeeDeclare.toCompareString(), newEmployeeDeclare.toCompareString()) ? 0 : 1)
// .setUpdateTime(now);
// if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
// newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
// newEmployeeDeclare.setDeclareErrorMsg("");
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
// needUpdateEmployeeDeclares.add(newEmployeeDeclare);
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
// }
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
// if (isError) {
// errorCount++;
// failRowIndex++;
// errorData.add(map);
// continue;
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
// successCount++;
// }
// // 如果sheet包含错误数据
// if (CollectionUtils.isNotEmpty(errorData)) {
// salaryBatchService.createErrorExcelSheet(excelSheet.getHeader(), errorData, excelSheet.getName(), excelComments, errorExcelSheets);
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
//
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// if (CollectionUtils.isNotEmpty(needAddEmployeeDeclares)) {
// getEmployeeDeclareService(user).saveBatch(needAddEmployeeDeclares);
// }
// if (CollectionUtils.isNotEmpty(needUpdateEmployeeDeclares)) {
// getEmployeeDeclareService(user).updateBatchById(needUpdateEmployeeDeclares);
// }
// // 发送导入回调信息
人员报送导入模板
2023-12-13 17:52:51 +08:00
// salaryBatchService.sendImportCallBackInfo(message, successCount, errorCount, errorExcelSheets);
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// } catch (Exception e) {
// log.error("人员报送信息导入失败：{}", e.getMessage(), e);
人员报送导入模板
2023-12-13 17:52:51 +08:00
// salaryBatchService.sendImportCallBackInfo(message, SalaryI18nUtil.getI18nLabel(156438, "人员报送信息导入失败：") + e.getMessage());
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// }
// }
//
// private EmployeeDeclarePO buildEmployeeDeclare(ExtEmployeePO extEmployee,
// EmployeeDeclareExcelDTO employeeDeclareExcel, Long taxAgentId,
人员报送导入模板
2023-12-13 17:52:51 +08:00
// String taxCycle, LocalDateTime now, Long String tenantKey) {
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
// EmployeeDeclarePO employeeDeclare = new EmployeeDeclarePO()
// .setId(IdGenerator.generate())
// .setTaxAgentId(taxAgentId)
// .setTaxCycle(taxCycle)
// .setTenantKey(tenantKey)
// .setCreator(employeeId)
// .setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue())
// .setCreateTime(now)
// .setUpdateTime(now);
// BeanUtils.copyProperties(employeeDeclareExcel, employeeDeclare);
// if (extEmployee != null) {
// employeeDeclare.setEmployeeId(extEmployee.getId())
// .setEmployeeType(EmployeeTypeEnum.EXT_EMPLOYEE.getValue());
// }
// if (simpleEmployee != null) {
// employeeDeclare.setEmployeeId(simpleEmployee.getEmployeeId())
// .setEmployeeType(EmployeeTypeEnum.ORGANIZATION.getValue());
// }
// return employeeDeclare;
// }
人员报送导入模板
2023-12-13 17:52:51 +08:00
private List<Object> getImportHeader() {
List<Object> headers = new ArrayList<>();
导出申报明细
2023-12-08 18:15:56 +08:00
身份证最后一位x转大写
2023-12-13 19:34:10 +08:00
headers.add(SalaryI18nUtil.getI18nLabel(111111, "工号"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "姓名"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "证件类型"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "证件号码"));
外籍人员更新
2024-04-11 18:57:56 +08:00
headers.add(SalaryI18nUtil.getI18nLabel(111111, "国籍"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "性别"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "出生地"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "出生日期"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "状态"));
身份证最后一位x转大写
2023-12-13 19:34:10 +08:00
headers.add(SalaryI18nUtil.getI18nLabel(111111, "手机号码"));
外籍人员更新
2024-04-11 18:57:56 +08:00
headers.add(SalaryI18nUtil.getI18nLabel(111111, "任职受雇从业类型"));
身份证最后一位x转大写
2023-12-13 19:34:10 +08:00
headers.add(SalaryI18nUtil.getI18nLabel(111111, "任职受雇从业日期"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "离职日期"));
外籍人员更新
2024-04-11 18:57:56 +08:00
headers.add(SalaryI18nUtil.getI18nLabel(111111, "首次入境时间"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "预计离境时间"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "涉税事由"));
身份证最后一位x转大写
2023-12-13 19:34:10 +08:00
headers.add(SalaryI18nUtil.getI18nLabel(111111, "是否残疾"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "残疾证号"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "是否烈属"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "烈属证号"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "是否孤老"));
headers.add(SalaryI18nUtil.getI18nLabel(111111, "是否扣除减除费用"));
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
人员报送导入模板
2023-12-13 17:52:51 +08:00
return headers;
}
/**
* 检查表头
*
* @param headers
* @return
*/
private String checkHeader(List<String> headers, List<String> headerList) {
// 缺少的列
List<String> lackHeaders = headerList.stream()
.filter(header -> !headers.contains(header))
.collect(Collectors.toList());
if (CollectionUtils.isNotEmpty(lackHeaders)) {
// 发送导入回调信息
身份证最后一位x转大写
2023-12-13 19:34:10 +08:00
return SalaryI18nUtil.getI18nLabel(111111, "缺少如下列，请检查：") + Joiner.on(",").join((Iterable<?>) lackHeaders);
人员报送导入模板
2023-12-13 17:52:51 +08:00
}
return null;
}
人员报送导出 修复清除离职日期bug
2023-12-06 16:37:42 +08:00
}