qt
/
weaver-hrm-salary
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

人员报送导入模板

This commit is contained in:
钱涛 2023-12-13 17:52:51 +08:00
parent f53922a3ab
commit fa30083d07
11 changed files with 641 additions and 399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
src/com/engine/salary/entity/employeedeclare/dto/EmployeeDeclareExcelDTO.java Normal file
View File

@ -0,0 +1,126 @@
package com.engine.salary.entity.employeedeclare.dto;
import com.engine.salary.annotation.SalaryTable;
import com.engine.salary.annotation.SalaryTableColumn;
import com.engine.salary.annotation.TableTitle;
import com.engine.salary.enums.employeedeclare.DeclareStatusEnum;
import com.engine.salary.enums.salaryaccounting.EmployeeTypeEnum;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.util.Set;
/**
* 人员报送（人员）列表
* <p>Copyright: Copyright (c) 2023</p>
* <p>Company: 泛微软件</p>
*
* @author qiantao
* @version 1.0
**/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
@SalaryTable(pageId = "a4f89287-289scf07669d7a23de0ef8u8s2710oe7")
public class EmployeeDeclareExcelDTO {
// 主键id
private Long id;
// 人员ID
private Long employeeId;
// 人员类型
private EmployeeTypeEnum employeeType;
// 姓名
@SalaryTableColumn(text = "姓名", width = "10%", column = "employeeName")
@TableTitle(title = "姓名", dataIndex = "employeeName", key = "employeeName")
private String employeeName;
// 分部
@SalaryTableColumn(text = "分部", width = "10%", column = "subCompanyName")
@TableTitle(title = "分部", dataIndex = "subCompanyName", key = "subCompanyName")
private String subCompanyName;
// 部门
@SalaryTableColumn(text = "部门", width = "10%", column = "departmentName")
@TableTitle(title = "部门", dataIndex = "departmentName", key = "departmentName")
private String departmentName;
// 个税扣缴义务人
@SalaryTableColumn(text = "个税扣缴义务人", width = "10%", column = "taxAgentName")
@TableTitle(title = "个税扣缴义务人", dataIndex = "taxAgentName", key = "taxAgentName")
private String taxAgentName;
// 工号
@SalaryTableColumn(text = "工号", width = "10%", column = "jobNum")
@TableTitle(title = "工号", dataIndex = "jobNum", key = "jobNum")
private String jobNum;
// 证件类型
@SalaryTableColumn(text = "证件类型", width = "10%", column = "cardType")
@TableTitle(title = "证件类型", dataIndex = "cardType", key = "cardType")
private String cardType;
// 证件号码
@SalaryTableColumn(text = "证件号码", width = "10%", column = "cardNum")
@TableTitle(title = "证件号码", dataIndex = "cardNum", key = "cardNum")
private String cardNum;
// 性别
@SalaryTableColumn(text = "性别", width = "10%", column = "gender")
@TableTitle(title = "性别", dataIndex = "gender", key = "gender")
private String gender;
// 出生日期
@SalaryTableColumn(text = "出生日期", width = "10%", column = "birthday")
@TableTitle(title = "出生日期", dataIndex = "birthday", key = "birthday")
private String birthday;
// 人员状态
@SalaryTableColumn(text = "人员状态", width = "10%", column = "employmentStatus")
@TableTitle(title = "人员状态", dataIndex = "employmentStatus", key = "employmentStatus")
private String employmentStatus;
// 手机号码
@SalaryTableColumn(text = "手机号码", width = "10%", column = "mobile")
@TableTitle(title = "手机号码", dataIndex = "mobile", key = "mobile")
private String mobile;
// 任职受雇从业类型
@SalaryTableColumn(text = "任职受雇从业类型", width = "10%", column = "employmentType")
@TableTitle(title = "任职受雇从业类型", dataIndex = "employmentType", key = "employmentType")
private String employmentType;
// 任职受雇从业日期
@SalaryTableColumn(text = "任职受雇从业日期", width = "10%", column = "employmentDate")
@TableTitle(title = "任职受雇从业日期", dataIndex = "employmentDate", key = "employmentDate")
private String employmentDate;
// 离职日期
@SalaryTableColumn(text = "离职日期", width = "10%", column = "dismissDate")
@TableTitle(title = "离职日期", dataIndex = "dismissDate", key = "dismissDate")
private String dismissDate;
// 申报状态
private DeclareStatusEnum declareStatus;
// 申报状态
@SalaryTableColumn(text = "申报状态", width = "10%", column = "declareStatusDesc")
@TableTitle(title = "申报状态", dataIndex = "declareStatusDesc", key = "declareStatusDesc")
private String declareStatusDesc;
// 申报失败原因
private String declareErrorMsg;
// 编辑过的字段
private Set<String> updatedDataIndexSet;
}

30
src/com/engine/salary/entity/employeedeclare/param/EmployeeDeclareImportEmployeeParam.java Normal file
View File

@ -0,0 +1,30 @@
package com.engine.salary.entity.employeedeclare.param;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 人员报送（人员）导入参数
* <p>Copyright: Copyright (c) 2023</p>
* <p>Company: 泛微软件</p>
*
* @author qiantao
* @version 1.0
**/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class EmployeeDeclareImportEmployeeParam {
//上传文件id
String imageId;
Long taxAgentId;
Date taxCycle;
}

18
src/com/engine/salary/entity/employeedeclare/param/EmployeeDeclareImportParam.java Normal file
View File

@ -0,0 +1,18 @@
package com.engine.salary.entity.employeedeclare.param;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* @description: 人员报送导入参数
* @author: xiajun
* @modified By: xiajun
* @date: Created in 2022/11/21 4:58 PM
* @version:v1.0
*/
@Data
public class EmployeeDeclareImportParam extends EmployeeDeclareListQueryParam {
@ApiModelProperty("是否导出现有数据")
private String exportData;
}

3
src/com/engine/salary/service/EmployeeDeclareExcelService.java
View File

