Microservice/cn-rdms
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(我的绩效): 支持多份excel合并为一个大excel的不同sheet页。

Browse Source 
fix(我的绩效): 修复非直属上级也能对下属的绩效表，进行编辑/删除/发送等动作的问题。
This commit is contained in:
dk
2026-06-24 17:50:02 +08:00
parent 64e4100c11
commit 6d7e011b49
2 changed files with 425 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/performance/PerformanceSheetMapper.java
View File

@@ -3,6 +3,7 @@ package com.njcn.rdms.module.project.dal.mysql.performance;
import com.njcn.rdms.framework.common.pojo.PageResult;
import com.njcn.rdms.framework.mybatis.core.mapper.BaseMapperX;
import com.njcn.rdms.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.njcn.rdms.module.project.constant.PerformanceConstants;
import com.njcn.rdms.module.project.controller.admin.performance.vo.PerformanceSheetPageReqVO;
import com.njcn.rdms.module.project.dal.dataobject.performance.PerformanceSheetDO;
import org.apache.ibatis.annotations.Mapper;
@@ -22,6 +23,9 @@ public interface PerformanceSheetMapper extends BaseMapperX<PerformanceSheetDO>
default PageResult<PerformanceSheetDO> selectEmployeePage(Long employeeId, PerformanceSheetPageReqVO reqVO) {
LambdaQueryWrapperX<PerformanceSheetDO> wrapper = buildPageQuery(reqVO)
.eq(PerformanceSheetDO::getEmployeeId, employeeId)
.in(PerformanceSheetDO::getStatusCode, List.of(
PerformanceConstants.STATUS_SENT,
PerformanceConstants.STATUS_CONFIRMED))
.orderByDesc(PerformanceSheetDO::getPeriodMonth)
.orderByDesc(PerformanceSheetDO::getId);
return selectPage(reqVO, wrapper);

431
rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/performance/PerformanceSheetServiceImpl.java
View File

@@ -40,11 +40,35 @@ import com.njcn.rdms.module.system.api.user.UserManagementRelationApi;
import com.njcn.rdms.module.system.api.user.dto.AdminUserRespDTO;
import com.njcn.rdms.module.system.enums.notify.NotifyMessageLevelConstants;
import jakarta.annotation.Resource;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellCopyContext;
import org.apache.poi.ss.usermodel.CellCopyPolicy;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.ClientAnchor;
import org.apache.poi.ss.usermodel.Comment;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.DataFormat;
import org.apache.poi.ss.usermodel.Drawing;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.PageMargin;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.apache.poi.ss.util.CellAddress;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.PaneInformation;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFColor;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.math.BigDecimal;
import java.math.RoundingMode;
@@ -55,11 +79,15 @@ import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.zip.CRC32;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
@@ -102,11 +130,11 @@ public class PerformanceSheetServiceImpl implements PerformanceSheetService {
@Override
public PageResult<PerformanceSheetRespVO> getSheetPage(PerformanceSheetPageReqVO reqVO) {
PageResult<PerformanceSheetDO> pageResult;
if (reqVO.getEmployeeIds() != null) {
if (reqVO.getEmployeeIds() != null) { //团队视角下进入
List<Long> employeeIds = teamDashboardAccessService.resolveRequestedSubordinateUserIds(
reqVO.getEmployeeIds(), PerformanceConstants.PERMISSION_TEAM_DASHBOARD);
pageResult = performanceSheetMapper.selectEmployeePage(employeeIds, reqVO);
} else {
} else { //个人视角下进入
pageResult = performanceSheetMapper.selectEmployeePage(SecurityFrameworkUtils.getLoginUserId(), reqVO);
}
return new PageResult<>(pageResult.getList().stream().map(this::toRespVO).toList(), pageResult.getTotal());
@@ -228,7 +256,7 @@ public class PerformanceSheetServiceImpl implements PerformanceSheetService {
for (Long id : ids) {
sheets.add(validateReadableSheet(id));
}
return zipSheets("绩效表_" + LocalDate.now() + ".zip", sheets);
return zipSheetsWithMergedWorkbook("绩效表_" + LocalDate.now() + ".zip", sheets);
}
@Override
@@ -238,10 +266,10 @@ public class PerformanceSheetServiceImpl implements PerformanceSheetService {
employeeIds = teamDashboardAccessService.resolveRequestedSubordinateUserIds(
reqVO.getEmployeeIds(), PerformanceConstants.PERMISSION_TEAM_DASHBOARD);
} else {
employeeIds = List.of(SecurityFrameworkUtils.getLoginUserId());
employeeIds = List.of(Objects.requireNonNull(SecurityFrameworkUtils.getLoginUserId()));
}
List<PerformanceSheetDO> sheets = performanceSheetMapper.selectExportList(reqVO, employeeIds);
return zipSheets("绩效表_" + LocalDate.now() + ".zip", sheets);
return zipSheetsWithMergedWorkbook("绩效表_" + LocalDate.now() + ".zip", sheets);
}
@Override
@@ -461,16 +489,19 @@ public class PerformanceSheetServiceImpl implements PerformanceSheetService {
return respVO;
}
private PerformanceDownloadFile zipSheets(String filename, List<PerformanceSheetDO> sheets) {
private PerformanceDownloadFile zipSheetsWithMergedWorkbook(String filename, List<PerformanceSheetDO> sheets) {
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream)) {
Map<String, Integer> filenameCounts = new HashMap<>();
Map<PerformanceSheetDO, byte[]> fileContents = loadFileContents(sheets);
if (sheets != null && !sheets.isEmpty()) {
byte[] mergedWorkbookContent = buildMergedWorkbook(sheets, fileContents);
putStoredZipEntry(zipOutputStream, buildMergedWorkbookEntryName(sheets), mergedWorkbookContent);
}
for (PerformanceSheetDO sheet : sheets) {
byte[] content = readFileContent(sheet);
byte[] content = fileContents.get(sheet);
String entryName = uniqueFilename(defaultDownloadName(sheet), filenameCounts);
zipOutputStream.putNextEntry(new ZipEntry(entryName));
zipOutputStream.write(content);
zipOutputStream.closeEntry();
putStoredZipEntry(zipOutputStream, entryName, content);
}
zipOutputStream.finish();
return new PerformanceDownloadFile(filename, ZIP_CONTENT_TYPE, outputStream.toByteArray());
@@ -479,6 +510,379 @@ public class PerformanceSheetServiceImpl implements PerformanceSheetService {
}
}
private Map<PerformanceSheetDO, byte[]> loadFileContents(List<PerformanceSheetDO> sheets) {
Map<PerformanceSheetDO, byte[]> fileContents = new IdentityHashMap<>();
if (sheets == null || sheets.isEmpty()) {
return fileContents;
}
for (PerformanceSheetDO sheet : sheets) {
fileContents.put(sheet, readFileContent(sheet));
}
return fileContents;
}
private void putStoredZipEntry(ZipOutputStream zipOutputStream, String entryName, byte[] content) throws Exception {
CRC32 crc32 = new CRC32();
crc32.update(content);
ZipEntry zipEntry = new ZipEntry(entryName);
zipEntry.setMethod(ZipEntry.STORED);
zipEntry.setSize(content.length);
zipEntry.setCompressedSize(content.length);
zipEntry.setCrc(crc32.getValue());
zipOutputStream.putNextEntry(zipEntry);
zipOutputStream.write(content);
zipOutputStream.closeEntry();
}
private byte[] buildMergedWorkbook(List<PerformanceSheetDO> sheets, Map<PerformanceSheetDO, byte[]> fileContents) {
try (XSSFWorkbook targetWorkbook = new XSSFWorkbook();
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
Set<String> usedSheetNames = new HashSet<>();
for (PerformanceSheetDO performanceSheet : sheets) {
byte[] sourceBytes = fileContents.get(performanceSheet);
try (ByteArrayInputStream inputStream = new ByteArrayInputStream(sourceBytes);
Workbook sourceWorkbook = WorkbookFactory.create(inputStream)) {
if (!(sourceWorkbook instanceof XSSFWorkbook)) {
throw new IllegalStateException("绩效汇总导出仅支持 .xlsx 文件");
}
if (sourceWorkbook.getNumberOfSheets() <= 0) {
continue;
}
Sheet sourceSheet = sourceWorkbook.getSheetAt(0);
String targetSheetName = sanitizeSheetName(buildMergedSheetName(performanceSheet), usedSheetNames);
Sheet targetSheet = targetWorkbook.createSheet(targetSheetName);
copySheet(sourceWorkbook, sourceSheet, targetWorkbook, targetSheet);
}
}
targetWorkbook.setForceFormulaRecalculation(true);
targetWorkbook.write(outputStream);
return outputStream.toByteArray();
} catch (Exception ex) {
throw new IllegalStateException("生成绩效汇总 Excel 失败", ex);
}
}
private String buildMergedWorkbookEntryName(List<PerformanceSheetDO> sheets) {
Set<String> periodMonths = new LinkedHashSet<>();
for (PerformanceSheetDO sheet : sheets) {
if (sheet != null && StringUtils.hasText(sheet.getPeriodMonth())) {
periodMonths.add(sheet.getPeriodMonth().trim());
}
}
if (periodMonths.size() == 1) {
return "0_绩效表汇总_" + periodMonths.iterator().next() + "月.xlsx";
}
return "0_绩效表汇总.xlsx";
}
private String buildMergedSheetName(PerformanceSheetDO sheet) {
return defaultText(sheet.getPeriodMonth()) + "_" + defaultText(sheet.getEmployeeName());
}
private String sanitizeSheetName(String rawName, Set<String> usedNames) {
String name = StringUtils.hasText(rawName) ? rawName.trim() : "Sheet";
name = name.replace("\\", "_")
.replace("/", "_")
.replace("?", "_")
.replace("*", "_")
.replace("[", "_")
.replace("]", "_")
.replace(":", "_");
if (name.length() > 31) {
name = name.substring(0, 31);
}
if (!StringUtils.hasText(name)) {
name = "Sheet";
}
if (usedNames.add(name)) {
return name;
}
int index = 2;
while (true) {
String suffix = "_" + index;
int maxLength = 31 - suffix.length();
String base = name.length() > maxLength ? name.substring(0, maxLength) : name;
String candidate = base + suffix;
if (usedNames.add(candidate)) {
return candidate;
}
index++;
}
}
private void copySheet(Workbook sourceWorkbook, Sheet sourceSheet, Workbook targetWorkbook, Sheet targetSheet) {
if (!(sourceSheet instanceof XSSFSheet sourceXssfSheet) || !(targetSheet instanceof XSSFSheet targetXssfSheet)) {
throw new IllegalStateException("绩效汇总导出仅支持 .xlsx 文件");
}
copySheetSettings(sourceSheet, targetSheet);
CellCopyPolicy copyPolicy = new CellCopyPolicy();
copyPolicy.setCopyCellValue(true);
copyPolicy.setCopyCellStyle(true);
copyPolicy.setCopyCellFormula(true);
copyPolicy.setCopyHyperlink(true);
copyPolicy.setCopyRowHeight(true);
copyPolicy.setCopyMergedRegions(false);
CellCopyContext cellCopyContext = new CellCopyContext();
int firstRowNum = sourceXssfSheet.getFirstRowNum();
int lastRowNum = sourceXssfSheet.getLastRowNum();
int rangeStart = -1;
List<Row> rangeRows = new ArrayList<>();
for (int rowIndex = firstRowNum; rowIndex <= lastRowNum; rowIndex++) {
Row sourceRow = sourceXssfSheet.getRow(rowIndex);
if (sourceRow == null) {
if (rangeStart >= 0 && !rangeRows.isEmpty()) {
targetXssfSheet.copyRows(rangeRows, rangeStart, copyPolicy, cellCopyContext);
rangeStart = -1;
rangeRows = new ArrayList<>();
}
continue;
}
if (rangeStart < 0) {
rangeStart = rowIndex;
}
rangeRows.add(sourceRow);
}
if (rangeStart >= 0 && !rangeRows.isEmpty()) {
targetXssfSheet.copyRows(rangeRows, rangeStart, copyPolicy, cellCopyContext);
}
syncRowStyles(sourceWorkbook, targetWorkbook, sourceSheet, targetSheet, new SheetCopyContext());
copyMergedRegions(sourceSheet, targetSheet);
copyColumnWidths(sourceSheet, targetSheet);
copySheetComments(sourceSheet, targetSheet);
targetSheet.setForceFormulaRecalculation(true);
}
private void copySheetComments(Sheet sourceSheet, Sheet targetSheet) {
Map<CellAddress, ? extends Comment> comments = sourceSheet.getCellComments();
if (comments == null || comments.isEmpty()) {
return;
}
for (Map.Entry<CellAddress, ? extends Comment> entry : comments.entrySet()) {
CellAddress cellAddress = entry.getKey();
Row targetRow = targetSheet.getRow(cellAddress.getRow());
if (targetRow == null) {
continue;
}
Cell targetCell = targetRow.getCell(cellAddress.getColumn());
if (targetCell == null) {
continue;
}
copyCellComment(entry.getValue(), cellAddress.getRow(), cellAddress.getColumn(), targetCell);
}
}
private void syncRowStyles(Workbook sourceWorkbook, Workbook targetWorkbook, Sheet sourceSheet, Sheet targetSheet,
SheetCopyContext copyContext) {
int firstRowNum = sourceSheet.getFirstRowNum();
int lastRowNum = sourceSheet.getLastRowNum();
for (int rowIndex = firstRowNum; rowIndex <= lastRowNum; rowIndex++) {
Row sourceRow = sourceSheet.getRow(rowIndex);
Row targetRow = targetSheet.getRow(rowIndex);
if (sourceRow == null || targetRow == null) {
continue;
}
CellStyle sourceRowStyle = sourceRow.getRowStyle();
if (sourceRowStyle != null) {
targetRow.setRowStyle(cloneStyle(sourceWorkbook, targetWorkbook, sourceRowStyle, copyContext));
}
}
}
private CellStyle cloneStyle(Workbook sourceWorkbook, Workbook targetWorkbook, CellStyle sourceStyle,
SheetCopyContext copyContext) {
CellStyle cachedStyle = copyContext.styleCache.get(sourceStyle);
if (cachedStyle != null) {
return cachedStyle;
}
CellStyle newStyle = targetWorkbook.createCellStyle();
copyCellStyleProperties(sourceWorkbook, targetWorkbook, sourceStyle, newStyle, copyContext);
copyContext.styleCache.put(sourceStyle, newStyle);
return newStyle;
}
private void copyCellStyleProperties(Workbook sourceWorkbook, Workbook targetWorkbook, CellStyle sourceStyle,
CellStyle targetStyle, SheetCopyContext copyContext) {
boolean xssfCloned = false;
if (sourceStyle instanceof XSSFCellStyle sourceXssfStyle && targetStyle instanceof XSSFCellStyle targetXssfStyle) {
try {
targetXssfStyle.cloneStyleFrom(sourceXssfStyle);
xssfCloned = true;
} catch (RuntimeException ignored) {
// fallback to generic property copy
}
}
if (!xssfCloned) {
targetStyle.setAlignment(sourceStyle.getAlignment());
targetStyle.setVerticalAlignment(sourceStyle.getVerticalAlignment());
targetStyle.setBorderBottom(sourceStyle.getBorderBottom());
targetStyle.setBorderLeft(sourceStyle.getBorderLeft());
targetStyle.setBorderRight(sourceStyle.getBorderRight());
targetStyle.setBorderTop(sourceStyle.getBorderTop());
targetStyle.setBottomBorderColor(sourceStyle.getBottomBorderColor());
targetStyle.setLeftBorderColor(sourceStyle.getLeftBorderColor());
targetStyle.setRightBorderColor(sourceStyle.getRightBorderColor());
targetStyle.setTopBorderColor(sourceStyle.getTopBorderColor());
targetStyle.setFillPattern(sourceStyle.getFillPattern());
targetStyle.setFillForegroundColor(sourceStyle.getFillForegroundColor());
targetStyle.setFillBackgroundColor(sourceStyle.getFillBackgroundColor());
targetStyle.setHidden(sourceStyle.getHidden());
targetStyle.setIndention(sourceStyle.getIndention());
targetStyle.setLocked(sourceStyle.getLocked());
targetStyle.setRotation(sourceStyle.getRotation());
targetStyle.setShrinkToFit(sourceStyle.getShrinkToFit());
targetStyle.setWrapText(sourceStyle.getWrapText());
targetStyle.setQuotePrefixed(sourceStyle.getQuotePrefixed());
}
String dataFormatString = sourceStyle.getDataFormatString();
if (StringUtils.hasText(dataFormatString)) {
Short targetDataFormat = copyContext.dataFormatCache.get(dataFormatString);
if (targetDataFormat == null) {
DataFormat dataFormat = targetWorkbook.createDataFormat();
targetDataFormat = dataFormat.getFormat(dataFormatString);
copyContext.dataFormatCache.put(dataFormatString, targetDataFormat);
}
targetStyle.setDataFormat(targetDataFormat);
}
if (sourceStyle instanceof XSSFCellStyle sourceXssfStyle && targetStyle instanceof XSSFCellStyle targetXssfStyle) {
applyXssfStyleColors(sourceXssfStyle, targetXssfStyle);
}
Font sourceFont = sourceWorkbook.getFontAt(sourceStyle.getFontIndex());
if (sourceFont != null) {
Font targetFont = copyContext.fontCache.get(sourceFont);
if (targetFont == null) {
targetFont = cloneFont(targetWorkbook, sourceFont);
copyContext.fontCache.put(sourceFont, targetFont);
}
targetStyle.setFont(targetFont);
}
}
private Font cloneFont(Workbook targetWorkbook, Font sourceFont) {
Font targetFont = targetWorkbook.createFont();
targetFont.setBold(sourceFont.getBold());
targetFont.setCharSet(sourceFont.getCharSet());
targetFont.setColor(sourceFont.getColor());
targetFont.setFontHeight(sourceFont.getFontHeight());
targetFont.setFontHeightInPoints(sourceFont.getFontHeightInPoints());
targetFont.setFontName(sourceFont.getFontName());
targetFont.setItalic(sourceFont.getItalic());
targetFont.setStrikeout(sourceFont.getStrikeout());
targetFont.setTypeOffset(sourceFont.getTypeOffset());
targetFont.setUnderline(sourceFont.getUnderline());
if (sourceFont instanceof XSSFFont sourceXssfFont && targetFont instanceof XSSFFont targetXssfFont) {
targetXssfFont.setFamily(sourceXssfFont.getFamily());
if (sourceXssfFont.getScheme() != null) {
targetXssfFont.setScheme(sourceXssfFont.getScheme());
}
targetXssfFont.setThemeColor(sourceXssfFont.getThemeColor());
XSSFColor xssfColor = sourceXssfFont.getXSSFColor();
if (xssfColor != null) {
targetXssfFont.setColor(xssfColor);
}
}
return targetFont;
}
private void applyXssfStyleColors(XSSFCellStyle sourceStyle, XSSFCellStyle targetStyle) {
XSSFColor fillForegroundColor = sourceStyle.getFillForegroundColorColor();
if (fillForegroundColor != null) {
targetStyle.setFillForegroundColor(fillForegroundColor);
}
XSSFColor fillBackgroundColor = sourceStyle.getFillBackgroundColorColor();
if (fillBackgroundColor != null) {
targetStyle.setFillBackgroundColor(fillBackgroundColor);
}
XSSFColor topBorderColor = sourceStyle.getTopBorderXSSFColor();
if (topBorderColor != null) {
targetStyle.setTopBorderColor(topBorderColor);
}
XSSFColor bottomBorderColor = sourceStyle.getBottomBorderXSSFColor();
if (bottomBorderColor != null) {
targetStyle.setBottomBorderColor(bottomBorderColor);
}
XSSFColor leftBorderColor = sourceStyle.getLeftBorderXSSFColor();
if (leftBorderColor != null) {
targetStyle.setLeftBorderColor(leftBorderColor);
}
XSSFColor rightBorderColor = sourceStyle.getRightBorderXSSFColor();
if (rightBorderColor != null) {
targetStyle.setRightBorderColor(rightBorderColor);
}
}
private void copyCellComment(Comment sourceComment, int rowIndex, int columnIndex, Cell targetCell) {
if (sourceComment == null) {
return;
}
Sheet targetSheet = targetCell.getSheet();
Drawing<?> drawing = targetSheet.getDrawingPatriarch();
if (drawing == null) {
drawing = targetSheet.createDrawingPatriarch();
}
CreationHelper creationHelper = targetSheet.getWorkbook().getCreationHelper();
ClientAnchor anchor = creationHelper.createClientAnchor();
anchor.setCol1(columnIndex);
anchor.setCol2(columnIndex + 3);
anchor.setRow1(rowIndex);
anchor.setRow2(rowIndex + 4);
Comment targetComment = drawing.createCellComment(anchor);
targetComment.setAuthor(sourceComment.getAuthor());
targetComment.setVisible(sourceComment.isVisible());
targetComment.setString(creationHelper.createRichTextString(sourceComment.getString().getString()));
targetCell.setCellComment(targetComment);
}
private void copySheetSettings(Sheet sourceSheet, Sheet targetSheet) {
targetSheet.setDisplayGridlines(sourceSheet.isDisplayGridlines());
targetSheet.setPrintGridlines(sourceSheet.isPrintGridlines());
targetSheet.setDefaultRowHeight(sourceSheet.getDefaultRowHeight());
targetSheet.setDefaultColumnWidth(sourceSheet.getDefaultColumnWidth());
targetSheet.setHorizontallyCenter(sourceSheet.getHorizontallyCenter());
targetSheet.setVerticallyCenter(sourceSheet.getVerticallyCenter());
targetSheet.setMargin(PageMargin.LEFT, sourceSheet.getMargin(PageMargin.LEFT));
targetSheet.setMargin(PageMargin.RIGHT, sourceSheet.getMargin(PageMargin.RIGHT));
targetSheet.setMargin(PageMargin.TOP, sourceSheet.getMargin(PageMargin.TOP));
targetSheet.setMargin(PageMargin.BOTTOM, sourceSheet.getMargin(PageMargin.BOTTOM));
targetSheet.setZoom(40);
PaneInformation paneInformation = sourceSheet.getPaneInformation();
if (paneInformation != null && paneInformation.isFreezePane()) {
targetSheet.createFreezePane(
paneInformation.getVerticalSplitPosition(),
paneInformation.getHorizontalSplitPosition(),
paneInformation.getVerticalSplitLeftColumn(),
paneInformation.getHorizontalSplitTopRow());
}
}
private void copyColumnWidths(Sheet sourceSheet, Sheet targetSheet) {
int maxColumnNum = 0;
int firstRowNum = sourceSheet.getFirstRowNum();
int lastRowNum = sourceSheet.getLastRowNum();
for (int rowIndex = firstRowNum; rowIndex <= lastRowNum; rowIndex++) {
Row row = sourceSheet.getRow(rowIndex);
if (row != null && row.getLastCellNum() > maxColumnNum) {
maxColumnNum = row.getLastCellNum();
}
}
for (int columnIndex = 0; columnIndex < maxColumnNum; columnIndex++) {
targetSheet.setColumnWidth(columnIndex, sourceSheet.getColumnWidth(columnIndex));
targetSheet.setColumnHidden(columnIndex, sourceSheet.isColumnHidden(columnIndex));
}
}
private void copyMergedRegions(Sheet sourceSheet, Sheet targetSheet) {
int mergedRegionCount = sourceSheet.getNumMergedRegions();
for (int i = 0; i < mergedRegionCount; i++) {
CellRangeAddress region = sourceSheet.getMergedRegion(i);
targetSheet.addMergedRegion(new CellRangeAddress(
region.getFirstRow(), region.getLastRow(), region.getFirstColumn(), region.getLastColumn()));
}
}
private byte[] readFileContent(PerformanceSheetDO sheet) {
if (sheet.getFileId() == null) {
throw exception(ErrorCodeConstants.PERFORMANCE_SHEET_FILE_REQUIRED);
@@ -631,4 +1035,11 @@ public class PerformanceSheetServiceImpl implements PerformanceSheetService {
private String defaultText(String value) {
return StringUtils.hasText(value) ? value.trim() : "";
}
private static final class SheetCopyContext {
private final Map<CellStyle, CellStyle> styleCache = new IdentityHashMap<>();
private final Map<Font, Font> fontCache = new IdentityHashMap<>();
private final Map<String, Short> dataFormatCache = new HashMap<>();
}
}