@ -1,5 +1,6 @@
package com.engine.salary.service; package com.engine.salary.service;
import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareImportParam;
import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareListQueryParam; import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareListQueryParam;
import org.apache.poi.xssf.usermodel.XSSFWorkbook; import org.apache.poi.xssf.usermodel.XSSFWorkbook;
@ -18,7 +19,7 @@ public interface EmployeeDeclareExcelService {
* @param importParam * @param importParam
* @return * @return
*/ */
// Map<String, Object> exportTemplate(EmployeeDeclareImportParam importParam); XSSFWorkbook exportTemplate(EmployeeDeclareImportParam importParam);
/** /**
* 导出人员信息采集-全部 * 导出人员信息采集-全部

795
src/com/engine/salary/service/impl/EmployeeDeclareExcelServiceImpl.java
View File

@ -3,33 +3,50 @@ package com.engine.salary.service.impl;
import com.engine.common.util.ServiceUtil; import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service; import com.engine.core.impl.Service;
import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareListDTO; import com.engine.salary.entity.employeedeclare.dto.EmployeeDeclareListDTO;
import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareImportParam;
import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareListQueryParam; import com.engine.salary.entity.employeedeclare.param.EmployeeDeclareListQueryParam;
import com.engine.salary.entity.employeedeclare.po.EmployeeDeclarePO; import com.engine.salary.entity.employeedeclare.po.EmployeeDeclarePO;
import com.engine.salary.enums.employeedeclare.CardTypeEnum;
import com.engine.salary.enums.employeedeclare.EmploymentStatusEnum;
import com.engine.salary.enums.employeedeclare.EmploymentTypeEnum;
import com.engine.salary.service.EmployeeDeclareExcelService; import com.engine.salary.service.EmployeeDeclareExcelService;
import com.engine.salary.service.EmployeeDeclareService; import com.engine.salary.service.EmployeeDeclareService;
import com.engine.salary.service.SalaryEmployeeService; import com.engine.salary.service.SalaryEmployeeService;
import com.engine.salary.service.TaxAgentService; import com.engine.salary.service.TaxAgentService;
import com.engine.salary.util.SalaryEnumUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.excel.ExcelSheetData;
import com.engine.salary.util.excel.ExcelUtil; import com.engine.salary.util.excel.ExcelUtil;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook; import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import weaver.general.Util;
import weaver.hrm.User; import weaver.hrm.User;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
/** /**
* @description: 人员报送（人员）导入导出 * 人员报送（人员）导入导出
* @author: xiajun * <p>Copyright: Copyright (c) 2023</p>
* @modified By: xiajun * <p>Company: 泛微软件</p>
* @date: Created in 9/7/22 5:39 PM *
* @version:v1.0 * @author qiantao
*/ * @version 1.0
**/
@Slf4j @Slf4j
public class EmployeeDeclareExcelServiceImpl extends Service implements EmployeeDeclareExcelService { public class EmployeeDeclareExcelServiceImpl extends Service implements EmployeeDeclareExcelService {
private EmployeeDeclareService getEmployeeDeclareService(User user) { private EmployeeDeclareService getEmployeeDeclareService(User user) {
return ServiceUtil.getService(EmployeeDeclareServiceImpl.class, user); return ServiceUtil.getService(EmployeeDeclareServiceImpl.class, user);
} }
private SalaryEmployeeService getSalaryEmployeeService(User user) { private SalaryEmployeeService getSalaryEmployeeService(User user) {
return ServiceUtil.getService(SalaryEmployeeServiceImpl.class, user); return ServiceUtil.getService(SalaryEmployeeServiceImpl.class, user);
} }
@ -39,67 +56,45 @@ public class EmployeeDeclareExcelServiceImpl extends Service implements Employee
return ServiceUtil.getService(TaxAgentServiceImpl.class, user); return ServiceUtil.getService(TaxAgentServiceImpl.class, user);
} }
// @Override @Override
// public Map<String, Object> exportTemplate( EmployeeDeclareImportParam importParam) { public XSSFWorkbook exportTemplate(EmployeeDeclareImportParam importParam) {
// String tenantKey = simpleEmployee.getTenantKey(); // 查询人员
// Long currentEmployeeId = simpleEmployee.getEmployeeId(); List<EmployeeDeclarePO> employeeDeclares = Collections.emptyList();
// // 查询人员 if (StringUtils.equalsIgnoreCase(importParam.getExportData(), "true")) {
// List<EmployeeDeclarePO> employeeDeclares = Collections.emptyList(); employeeDeclares = getEmployeeDeclareService(user).listByParam(importParam);
// if (StringUtils.equalsIgnoreCase(importParam.getExportData(), "true")) { }
// employeeDeclares = getEmployeeDeclareService(user).listByParam(importParam); String yesI18 = SalaryI18nUtil.getI18nLabel(84967, "是");
// } String noI18 = SalaryI18nUtil.getI18nLabel(84968, "否");
// String yesI18 = SalaryI18nUtil.getI18nLabel( 84967, "是"); List<List<Object>> rows = Lists.newArrayList();
// String noI18 = SalaryI18nUtil.getI18nLabel( 84968, "否"); for (EmployeeDeclarePO employeeDeclare : employeeDeclares) {
// List<List<Object>> rows = Lists.newArrayList(); EmploymentStatusEnum employmentStatusEnum = SalaryEnumUtil.enumMatchByValue(employeeDeclare.getEmploymentStatus(), EmploymentStatusEnum.class);
// for (EmployeeDeclarePO employeeDeclare : employeeDeclares) { EmploymentTypeEnum employmentTypeEnum = SalaryEnumUtil.enumMatchByValue(employeeDeclare.getEmploymentType(), EmploymentTypeEnum.class);
// EmploymentStatusEnum employmentStatusEnum = SalaryEnumUtil.enumMatchByValue(employeeDeclare.getEmploymentStatus(), EmploymentStatusEnum.class); List<Object> row = Lists.newArrayList();
// EmploymentTypeEnum employmentTypeEnum = SalaryEnumUtil.enumMatchByValue(employeeDeclare.getEmploymentType(), EmploymentTypeEnum.class); row.add(employeeDeclare.getJobNum());
// List<Object> row = Lists.newArrayList(); row.add(employeeDeclare.getEmployeeName());
// row.add(employeeDeclare.getJobNum()); row.add(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getDefaultLabel());
// row.add(employeeDeclare.getEmployeeName()); row.add(employeeDeclare.getCardNum());
// row.add(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getDefaultLabel()); row.add(employmentStatusEnum == null ? "" : employmentStatusEnum.getDefaultLabel());
// row.add(employeeDeclare.getCardNum()); row.add(employmentTypeEnum == null ? "" : employmentTypeEnum.getDefaultLabel());
// row.add(employmentStatusEnum == null ? "" : employmentStatusEnum.getDefaultLabel()); row.add(employeeDeclare.getEmploymentFirstYear());
// row.add(employmentTypeEnum == null ? "" : employmentTypeEnum.getDefaultLabel()); row.add(employeeDeclare.getMobile());
// row.add(employeeDeclare.getEmploymentFirstYear()); row.add(Util.null2String(employeeDeclare.getEmploymentDate()));
// row.add(employeeDeclare.getMobile()); row.add(Util.null2String(employeeDeclare.getDismissDate()));
// row.add(Util.null2String(employeeDeclare.getEmploymentDate())); row.add(Objects.equals(employeeDeclare.getDisability(), 1) ? yesI18 : noI18);
// row.add(Util.null2String(employeeDeclare.getDismissDate())); row.add(employeeDeclare.getDisabilityCardNo());
// row.add(Objects.equals(employeeDeclare.getDisability(), 1) ? yesI18 : noI18); row.add(Objects.equals(employeeDeclare.getMartyrDependents(), 1) ? yesI18 : noI18);
// row.add(employeeDeclare.getDisabilityCardNo()); row.add(employeeDeclare.getMartyrDependentsCardNo());
// row.add(Objects.equals(employeeDeclare.getMartyrDependents(), 1) ? yesI18 : noI18); row.add(Objects.equals(employeeDeclare.getLonelyOld(), 1) ? yesI18 : noI18);
// row.add(employeeDeclare.getMartyrDependentsCardNo()); row.add(Objects.equals(employeeDeclare.getDeductExpenses(), 1) ? yesI18 : noI18);
// row.add(Objects.equals(employeeDeclare.getLonelyOld(), 1) ? yesI18 : noI18); rows.add(row);
// row.add(Objects.equals(employeeDeclare.getDeductExpenses(), 1) ? yesI18 : noI18); }
// rows.add(row); // 组装excel导出数据
// } ExcelSheetData excelSheetData = new ExcelSheetData();
// // 组装excel导出数据 excelSheetData.setSheetName(SalaryI18nUtil.getI18nLabel(156425, "人员信息采集"));
// String[] headers = getImportHeader(currentEmployeeId, tenantKey).toArray(new String[0]); excelSheetData.setHeaders(getImportHeader());
// ExcelSheetData excelSheetData = new ExcelSheetData(); excelSheetData.setRows(rows);
// excelSheetData.setSheetName(SalaryI18nUtil.getI18nLabel( 156425, "人员信息采集")); return ExcelUtil.genWorkbook(excelSheetData);
// excelSheetData.setHeaders(Collections.singletonList(headers)); }
// excelSheetData.setRows(rows);
// ExportExcelInfo exportExcelInfo = ExportExcelInfo.builder()
// .fileName(SalaryI18nUtil.getI18nLabel( 156424, "人员信息采集导入模板") + "-" + SalaryDateUtil.getFormatLocalDate(LocalDateTime.now()))
// .dataType(SalaryI18nUtil.getI18nLabel( 156424, "人员信息采集导入模板"))
// .function(excelExportParam.getFunction())
// .handlerName("exportEmployeeDeclareTemplate")
// .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("exportEmployeeDeclareTemplate")
// private void exportEmployeeDeclareTemplate() {
// BatchCallbackMessage message = BatchExportContext.getBatchCallbackMessage();
// log.info("导出结束：{}", JsonUtil.toJsonString(message));
// }
@Override @Override
public XSSFWorkbook export(EmployeeDeclareListQueryParam queryParam) { public XSSFWorkbook export(EmployeeDeclareListQueryParam queryParam) {
@ -206,59 +201,46 @@ public class EmployeeDeclareExcelServiceImpl extends Service implements Employee
// } // }
// // public Map<String, Object> importEmployeeDeclare(EmployeeDeclareImportEmployeeParam param) {
// @Transactional(rollbackFor = Exception.class)
// @BatchImportHandler("importEmployeeDeclare")
// public void importEmployeeDeclare() {
// BatchDocumentMessage message = BatchImportContext.getBatchDocumentMessage();
// Long employeeId = message.getUserId();
// String tenantKey = message.getTenantKey();
// try { // try {
// LocalDateTime now = LocalDateTime.now(); // Date now = new Date();
// Map<String, Object> paramMap = JsonUtil.parseMap(message.getUploadSet().getCustomData(), Object.class);
// // 个税扣缴义务人id // // 个税扣缴义务人id
// Long taxAgentId = Util.getLongValue(Util.null2String(paramMap.get("taxAgentId"))); // Long taxAgentId = param.getTaxAgentId();
// TaxAgentPO taxAgent = getTaxAgentService(user).getById(taxAgentId, employeeId, tenantKey); // TaxAgentPO taxAgent = getTaxAgentService(user).getById(taxAgentId);
// if (taxAgent == null) { // if (taxAgent == null) {
// salaryBatchService.sendImportCallBackInfo(message, SalaryI18nUtil.getI18nLabel(employeeId, 187469, "参数错误，无法找到个税扣缴义务人")); // throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(111111, "参数错误，无法找到个税扣缴义务人"));
// return;
// } // }
// // 税款所属期 // // 税款所属期
// String taxCycle = Util.null2String(paramMap.get("taxCycle")); // Date taxCycle = param.getTaxCycle();
// if (!SalaryDateUtil.checkYearMonth(taxCycle)) { // if (taxCycle == null) {
// salaryBatchService.sendImportCallBackInfo(message, SalaryI18nUtil.getI18nLabel(employeeId, 156384, "参数错误，税款所属期参数格式错误")); // throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(111111, "参数错误，税款所属期参数格式错误"));
// return;
// } // }
// //
// InputStream fileInputStream = null;
// fileInputStream = ImageFileManager.getInputStreamById(Integer.parseInt(param.getImageId()));
//
// // 导出模板中的表头 // // 导出模板中的表头
// List<String> headerList = getImportHeader(employeeId, tenantKey); // List<String> headerList = getImportHeader();
// // 查询所有的人员 // // 查询所有的人员
// List<Long> orgEmployeeIds = hrmCommonEmployeeService.getAllEmployee(tenantKey); // List<DataCollectionEmployee> simpleEmployees = getSalaryEmployeeService(user).listAll(UseEmployeeTypeEnum.ALL);
// List<SimpleEmployee> simpleEmployees = hrmCommonEmployeeService.getEmployeeByIds(orgEmployeeIds, tenantKey);
// // 查询所有的外部人员
// List<ExtEmployeePO> extEmployees = extEmployeeService.listAll(tenantKey);
// // 查询人员报送表的人员 // // 查询人员报送表的人员
// List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).listByTaxCycleAndTaxAgentId(YearMonth.parse(taxCycle), // List<EmployeeDeclarePO> employeeDeclares = getEmployeeDeclareService(user).listByTaxCycleAndTaxAgentId(taxCycle, taxAgentId);
// taxAgentId, tenantKey);
// // 校验字段 // // 校验字段
// String checkType = Util.null2String(paramMap.getOrDefault("checkType", "jobNum")); // String checkType = Util.null2String(paramMap.getOrDefault("checkType", "jobNum"));
// Map<String, ExtEmployeePO> extEmployeeMap = Maps.newHashMap(); // Map<String, DataCollectionEmployee> simpleEmployeeMap = Maps.newHashMap();
// Map<String, SimpleEmployee> simpleEmployeeMap = Maps.newHashMap();
// Map<String, EmployeeDeclarePO> employeeDeclareMap = Maps.newHashMapWithExpectedSize(employeeDeclares.size()); // Map<String, EmployeeDeclarePO> employeeDeclareMap = Maps.newHashMapWithExpectedSize(employeeDeclares.size());
// if (Objects.equals(checkType, "jobNum")) { // if (Objects.equals(checkType, "jobNum")) {
// extEmployeeMap = Collections.emptyMap();
// simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getJobNum); // simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getJobNum);
// employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getJobNum); // employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getJobNum);
// } else { // } else {
// // 查询所有人员的个人信息 // // 查询所有人员的个人信息
// List<SimpleUserInfo> simpleUserInfos = getSalaryEmployeeService(user).listByEmployeeIds(orgEmployeeIds, tenantKey); // List<EmployeeDeclarePO> simpleUserInfos = getSalaryEmployeeService(user).listByEmployeeIds(orgEmployeeIds);
// Map<Long, SimpleEmployee> idKeySimpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getId); // Map<Long, EmployeeDeclarePO> idKeySimpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getId);
// for (SimpleUserInfo simpleUserInfo : simpleUserInfos) { // for (SimpleUserInfo simpleUserInfo : simpleUserInfos) {
// if (idKeySimpleEmployeeMap.containsKey(simpleUserInfo.getEmployeeId())) { // if (idKeySimpleEmployeeMap.containsKey(simpleUserInfo.getEmployeeId())) {
// simpleEmployeeMap.put(simpleUserInfo.getIdNo(), idKeySimpleEmployeeMap.get(simpleUserInfo.getEmployeeId())); // simpleEmployeeMap.put(simpleUserInfo.getIdNo(), idKeySimpleEmployeeMap.get(simpleUserInfo.getEmployeeId()));
// } // }
// } // }
// extEmployeeMap = SalaryEntityUtil.convert2Map(extEmployees, ExtEmployeePO::getCardNum);
// employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getCardNum); // employeeDeclareMap = SalaryEntityUtil.convert2Map(employeeDeclares, EmployeeDeclarePO::getCardNum);
// //
// } // }
@ -269,263 +251,308 @@ public class EmployeeDeclareExcelServiceImpl extends Service implements Employee
// // 索引(用于计算进度) // // 索引(用于计算进度)
// int index = 0; // int index = 0;
// // 失败的数量 // // 失败的数量
// int failCount = 0; // int errorCount = 0;
// // 成功的数量 // // 成功的数量
// int successCount = 0; // int successCount = 0;
// // 错误行的索引 // // 错误行的索引
// int failRowIndex = 1; // int failRowIndex = 1;
// // 包含错误提示信息的sheet页 // // 错误提示
// List<ExcelSheet> errorExcelSheets = Lists.newArrayList(); // List<Map<String, String>> excelComments = new ArrayList<>();
// for (ExcelSheet excelSheet : message.getBatchFile().getExcelSheets()) { // // 错误excel内容
// if (CollectionUtils.isEmpty(excelSheet.getHeader())) { // List<Map> errorData = new ArrayList<>();
// continue; //
// 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;
// }
// } // }
// // 表头 //
// List<String> headers = excelSheet.getHeader().stream() //
// .map(m -> Util.null2String(m.get("key"))) // // 数据是否存在错误
// .collect(Collectors.toList()); // boolean isError = false;
// // 检查表头 // if (StringUtils.equals(employeeDeclareExcelDTO.getJobNum(), SalaryI18nUtil.getI18nLabel(86317, "工号"))) {
// boolean isCorrectHeader = checkHeader(message, headers, headerList); // if (StringUtils.isEmpty(employeeDeclareExcelDTO.getJobNum()) ) {
// if (!isCorrectHeader) { // isError = true;
// return; //
// } // salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(136250, "工号不能为空"), failRowIndex, failRowIndex, j, j);
// // 表头每一列的位置 // }
// Map<String, Integer> columnIndexMap = Maps.newHashMap(); // employeeDeclareExcel.setJobNum(dataValue);
// for (int i = 0; i < headers.size(); i++) { // } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(85429, "姓名"))) {
// columnIndexMap.put(headers.get(i), i); // if (StringUtils.isEmpty(dataValue)) {
// } // isError = true;
// // 数据 // salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(102838, "姓名不能为空"), failRowIndex, failRowIndex, j, j);
// List<Map<String, Object>> data = excelSheet.getData(); // } else {
// if (CollectionUtils.isEmpty(data)) { // employeeDeclareExcel.setEmployeeName(dataValue);
// continue; // }
// } // } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(105139, "证件类型"))) {
// // 错误提示信息 // employeeDeclareExcel.setCardType(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getValue());
// List<ExcelComment> excelComments = Lists.newArrayList(); // } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(86318, "证件号码"))) {
// // 存在错误的那行数据 // if (StringUtils.isEmpty(dataValue)) {
// List<Map<String, Object>> errorData = Lists.newArrayList(); // isError = true;
// for (int i = 0; i < data.size(); i++) { // salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156386, "证件号码不能为空"), failRowIndex, failRowIndex, j, j);
// Map<String, Object> map = data.get(i); // } else if (!SalaryCardUtil.checkIdNum(dataValue)) {
// // 数据是否存在错误 // isError = true;
// boolean isError = false; // salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156429, "证件号码格式不正确"), failRowIndex, failRowIndex, j, j);
// EmployeeDeclareExcelDTO employeeDeclareExcel = new EmployeeDeclareExcelDTO(); // } else {
// for (String dataKey : getImportHeader(employeeId, tenantKey)) { // employeeDeclareExcel.setCardNum(dataValue);
// Integer j = columnIndexMap.get(dataKey); // employeeDeclareExcel.setGender(SalaryCardUtil.judgeGender(dataValue).getValue());
// String dataValue = Util.null2String(map.get(dataKey)); // employeeDeclareExcel.setBirthday(SalaryCardUtil.judgeBirthday(dataValue));
// if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 86317, "工号"))) { // }
// if (StringUtils.equals(checkType, "jobNum") && StringUtils.isEmpty(dataValue)) { // } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156394, "人员状态"))) {
// isError = true; // boolean legalDataValue = false;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 136250, "工号不能为空"), failRowIndex, failRowIndex, j, j); // for (EmploymentStatusEnum employmentStatusEnum : EmploymentStatusEnum.values()) {
// } // if (StringUtils.equals(dataValue, employmentStatusEnum.getDefaultLabel())) {
// employeeDeclareExcel.setJobNum(dataValue); // legalDataValue = true;
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 85429, "姓名"))) { // employeeDeclareExcel.setEmploymentStatus(employmentStatusEnum.getValue());
// if (StringUtils.isEmpty(dataValue)) { // break;
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 102838, "姓名不能为空"), failRowIndex, failRowIndex, j, j);
// } else {
// employeeDeclareExcel.setEmployeeName(dataValue);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 105139, "证件类型"))) {
// employeeDeclareExcel.setCardType(CardTypeEnum.RESIDENT_IDENTITY_CARDS.getValue());
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 86318, "证件号码"))) {
// if (StringUtils.isEmpty(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156386, "证件号码不能为空"), failRowIndex, failRowIndex, j, j);
// } else if (!SalaryCardUtil.checkIdNum(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 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(employeeId, 156430, "人员状态只能填写正常或非正常"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 156431, "任职受雇从业类型填写错误"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 187374, "入职年度就业情形"))) {
// employeeDeclareExcel.setEmploymentFirstYear(dataValue);
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 98621, "手机号码"))) {
// if (StringUtils.isEmpty(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 106429, "手机号码不能为空"), failRowIndex, failRowIndex, j, j);
// } else if (!SalaryCardUtil.checkMobile(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160510, "手机号码格式不正确"), failRowIndex, failRowIndex, j, j);
// } else {
// employeeDeclareExcel.setMobile(dataValue);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 156409, "任职受雇从业日期"))) {
// if (StringUtils.isEmpty(dataValue)) {
// if (!Objects.equals(employeeDeclareExcel.getEmploymentType(), EmploymentTypeEnum.OTHER.getValue())) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160511, "任职受雇从业类型不为「其他」时，任职受雇从业日期为必填"), failRowIndex, failRowIndex, j, j);
// }
// } else {
// if (!SalaryDateUtil.checkDay(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156432, "日期格式不正确"), failRowIndex, failRowIndex, j, j);
// } else {
// employeeDeclareExcel.setEmploymentDate(LocalDate.parse(dataValue));
// }
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 95228, "离职日期"))) {
// if (StringUtils.isEmpty(dataValue)) {
// if (Objects.equals(employeeDeclareExcel.getEmploymentStatus(), EmploymentStatusEnum.ABNORMAL.getValue())) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160512, "人员状态为非正常时，离职日期必填"), failRowIndex, failRowIndex, j, j);
// }
// } else {
// if (!SalaryDateUtil.checkDay(dataValue)) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156432, "日期格式不正确"), failRowIndex, failRowIndex, j, j);
// } else {
// employeeDeclareExcel.setDismissDate(LocalDate.parse(dataValue));
// }
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 156433, "是否残疾只能填写是与否"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 156412, "残疾证号"))) {
// if (StringUtils.isEmpty(dataValue)) {
// if (Objects.equals(employeeDeclareExcel.getDisability(), SalaryOnOffEnum.ON.getValue())) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160513, "「是否残疾」填「是」时，残疾证号必填"), failRowIndex, failRowIndex, j, j);
// }
// } else {
// employeeDeclareExcel.setDisabilityCardNo(dataValue);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 156433, "是否烈属只能填写是与否"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 156413, "烈属证号"))) {
// if (StringUtils.isEmpty(dataValue)) {
// if (Objects.equals(employeeDeclareExcel.getMartyrDependents(), SalaryOnOffEnum.ON.getValue())) {
// isError = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 160514, "「是否烈属」填「是」时，烈属证号必填"), failRowIndex, failRowIndex, j, j);
// }
// } else {
// employeeDeclareExcel.setMartyrDependentsCardNo(dataValue);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 156434, "是否孤老只能填写是与否"), failRowIndex, failRowIndex, j, j);
// }
// } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(employeeId, 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(employeeId, 156435, "是否扣除减除费用只能填写是与否"), failRowIndex, failRowIndex, j, j);
// }
// } // }
// } // }
// if (!isError) { // if (!legalDataValue) {
// if (StringUtils.equals(checkType, "jobNum")) { // isError = true;
// EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getJobNum()); // salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156430, "人员状态只能填写正常或非正常"), failRowIndex, failRowIndex, j, j);
// if (employeeDeclare == null) { // }
// ExtEmployeePO extEmployee = extEmployeeMap.get(employeeDeclareExcel.getJobNum()); // } else if (StringUtils.equals(dataKey, SalaryI18nUtil.getI18nLabel(156396, "任职受雇从业类型"))) {
// SimpleEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getJobNum()); // boolean legalDataValue = false;
// if (extEmployee == null && simpleEmployee == null) { // for (EmploymentTypeEnum employmentTypeEnum : EmploymentTypeEnum.values()) {
// isError = true; // if (StringUtils.equals(dataValue, employmentTypeEnum.getDefaultLabel())) {
// String jobNumI18 = SalaryI18nUtil.getI18nLabel(employeeId, 86317, "工号"); // legalDataValue = true;
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156436, "系统内的人员不存在该工号"), failRowIndex, failRowIndex, headers.indexOf(jobNumI18), headers.indexOf(jobNumI18)); // employeeDeclareExcel.setEmploymentType(employmentTypeEnum.getValue());
// } else { // break;
// needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee, // }
// employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId, tenantKey)); // }
// } // 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);
// }
// }
// 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) {
// isError = true;
// String jobNumI18 = SalaryI18nUtil.getI18nLabel(86317, "工号");
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(156436, "系统内的人员不存在该工号"), failRowIndex, failRowIndex, headers.indexOf(jobNumI18), headers.indexOf(jobNumI18));
// } else { // } else {
// EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO(); // needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
// BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare); // employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId));
// 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("");
// }
// } // }
// } else { // } else {
// EmployeeDeclarePO employeeDeclare = employeeDeclareMap.get(employeeDeclareExcel.getCardNum()); // EmployeeDeclarePO newEmployeeDeclare = new EmployeeDeclarePO();
// if (employeeDeclare == null) { // BeanUtils.copyProperties(employeeDeclare, newEmployeeDeclare);
// ExtEmployeePO extEmployee = extEmployeeMap.get(employeeDeclareExcel.getCardNum()); // BeanUtils.copyProperties(employeeDeclareExcel, newEmployeeDeclare);
// SimpleEmployee simpleEmployee = simpleEmployeeMap.get(employeeDeclareExcel.getCardNum()); // newEmployeeDeclare.setNewEmployeeInfo(StringUtils.equals(employeeDeclare.toCompareString(), newEmployeeDeclare.toCompareString()) ? 0 : 1)
// if (extEmployee == null && simpleEmployee == null) { // .setUpdateTime(now);
// isError = true; // needUpdateEmployeeDeclares.add(newEmployeeDeclare);
// String cardNoI18 = SalaryI18nUtil.getI18nLabel(employeeId, 86318, "证件号码"); // if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
// salaryBatchService.createExcelComment(excelComments, SalaryI18nUtil.getI18nLabel(employeeId, 156437, "系统内的人员不存在该证件号码"), failRowIndex, failRowIndex, headers.indexOf(cardNoI18), headers.indexOf(cardNoI18)); // newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
// } else { // newEmployeeDeclare.setDeclareErrorMsg("");
// needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
// employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId, tenantKey));
// }
// } 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);
// if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
// newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
// newEmployeeDeclare.setDeclareErrorMsg("");
// }
// needUpdateEmployeeDeclares.add(newEmployeeDeclare);
// } // }
// } // }
// } 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));
// } else {
// needAddEmployeeDeclares.add(buildEmployeeDeclare(extEmployee, simpleEmployee,
// employeeDeclareExcel, taxAgentId, taxCycle, now, employeeId));
// }
// } 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);
// if (Objects.equals(newEmployeeDeclare.getNewEmployeeInfo(), 1)) {
// newEmployeeDeclare.setDeclareStatus(DeclareStatusEnum.NOT_DECLARE.getValue());
// newEmployeeDeclare.setDeclareErrorMsg("");
// }
// needUpdateEmployeeDeclares.add(newEmployeeDeclare);
// }
// } // }
// if (isError) {
// failCount++;
// failRowIndex++;
// errorData.add(map);
// continue;
// }
// successCount++;
// } // }
// // 如果sheet包含错误数据 // if (isError) {
// if (CollectionUtils.isNotEmpty(errorData)) { // errorCount++;
// salaryBatchService.createErrorExcelSheet(excelSheet.getHeader(), errorData, excelSheet.getName(), excelComments, errorExcelSheets); // failRowIndex++;
// errorData.add(map);
// continue;
// } // }
// successCount++;
// } // }
// // 如果sheet包含错误数据
// if (CollectionUtils.isNotEmpty(errorData)) {
// salaryBatchService.createErrorExcelSheet(excelSheet.getHeader(), errorData, excelSheet.getName(), excelComments, errorExcelSheets);
// }
//
// if (CollectionUtils.isNotEmpty(needAddEmployeeDeclares)) { // if (CollectionUtils.isNotEmpty(needAddEmployeeDeclares)) {
// getEmployeeDeclareService(user).saveBatch(needAddEmployeeDeclares); // getEmployeeDeclareService(user).saveBatch(needAddEmployeeDeclares);
// } // }
@ -533,16 +560,16 @@ public class EmployeeDeclareExcelServiceImpl extends Service implements Employee
// getEmployeeDeclareService(user).updateBatchById(needUpdateEmployeeDeclares); // getEmployeeDeclareService(user).updateBatchById(needUpdateEmployeeDeclares);
// } // }
// // 发送导入回调信息 // // 发送导入回调信息
// salaryBatchService.sendImportCallBackInfo(message, successCount, failCount, errorExcelSheets); // salaryBatchService.sendImportCallBackInfo(message, successCount, errorCount, errorExcelSheets);
// } catch (Exception e) { // } catch (Exception e) {
// log.error("人员报送信息导入失败：{}", e.getMessage(), e); // log.error("人员报送信息导入失败：{}", e.getMessage(), e);
// salaryBatchService.sendImportCallBackInfo(message, SalaryI18nUtil.getI18nLabel(employeeId, 156438, "人员报送信息导入失败：") + e.getMessage()); // salaryBatchService.sendImportCallBackInfo(message, SalaryI18nUtil.getI18nLabel(156438, "人员报送信息导入失败：") + e.getMessage());
// } // }
// } // }
// //
// private EmployeeDeclarePO buildEmployeeDeclare(ExtEmployeePO extEmployee, // private EmployeeDeclarePO buildEmployeeDeclare(ExtEmployeePO extEmployee,
// EmployeeDeclareExcelDTO employeeDeclareExcel, Long taxAgentId, // EmployeeDeclareExcelDTO employeeDeclareExcel, Long taxAgentId,
// String taxCycle, LocalDateTime now, Long employeeId, String tenantKey) { // String taxCycle, LocalDateTime now, Long String tenantKey) {
// EmployeeDeclarePO employeeDeclare = new EmployeeDeclarePO() // EmployeeDeclarePO employeeDeclare = new EmployeeDeclarePO()
// .setId(IdGenerator.generate()) // .setId(IdGenerator.generate())
// .setTaxAgentId(taxAgentId) // .setTaxAgentId(taxAgentId)
@ -563,49 +590,47 @@ public class EmployeeDeclareExcelServiceImpl extends Service implements Employee
// } // }
// return employeeDeclare; // return employeeDeclare;
// } // }
//
// private List<String> getImportHeader(Long employeeId, String tenantKey) { private List<Object> getImportHeader() {
// return Lists.newArrayList( List<Object> headers = new ArrayList<>();
// SalaryI18nUtil.getI18nLabel(employeeId, 86317, "工号"),
// SalaryI18nUtil.getI18nLabel(employeeId, 85429, "姓名"), headers.add(SalaryI18nUtil.getI18nLabel(86317, "工号"));
// SalaryI18nUtil.getI18nLabel(employeeId, 105139, "证件类型"), headers.add(SalaryI18nUtil.getI18nLabel(85429, "姓名"));
// SalaryI18nUtil.getI18nLabel(employeeId, 86318, "证件号码"), headers.add(SalaryI18nUtil.getI18nLabel(105139, "证件类型"));
// SalaryI18nUtil.getI18nLabel(employeeId, 156394, "人员状态"), headers.add(SalaryI18nUtil.getI18nLabel(86318, "证件号码"));
// SalaryI18nUtil.getI18nLabel(employeeId, 156396, "任职受雇从业类型"), headers.add(SalaryI18nUtil.getI18nLabel(156394, "人员状态"));
// SalaryI18nUtil.getI18nLabel(employeeId, 187374, "入职年度就业情形"), headers.add(SalaryI18nUtil.getI18nLabel(156396, "任职受雇从业类型"));
// SalaryI18nUtil.getI18nLabel(employeeId, 98621, "手机号码"), headers.add(SalaryI18nUtil.getI18nLabel(187374, "入职年度就业情形"));
// SalaryI18nUtil.getI18nLabel(employeeId, 156409, "任职受雇从业日期"), headers.add(SalaryI18nUtil.getI18nLabel(98621, "手机号码"));
// SalaryI18nUtil.getI18nLabel(employeeId, 95228, "离职日期"), headers.add(SalaryI18nUtil.getI18nLabel(156409, "任职受雇从业日期"));
// SalaryI18nUtil.getI18nLabel(employeeId, 156399, "是否残疾"), headers.add(SalaryI18nUtil.getI18nLabel(95228, "离职日期"));
// SalaryI18nUtil.getI18nLabel(employeeId, 156412, "残疾证号"), headers.add(SalaryI18nUtil.getI18nLabel(156399, "是否残疾"));
// SalaryI18nUtil.getI18nLabel(employeeId, 187385, "是否烈属"), headers.add(SalaryI18nUtil.getI18nLabel(156412, "残疾证号"));
// SalaryI18nUtil.getI18nLabel(employeeId, 156413, "烈属证号"), headers.add(SalaryI18nUtil.getI18nLabel(187385, "是否烈属"));
// SalaryI18nUtil.getI18nLabel(employeeId, 156400, "是否孤老"), headers.add(SalaryI18nUtil.getI18nLabel(156413, "烈属证号"));
// SalaryI18nUtil.getI18nLabel(employeeId, 156402, "是否扣除减除费用")); headers.add(SalaryI18nUtil.getI18nLabel(156400, "是否孤老"));
// } headers.add(SalaryI18nUtil.getI18nLabel(156402, "是否扣除减除费用"));
return headers;
}
/**
// /** * 检查表头
// * 检查表头 *
// * * @param headers
// * @param message * @return
// * @param headers */
// * @return private String checkHeader(List<String> headers, List<String> headerList) {
// */ // 缺少的列
// private boolean checkHeader(BatchDocumentMessage message, List<String> headers, List<String> headerList) { List<String> lackHeaders = headerList.stream()
// Long employeeId = message.getUserId(); .filter(header -> !headers.contains(header))
// String tenantKey = message.getTenantKey(); .collect(Collectors.toList());
// // 缺少的列 if (CollectionUtils.isNotEmpty(lackHeaders)) {
// List<String> lackHeaders = headerList.stream() // 发送导入回调信息
// .filter(header -> !headers.contains(header)) return SalaryI18nUtil.getI18nLabel(101850, "缺少如下列，请检查：") + Joiner.on(",").join((Iterable<?>) lackHeaders);
// .collect(Collectors.toList()); }
// if (CollectionUtils.isNotEmpty(lackHeaders)) { return null;
// // 发送导入回调信息 }
// String errorMsg = SalaryI18nUtil.getI18nLabel(employeeId, 101850, "缺少如下列，请检查：") + Joiner.on(",").join(lackHeaders);
// salaryBatchService.sendImportCallBackInfo(message, errorMsg);
// return false;
// }
// return true;
// }
} }

6
src/com/engine/salary/service/impl/TaxDeclarationExcelServiceImpl.java
View File

@ -138,7 +138,7 @@ public class TaxDeclarationExcelServiceImpl extends Service implements TaxDeclar
private <T> ExcelSheetData getExcelSheetData(Class<T> clazz, List<T> dtoList) { private <T> ExcelSheetData getExcelSheetData(Class<T> clazz, List<T> dtoList) {
// 导出的表头 // 导出的表头
List<String> headerList = Lists.newArrayList(); List<Object> headerList = Lists.newArrayList();
List<String> dataIndexList = Lists.newArrayList(); List<String> dataIndexList = Lists.newArrayList();
parseHeader(clazz, headerList, dataIndexList); parseHeader(clazz, headerList, dataIndexList);
// 导出的数据 // 导出的数据
@ -165,14 +165,14 @@ public class TaxDeclarationExcelServiceImpl extends Service implements TaxDeclar
* @param dataIndexList * @param dataIndexList
* @param <T> * @param <T>
*/ */
private <T> void parseHeader(Class<T> clazz, List<String> headerList, List<String> dataIndexList) { private <T> void parseHeader(Class<T> clazz, List<Object> headerList, List<String> dataIndexList) {
Field[] declaredFields = clazz.getDeclaredFields(); Field[] declaredFields = clazz.getDeclaredFields();
for (Field declaredField : declaredFields) { for (Field declaredField : declaredFields) {
if (!declaredField.isAnnotationPresent(SalaryTableColumn.class)) { if (!declaredField.isAnnotationPresent(SalaryTableColumn.class)) {
continue; continue;
} }
SalaryTableColumn annotation = declaredField.getAnnotation(SalaryTableColumn.class); SalaryTableColumn annotation = declaredField.getAnnotation(SalaryTableColumn.class);
headerList.add(SalaryI18nUtil.getI18nLabel((int) annotation.labelId(), annotation.text())); headerList.add(SalaryI18nUtil.getI18nLabel(annotation.labelId(), annotation.text()));
dataIndexList.add(declaredField.getName()); dataIndexList.add(declaredField.getName());
} }
} }

2
src/com/engine/salary/util/excel/ExcelSheetData.java
View File

@ -8,7 +8,7 @@ import java.util.List;
public class ExcelSheetData { public class ExcelSheetData {
private String sheetName; private String sheetName;
private List<String> headers; private List<Object> headers;
private List<List<Object>> rows; private List<List<Object>> rows;

2
src/com/engine/salary/util/excel/ExcelUtil.java
View File

@ -274,7 +274,7 @@ public class ExcelUtil {
public static XSSFWorkbook genWorkbook(ExcelSheetData excelSheetData) { public static XSSFWorkbook genWorkbook(ExcelSheetData excelSheetData) {
List<List<Object>> list = new ArrayList<>(); List<List<Object>> list = new ArrayList<>();
list.add(Collections.singletonList(excelSheetData.getHeaders())); list.add(excelSheetData.getHeaders());
list.addAll(excelSheetData.getRows()); list.addAll(excelSheetData.getRows());
return genWorkbookV2(list, excelSheetData.getSheetName()); return genWorkbookV2(list, excelSheetData.getSheetName());
} }

38
src/com/engine/salary/web/EmployeeDeclareController.java
View File

@ -12,7 +12,6 @@ import com.engine.salary.util.page.PageInfo;
import com.engine.salary.wrapper.EmployeeDeclareWrapper; import com.engine.salary.wrapper.EmployeeDeclareWrapper;
import io.swagger.v3.oas.annotations.parameters.RequestBody; import io.swagger.v3.oas.annotations.parameters.RequestBody;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.xssf.usermodel.XSSFWorkbook; import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import weaver.hrm.HrmUserVarify; import weaver.hrm.HrmUserVarify;
import weaver.hrm.User; import weaver.hrm.User;
@ -272,6 +271,39 @@ public class EmployeeDeclareController {
return new ResponseResult<EmployeeDeclareParam, Object>(user).run(getEmployeeDeclareWrapper(user)::getCompanyEmployee, param); return new ResponseResult<EmployeeDeclareParam, Object>(user).run(getEmployeeDeclareWrapper(user)::getCompanyEmployee, param);
} }
/**
* 人员报送-下载导入模板
*
* @param queryParam 导出参数
* @return
*/
@POST
@Path("/exportTemplate")
@Produces(MediaType.APPLICATION_OCTET_STREAM)
public Response exportTemplate(@Context HttpServletRequest request, @Context HttpServletResponse response, @RequestBody EmployeeDeclareImportParam queryParam) {
try {
User user = HrmUserVarify.getUser(request, response);
XSSFWorkbook workbook = getEmployeeDeclareWrapper(user).exportTemplate(queryParam);
String fileName = "人员信息采集导入模板-" + LocalDate.now();
try {
fileName = URLEncoder.encode(fileName + ".xlsx", "UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
StreamingOutput output = outputStream -> {
workbook.write(outputStream);
outputStream.flush();
};
response.setContentType("application/octet-stream");
return Response.ok(output).header("Content-disposition", "attachment;filename=" + fileName).header("Cache-Control", "no-cache").build();
} catch (Exception e) {
log.error("人员报送-人员信息采集导入模板异常", e);
throw e;
}
}
/** /**
* 人员报送-导出全部人员 * 人员报送-导出全部人员
* *
@ -281,11 +313,11 @@ public class EmployeeDeclareController {
@POST @POST
@Path("/export") @Path("/export")
@Produces(MediaType.APPLICATION_OCTET_STREAM) @Produces(MediaType.APPLICATION_OCTET_STREAM)
public Response export(@Context HttpServletRequest request, @Context HttpServletResponse response, @RequestBody EmployeeDeclareListQueryParam queryParam) { public Response export(@Context HttpServletRequest request, @Context HttpServletResponse response, @RequestBody EmployeeDeclareListQueryParam param) {
try { try {
User user = HrmUserVarify.getUser(request, response); User user = HrmUserVarify.getUser(request, response);
XSSFWorkbook workbook = getEmployeeDeclareWrapper(user).export(queryParam); XSSFWorkbook workbook = getEmployeeDeclareWrapper(user).export(param);
String fileName = "人员信息采集-" + LocalDate.now(); String fileName = "人员信息采集-" + LocalDate.now();
try { try {
fileName = URLEncoder.encode(fileName + ".xlsx", "UTF-8"); fileName = URLEncoder.encode(fileName + ".xlsx", "UTF-8");

2
src/com/engine/salary/web/TaxDeclarationController.java
View File

@ -218,7 +218,7 @@ public class TaxDeclarationController {
} }
/** /**
* 人员报送-导出全部人员 * 申报内置算税结果
* *
* @return * @return
*/ */

18
src/com/engine/salary/wrapper/EmployeeDeclareWrapper.java
View File

@ -558,13 +558,23 @@ public class EmployeeDeclareWrapper extends Service {
} }
/** /**
* 人员报送-导出本月全部的人员 * 人员报送-下载导入模板
* *
* @param queryParam * @param param
* @return * @return
*/ */
public XSSFWorkbook export(EmployeeDeclareListQueryParam queryParam) { public XSSFWorkbook exportTemplate(EmployeeDeclareImportParam param) {
return getEmployeeDeclareExcelService(user).export(queryParam); return getEmployeeDeclareExcelService(user).exportTemplate(param);
}
/**
* 人员报送-导出本月全部的人员
*
* @param param
* @return
*/
public XSSFWorkbook export(EmployeeDeclareListQueryParam param) {
return getEmployeeDeclareExcelService(user).export(param);
} }
// /** // /**