package com.emergencyrepair.business.service;
|
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.emergencyrepair.business.entity.CompletionInfo;
|
import com.emergencyrepair.business.entity.Fault;
|
import com.emergencyrepair.business.entity.WorkOrder;
|
import com.emergencyrepair.business.mapper.CompletionInfoMapper;
|
import com.emergencyrepair.business.mapper.FaultMapper;
|
import com.emergencyrepair.business.mapper.WorkOrderMapper;
|
import com.emergencyrepair.business.entity.ProductNode;
|
import com.emergencyrepair.business.mapper.ProductNodeMapper;
|
import com.emergencyrepair.common.BusinessException;
|
import lombok.RequiredArgsConstructor;
|
import org.apache.poi.ooxml.POIXMLProperties;
|
import org.apache.poi.wp.usermodel.HeaderFooterType;
|
import org.apache.poi.xwpf.usermodel.XWPFDocument;
|
import org.apache.poi.xwpf.usermodel.XWPFFooter;
|
import org.apache.poi.xwpf.usermodel.XWPFHeader;
|
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
|
import org.apache.poi.xwpf.usermodel.XWPFTable;
|
import org.apache.poi.xwpf.usermodel.XWPFTableCell;
|
import org.apache.poi.xwpf.usermodel.XWPFTableRow;
|
import org.apache.xmlbeans.XmlObject;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBody;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHdrFtr;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTP;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPageMar;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPageSz;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPPr;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRow;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrPr;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSectPr;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTbl;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblBorders;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblGrid;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblPr;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblPPr;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblWidth;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblCellMar;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTc;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTcPr;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTcPr;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTcMar;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTText;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STYAlign;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STBorder;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STPageOrientation;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STMerge;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STLineSpacingRule;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STTblWidth;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STTextDirection;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STVerticalJc;
|
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STVAnchor;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.StringUtils;
|
|
import javax.annotation.PostConstruct;
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.math.BigInteger;
|
import java.nio.file.Files;
|
import java.nio.file.Path;
|
import java.nio.file.Paths;
|
import java.time.LocalDate;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
/**
|
* 工程单打印（需求 32）。
|
*
|
* <p>把选中的故障记录按 Word 模板输出成 A4 横向的四联工程单，明细可自动分页。
|
* 模板里用 {@code {字段名}} 占位，渲染时替换成真实数据。</p>
|
*
|
* <p>模板文件默认放在 {@code config/engineering-order-template.docx}，首次启动若不存在会自动生成一份，
|
* 运维/业务人员可以直接用 Word 打开修改标题、列宽、联头文字，不需要改代码。</p>
|
*
|
* <p>业务配置放在 {@code config/business-config.yml}，可按联号维护第 1~4 联名称。</p>
|
*
|
* <p>模板约定（包含明细字段的表格）：</p>
|
* <ul>
|
* <li>明细表最后一行是数据行模板，会按选中记录数复制展开，记录行不允许跨页拆分；</li>
|
* <li>联级字段可以用 {@code {xNo}}、{@code {teamMajor}}、{@code {maxFinishDate}}、{@code {unitNo}}、{@code {unitName}}、{@code {unitDisplay}}；</li>
|
* <li>整份模板会被复制 4 次输出为四联（每联一页），{@code {unitNo}} 依次为 1/2/3/4。</li>
|
* </ul>
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class EngineeringOrderPrintService {
|
private static final Logger log = LoggerFactory.getLogger(EngineeringOrderPrintService.class);
|
|
/** 一个 Word 文件里的联数。 */
|
private static final int UNIT_COUNT = 4;
|
|
private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
private static final Pattern PLACEHOLDER = Pattern.compile("\\{([^{}]*)\\}");
|
private static final String TEMPLATE_VERSION = "engineering-order-template-v4";
|
private static final Pattern TEMPLATE_PLACEHOLDER =
|
Pattern.compile("\\{\\{\\s*([^{}]+?)\\s*\\}\\}|\\{\\s*([^{}]+?)\\s*\\}");
|
|
/** 只有包含明细字段的表格才按记录数展开最后一行。 */
|
private static final Set<String> DETAIL_PLACEHOLDERS = new HashSet<>(Arrays.asList(
|
"faultCode", "engineeringNo", "workOrderNo", "equipmentName", "quantity", "equipmentCount",
|
"parentSystem", "engineeringMajor", "faultImpact", "faultNature", "majorFaultDesc",
|
"repairRequirement", "engineeringNameDesc", "isSelfRepair", "isHRelated", "isMonitorItem",
|
"monitorItem", "monitorValue", "requestedFinishDate", "remark", "contractorName",
|
"contractorNames", "startDate", "finishDate", "owner", "reportUnit", "reportDate"
|
));
|
|
|
private static final BigInteger A4_LANDSCAPE_WIDTH = BigInteger.valueOf(16838);
|
private static final BigInteger A4_LANDSCAPE_HEIGHT = BigInteger.valueOf(11906);
|
private static final BigInteger PAGE_MARGIN = BigInteger.valueOf(567);
|
|
/** 默认模板的联头占位文字。 */
|
private static final String DEFAULT_UNIT_HEADER =
|
"X号：{xNo} ZB型号：{zbModel} 专业：{teamMajor} 最大要求完工时间：{maxFinishDate}";
|
|
/** 默认模板的列定义：标题 + 字段占位符。 */
|
private static final String[][] DEFAULT_COLUMNS = {
|
{"故障编号", "{faultCode}"},
|
{"设备名称", "{equipmentName}"},
|
{"工程名称及损坏情况", "{engineeringNameDesc}"},
|
{"修理技术要求", "{repairRequirement}"},
|
{"承修单位", "{contractorName}"},
|
{"数量", "{quantity}"},
|
{"备注", "{remark}"}
|
};
|
|
/** 默认模板的列宽（twips），合计约等于 A4 横向可用宽度。 */
|
private static final int UNIT_COLUMN_WIDTH = 400;
|
private static final int[] TABLE_COLUMN_WIDTHS = {1450, 2750, 3300, 3300, 2000, 800, 1700, UNIT_COLUMN_WIDTH};
|
|
private final FaultMapper faultMapper;
|
private final WorkOrderMapper workOrderMapper;
|
private final CompletionInfoMapper completionInfoMapper;
|
private final ProductNodeMapper productNodeMapper;
|
|
@Value("${app.engineering-print.template-path:${app.engineering-print.template:config/engineering-order-template.docx}}")
|
private String templateLocation;
|
|
@Value("${app.engineering-print.unit-names.1:上报人}")
|
private String unitName1;
|
|
@Value("${app.engineering-print.unit-names.2:}")
|
private String unitName2;
|
|
@Value("${app.engineering-print.unit-names.3:}")
|
private String unitName3;
|
|
@Value("${app.engineering-print.unit-names.4:}")
|
private String unitName4;
|
|
@PostConstruct
|
public void ensureTemplate() {
|
Path path = templatePath();
|
if (path == null) {
|
return;
|
}
|
try {
|
Files.createDirectories(path.getParent());
|
if (Files.exists(path)) {
|
return;
|
}
|
try (XWPFDocument document = buildDefaultTemplate();
|
ByteArrayOutputStream out = new ByteArrayOutputStream()) {
|
document.write(out);
|
Files.write(path, out.toByteArray());
|
}
|
log.info("工程单打印模板已生成或升级：{}", path.toAbsolutePath());
|
} catch (Exception exception) {
|
log.warn("生成或升级工程单打印模板失败：{}", exception.getMessage());
|
}
|
}
|
|
private Map<Integer, String> loadUnitNames() {
|
Map<Integer, String> names = new LinkedHashMap<>();
|
names.put(1, text(unitName1).trim());
|
names.put(2, text(unitName2).trim());
|
names.put(3, text(unitName3).trim());
|
names.put(4, text(unitName4).trim());
|
return names;
|
}
|
|
private boolean templateNeedsUpgrade(Path path) {
|
try (InputStream input = Files.newInputStream(path);
|
XWPFDocument document = new XWPFDocument(input)) {
|
POIXMLProperties.CoreProperties properties = document.getProperties().getCoreProperties();
|
return !TEMPLATE_VERSION.equals(properties.getKeywords())
|
|| collectText(document).indexOf("{zbModel}") < 0
|
|| collectText(document).indexOf("{unitDisplay}") < 0;
|
} catch (Exception exception) {
|
log.warn("工程单打印模板无法读取，将重新生成：{}", exception.getMessage());
|
return true;
|
}
|
}
|
|
/**
|
* 按选中的故障记录渲染工程单 Word 文档。
|
*
|
* @param faultIds 故障主键
|
*/
|
public byte[] render(List<Long> faultIds) {
|
return renderInternal(faultIds, false);
|
}
|
|
/**
|
* 打印工程单2：按联分组输出，第1联全部明细后换页，再输出第2联，以此类推。
|
*/
|
public byte[] renderVersion2(List<Long> faultIds) {
|
return renderInternal(faultIds, true);
|
}
|
|
private byte[] renderInternal(List<Long> faultIds, boolean legacyGroupedUnits) {
|
List<Long> ids = normalizeIds(faultIds);
|
if (ids.isEmpty()) {
|
throw new BusinessException("请至少选择一条记录后再打印");
|
}
|
List<Map<String, String>> records = loadRecords(ids);
|
if (records.isEmpty()) {
|
throw new BusinessException("选中的记录已不存在，请刷新后重试");
|
}
|
Map<Integer, String> unitNames = loadUnitNames();
|
try (InputStream template = openTemplate();
|
XWPFDocument document = new XWPFDocument(template);
|
ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
|
if (legacyGroupedUnits) {
|
renderLegacyGroupedUnits(document, records, unitNames);
|
} else {
|
renderUnits(document, records, unitNames);
|
}
|
document.write(buffer);
|
return buffer.toByteArray();
|
} catch (IOException exception) {
|
throw new BusinessException("生成工程单失败：" + exception.getMessage());
|
}
|
}
|
|
private List<Long> normalizeIds(List<Long> faultIds) {
|
if (faultIds == null) {
|
return new ArrayList<>();
|
}
|
List<Long> ids = new ArrayList<>();
|
for (Long id : faultIds) {
|
if (id != null && !ids.contains(id)) {
|
ids.add(id);
|
}
|
}
|
return ids;
|
}
|
|
private List<Map<String, String>> loadRecords(List<Long> ids) {
|
List<Fault> faults = faultMapper.selectBatchIds(ids);
|
Map<Long, Fault> faultById = new LinkedHashMap<>();
|
for (Fault fault : faults) {
|
faultById.put(fault.getId(), fault);
|
}
|
Map<String, String> zbModelByXNo = loadZbModels(faults);
|
|
List<WorkOrder> workOrders = workOrderMapper.selectList(Wrappers.<WorkOrder>lambdaQuery()
|
.in(WorkOrder::getFaultId, ids));
|
Map<Long, WorkOrder> workOrderByFault = new LinkedHashMap<>();
|
List<Long> workOrderIds = new ArrayList<>();
|
for (WorkOrder workOrder : workOrders) {
|
workOrderByFault.putIfAbsent(workOrder.getFaultId(), workOrder);
|
if (workOrder.getId() != null) {
|
workOrderIds.add(workOrder.getId());
|
}
|
}
|
|
Map<Long, CompletionInfo> completionByWorkOrder = new LinkedHashMap<>();
|
if (!workOrderIds.isEmpty()) {
|
List<CompletionInfo> completions = completionInfoMapper.selectList(Wrappers.<CompletionInfo>lambdaQuery()
|
.in(CompletionInfo::getWorkOrderId, workOrderIds));
|
for (CompletionInfo completion : completions) {
|
completionByWorkOrder.putIfAbsent(completion.getWorkOrderId(), completion);
|
}
|
}
|
|
LocalDate maxFinishDate = null;
|
for (CompletionInfo completion : completionByWorkOrder.values()) {
|
if (completion.getFinishDate() != null
|
&& (maxFinishDate == null || completion.getFinishDate().isAfter(maxFinishDate))) {
|
maxFinishDate = completion.getFinishDate();
|
}
|
}
|
if (maxFinishDate == null) {
|
for (Long id : ids) {
|
Fault fault = faultById.get(id);
|
if (fault != null && fault.getRequestedFinishDate() != null
|
&& (maxFinishDate == null || fault.getRequestedFinishDate().isAfter(maxFinishDate))) {
|
maxFinishDate = fault.getRequestedFinishDate();
|
}
|
}
|
}
|
|
List<Map<String, String>> records = new ArrayList<>();
|
for (Long id : ids) {
|
Fault fault = faultById.get(id);
|
if (fault == null) {
|
continue;
|
}
|
WorkOrder workOrder = workOrderByFault.get(id);
|
CompletionInfo completion = workOrder == null ? null : completionByWorkOrder.get(workOrder.getId());
|
String zbModel = zbModelByXNo.get(normalizeXNo(fault.getXNo()));
|
records.add(buildRecord(fault, workOrder, completion, maxFinishDate, zbModel));
|
}
|
return records;
|
}
|
|
private Map<String, String> loadZbModels(List<Fault> faults) {
|
Map<String, String> result = new LinkedHashMap<>();
|
List<String> xNos = new ArrayList<>();
|
for (Fault fault : faults) {
|
String xNo = normalizeXNo(fault.getXNo());
|
if (StringUtils.hasText(xNo) && !xNos.contains(xNo)) {
|
xNos.add(xNo);
|
}
|
}
|
if (xNos.isEmpty()) {
|
return result;
|
}
|
|
List<ProductNode> sideNodes = productNodeMapper.selectList(Wrappers.<ProductNode>lambdaQuery()
|
.in(ProductNode::getLayer, java.util.Arrays.asList("side", "SIDE"))
|
.in(ProductNode::getName, xNos)
|
.ne(ProductNode::getIsDelete, "1")
|
.orderByAsc(ProductNode::getSortNo)
|
.orderByAsc(ProductNode::getId));
|
Map<String, Long> parentIdsByXNo = new LinkedHashMap<>();
|
for (ProductNode side : sideNodes) {
|
String xNo = normalizeXNo(side.getName());
|
if (StringUtils.hasText(xNo) && side.getParentId() != null && side.getParentId() != 0L) {
|
parentIdsByXNo.putIfAbsent(xNo, side.getParentId());
|
}
|
}
|
if (parentIdsByXNo.isEmpty()) {
|
return result;
|
}
|
|
List<Long> parentIds = new ArrayList<>(new java.util.LinkedHashSet<>(parentIdsByXNo.values()));
|
List<ProductNode> parents = productNodeMapper.selectBatchIds(parentIds);
|
Map<Long, String> parentNameById = new LinkedHashMap<>();
|
for (ProductNode parent : parents) {
|
if (!"1".equals(parent.getIsDelete())) {
|
parentNameById.put(parent.getId(), text(parent.getName()));
|
}
|
}
|
for (Map.Entry<String, Long> entry : parentIdsByXNo.entrySet()) {
|
result.put(entry.getKey(), text(parentNameById.get(entry.getValue())));
|
}
|
return result;
|
}
|
|
private String normalizeXNo(String value) {
|
return StringUtils.hasText(value) ? value.trim() : "";
|
}
|
|
private Map<String, String> buildRecord(Fault fault, WorkOrder workOrder, CompletionInfo completion,
|
LocalDate maxFinishDate, String zbModel) {
|
Map<String, String> values = new LinkedHashMap<>();
|
String contractor = firstText(
|
workOrder == null ? null : workOrder.getContractorName(),
|
completion == null ? null : completion.getContractorName(),
|
fault.getContractorNames());
|
String engineeringNo = firstText(
|
completion == null ? null : completion.getEngineeringNo(),
|
fault.getEngineeringNo());
|
|
values.put("faultCode", text(fault.getFaultCode()));
|
values.put("engineeringNo", text(engineeringNo));
|
values.put("workOrderNo", text(workOrder == null ? null : workOrder.getWorkOrderNo()));
|
values.put("equipmentName", text(fault.getEquipmentName()));
|
values.put("quantity", String.valueOf(equipmentQuantity(fault)));
|
values.put("equipmentCount", values.get("quantity"));
|
values.put("parentSystem", text(fault.getParentSystem()));
|
values.put("engineeringMajor", text(fault.getEngineeringMajor()));
|
values.put("teamMajor", text(fault.getTeamMajor()));
|
values.put("xNo", text(fault.getXNo()));
|
values.put("zbModel", text(zbModel));
|
values.put("owner", text(fault.getOwner()));
|
values.put("reportUnit", text(fault.getReportUnit()));
|
values.put("reportDate", date(fault.getReportDate()));
|
values.put("faultImpact", text(fault.getFaultImpact()));
|
values.put("faultNature", text(fault.getFaultNature()));
|
values.put("majorFaultDesc", text(fault.getMajorFaultDesc()));
|
values.put("repairRequirement", text(fault.getRepairRequirement()));
|
values.put("engineeringNameDesc", text(fault.getEngineeringNameDesc()));
|
values.put("isSelfRepair", yesNo(fault.getIsSelfRepair()));
|
values.put("isHRelated", yesNo(fault.getIsHRelated()));
|
values.put("isMonitorItem", yesNo(fault.getIsMonitorItem()));
|
values.put("monitorItem", text(fault.getMonitorItem()));
|
values.put("monitorValue", text(fault.getMonitorValue()));
|
values.put("requestedFinishDate", date(fault.getRequestedFinishDate()));
|
values.put("remark", text(fault.getRemark()));
|
values.put("contractorName", text(contractor));
|
values.put("contractorNames", text(fault.getContractorNames()));
|
values.put("startDate", date(completion == null ? null : completion.getStartDate()));
|
values.put("finishDate", date(completion == null ? null : completion.getFinishDate()));
|
values.put("maxFinishDate", date(maxFinishDate));
|
return values;
|
}
|
|
private int equipmentQuantity(Fault fault) {
|
String equipmentIds = fault.getEquipmentIds();
|
int count = 0;
|
if (StringUtils.hasText(equipmentIds)) {
|
for (String item : equipmentIds.split(",")) {
|
if (StringUtils.hasText(item)) {
|
count++;
|
}
|
}
|
}
|
if (count == 0 && fault.getEquipmentId() != null) {
|
count = 1;
|
}
|
return count;
|
}
|
|
private void renderUnits(XWPFDocument document,
|
List<Map<String, String>> records, Map<Integer, String> unitNames) {
|
CTBody body = document.getDocument().getBody();
|
List<XmlObject> templateElements = snapshotBodyElements(document);
|
if (templateElements.isEmpty()) {
|
throw new BusinessException("Engineering order template is empty: " + templateLocation);
|
}
|
|
int detailTableIndex = findDetailTableIndex(templateElements);
|
if (detailTableIndex < 0) {
|
throw new BusinessException("Engineering order template has no detail table: " + templateLocation);
|
}
|
int bottomTableIndex = findBottomTableIndex(templateElements, detailTableIndex);
|
Map<String, String> shared = new LinkedHashMap<>(records.get(0));
|
|
CTSectPr section = body.isSetSectPr() ? (CTSectPr) body.getSectPr().copy() : null;
|
CTBody cleanBody = CTBody.Factory.newInstance();
|
if (section != null) {
|
cleanBody.addNewSectPr().set(section);
|
}
|
body.set(cleanBody);
|
|
// Render each dynamically paginated detail page as four consecutive units.
|
|
renderPagedUnits(body, (CTTbl) templateElements.get(detailTableIndex), records, unitNames, section);
|
|
moveSectionPropertiesToEnd(body);
|
copyTemplatePrefixToHeader(document, templateElements, detailTableIndex, shared, records);
|
if (bottomTableIndex >= 0) {
|
copyTemplateTableToFooter(document, (CTTbl) templateElements.get(bottomTableIndex), shared, records);
|
}
|
}
|
|
private void renderPagedUnits(CTBody body, CTTbl templateTable,
|
List<Map<String, String>> records,
|
Map<Integer, String> unitNames,
|
CTSectPr section) {
|
List<List<Map<String, String>>> pages = paginateRecords(templateTable, records, section);
|
int renderedPage = 0;
|
for (List<Map<String, String>> page : pages) {
|
for (int unit = 1; unit <= UNIT_COUNT; unit++) {
|
String unitName = text(unitNames.get(unit)).trim();
|
Map<String, String> unitValues = new LinkedHashMap<>();
|
unitValues.put("unitNo", String.valueOf(unit));
|
unitValues.put("unitName", unitName);
|
unitValues.put("unitDisplay", "\u7b2c" + unit + "\u8054"
|
+ (StringUtils.hasText(unitName) ? " " + unitName : ""));
|
|
List<Map<String, String>> unitRecords = new ArrayList<>();
|
for (Map<String, String> record : page) {
|
Map<String, String> unitRecord = new LinkedHashMap<>(record);
|
unitRecord.putAll(unitValues);
|
unitRecords.add(unitRecord);
|
}
|
|
CTTbl table = body.addNewTbl();
|
table.set(templateTable);
|
clearTablePosition(table);
|
renderTable(table, unitValues, unitRecords);
|
int headerRowCount = table.sizeOfTrArray() - unitRecords.size();
|
configureUnitTablePagination(table, renderedPage > 0, headerRowCount);
|
configureUnitColumnVerticalMerge(table);
|
renderedPage++;
|
}
|
}
|
}
|
|
private List<List<Map<String, String>>> paginateRecords(CTTbl templateTable,
|
List<Map<String, String>> records,
|
CTSectPr section) {
|
List<List<Map<String, String>>> pages = new ArrayList<>();
|
if (records.isEmpty() || templateTable.sizeOfTrArray() == 0) {
|
return pages;
|
}
|
|
List<Integer> columnWidths = tableColumnWidths(templateTable);
|
int dataRowIndex = templateTable.sizeOfTrArray() - 1;
|
int headerHeight = 0;
|
for (int i = 0; i < dataRowIndex; i++) {
|
headerHeight += estimateRowHeight(templateTable.getTrArray(i), columnWidths, records.get(0));
|
}
|
|
int availableHeight = Math.max(1200,
|
(int) ((pageContentHeight(section) - headerHeight) * 0.50));
|
List<Map<String, String>> current = new ArrayList<>();
|
int usedHeight = 0;
|
for (Map<String, String> record : records) {
|
int rowHeight = estimateRowHeight(templateTable.getTrArray(dataRowIndex), columnWidths, record);
|
if (!current.isEmpty() && usedHeight + rowHeight > availableHeight) {
|
pages.add(current);
|
current = new ArrayList<>();
|
usedHeight = 0;
|
}
|
current.add(record);
|
usedHeight += rowHeight;
|
}
|
if (!current.isEmpty()) {
|
pages.add(current);
|
}
|
return pages;
|
}
|
|
private List<Integer> tableColumnWidths(CTTbl table) {
|
List<Integer> widths = new ArrayList<>();
|
CTTblGrid grid = table.getTblGrid();
|
if (grid != null) {
|
for (int i = 0; i < grid.sizeOfGridColArray(); i++) {
|
Object value = grid.getGridColArray(i).getW();
|
widths.add(value == null ? 0 : new BigInteger(String.valueOf(value)).intValue());
|
}
|
}
|
if (widths.isEmpty()) {
|
for (int width : TABLE_COLUMN_WIDTHS) {
|
widths.add(width);
|
}
|
}
|
return widths;
|
}
|
|
private int pageContentHeight(CTSectPr section) {
|
int height = A4_LANDSCAPE_HEIGHT.intValue();
|
int top = PAGE_MARGIN.intValue();
|
int bottom = PAGE_MARGIN.intValue();
|
if (section != null) {
|
if (section.isSetPgSz() && section.getPgSz().getH() != null) {
|
height = new BigInteger(String.valueOf(section.getPgSz().getH())).intValue();
|
}
|
if (section.isSetPgMar()) {
|
if (section.getPgMar().getTop() != null) {
|
top = new BigInteger(String.valueOf(section.getPgMar().getTop())).intValue();
|
}
|
if (section.getPgMar().getBottom() != null) {
|
bottom = new BigInteger(String.valueOf(section.getPgMar().getBottom())).intValue();
|
}
|
}
|
}
|
return Math.max(1200, height - top - bottom);
|
}
|
|
private int estimateRowHeight(CTRow row, List<Integer> columnWidths, Map<String, String> values) {
|
int maxHeight = 0;
|
int gridIndex = 0;
|
for (CTTc cell : row.getTcList()) {
|
int gridSpan = 1;
|
if (cell.isSetTcPr() && cell.getTcPr().isSetGridSpan()
|
&& cell.getTcPr().getGridSpan().getVal() != null) {
|
gridSpan = new BigInteger(String.valueOf(cell.getTcPr().getGridSpan().getVal())).intValue();
|
}
|
int cellWidth = cellWidthTwips(cell, columnWidths, gridIndex, gridSpan);
|
int cellHeight = 0;
|
for (CTP paragraph : cell.getPList()) {
|
String paragraphText = substitute(paragraphText(paragraph), values);
|
double fontSize = paragraphFontSize(paragraph, 9.0);
|
double usableWidth = Math.max(8.0, cellWidth / 20.0 - 2.0);
|
int lines = Math.max(1, (int) Math.ceil(textUnits(paragraphText) * fontSize / usableWidth));
|
cellHeight += (int) Math.ceil(lines * fontSize * 1.28 * 20.0) + 20;
|
}
|
maxHeight = Math.max(maxHeight, cellHeight);
|
gridIndex += gridSpan;
|
}
|
return Math.max(240, maxHeight);
|
}
|
|
private int cellWidthTwips(CTTc cell, List<Integer> columnWidths, int gridIndex, int gridSpan) {
|
if (cell.isSetTcPr() && cell.getTcPr().isSetTcW()) {
|
Object width = cell.getTcPr().getTcW().getW();
|
if (width != null && (!cell.getTcPr().getTcW().isSetType()
|
|| cell.getTcPr().getTcW().getType() == STTblWidth.DXA)) {
|
return new BigInteger(String.valueOf(width)).intValue();
|
}
|
}
|
int width = 0;
|
for (int i = gridIndex; i < gridIndex + gridSpan && i < columnWidths.size(); i++) {
|
width += columnWidths.get(i);
|
}
|
return width > 0 ? width : 1000;
|
}
|
|
private String paragraphText(CTP paragraph) {
|
StringBuilder builder = new StringBuilder();
|
for (CTR run : paragraph.getRList()) {
|
for (CTText text : run.getTList()) {
|
builder.append(text.getStringValue());
|
}
|
}
|
return builder.toString();
|
}
|
|
private double paragraphFontSize(CTP paragraph, double fallback) {
|
for (CTR run : paragraph.getRList()) {
|
if (run.isSetRPr() && run.getRPr().isSetSz() && run.getRPr().getSz().getVal() != null) {
|
return new BigInteger(String.valueOf(run.getRPr().getSz().getVal())).intValue() / 2.0;
|
}
|
}
|
return fallback;
|
}
|
|
private double textUnits(String value) {
|
double units = 0;
|
for (int i = 0; i < value.length(); i++) {
|
char character = value.charAt(i);
|
if (character == '\r' || character == '\n') {
|
continue;
|
}
|
if (character == ' ') {
|
units += 0.5;
|
} else if (character >= 0x2e80 || Character.isIdeographic(character)) {
|
units += 1.0;
|
} else {
|
units += 0.58;
|
}
|
}
|
return units;
|
}
|
|
private void renderInterleavedUnitTable(CTBody body, CTTbl templateTable,
|
List<Map<String, String>> records,
|
Map<Integer, String> unitNames) {
|
List<Map<String, String>> repeatedRecords = repeatRecordsByUnit(records, unitNames);
|
CTTbl table = body.addNewTbl();
|
table.set(templateTable);
|
clearTablePosition(table);
|
Map<String, String> headerValues = new LinkedHashMap<>(records.get(0));
|
headerValues.put("unitDisplay", "联号/联名");
|
renderTable(table, headerValues, repeatedRecords);
|
configureRecordRows(table, table.sizeOfTrArray() - repeatedRecords.size());
|
}
|
|
private List<Map<String, String>> repeatRecordsByUnit(List<Map<String, String>> records,
|
Map<Integer, String> unitNames) {
|
List<Map<String, String>> repeatedRecords = new ArrayList<>();
|
for (Map<String, String> record : records) {
|
for (int unit = 1; unit <= UNIT_COUNT; unit++) {
|
Map<String, String> values = new LinkedHashMap<>(record);
|
String unitName = text(unitNames.get(unit)).trim();
|
values.put("unitNo", String.valueOf(unit));
|
values.put("unitName", unitName);
|
values.put("unitDisplay", "第" + unit + "联"
|
+ (StringUtils.hasText(unitName) ? " " + unitName : ""));
|
repeatedRecords.add(values);
|
}
|
}
|
return repeatedRecords;
|
}
|
|
private void renderLegacyGroupedUnits(XWPFDocument document,
|
List<Map<String, String>> records,
|
Map<Integer, String> unitNames) {
|
CTBody body = document.getDocument().getBody();
|
List<XmlObject> templateElements = snapshotBodyElements(document);
|
if (templateElements.isEmpty()) {
|
throw new BusinessException("Engineering order template is empty: " + templateLocation);
|
}
|
|
int detailTableIndex = findDetailTableIndex(templateElements);
|
if (detailTableIndex < 0) {
|
throw new BusinessException("Engineering order template has no detail table: " + templateLocation);
|
}
|
int bottomTableIndex = findBottomTableIndex(templateElements, detailTableIndex);
|
|
Map<String, String> shared = new LinkedHashMap<>(records.get(0));
|
// The first and last template tables are page chrome. Put them into the
|
// Word header/footer so Word repeats them on every generated page.
|
copyTemplatePrefixToHeader(document, templateElements, detailTableIndex, shared, records);
|
if (bottomTableIndex >= 0) {
|
copyTemplateTableToFooter(document, (CTTbl) templateElements.get(bottomTableIndex), shared, records);
|
}
|
CTSectPr section = body.isSetSectPr() ? (CTSectPr) body.getSectPr().copy() : null;
|
CTBody cleanBody = CTBody.Factory.newInstance();
|
if (section != null) {
|
cleanBody.addNewSectPr().set(section);
|
}
|
body.set(cleanBody);
|
|
for (int unit = 1; unit <= UNIT_COUNT; unit++) {
|
if (unit > 1) {
|
appendPageBreakParagraph(body);
|
}
|
|
String unitName = text(unitNames.get(unit)).trim();
|
Map<String, String> unitValues = new LinkedHashMap<>();
|
unitValues.put("unitNo", String.valueOf(unit));
|
unitValues.put("unitName", unitName);
|
unitValues.put("unitDisplay", "第" + unit + "联"
|
+ (StringUtils.hasText(unitName) ? " " + unitName : ""));
|
|
Map<String, String> values = new LinkedHashMap<>(shared);
|
values.putAll(unitValues);
|
|
List<Map<String, String>> unitRecords = new ArrayList<>();
|
for (Map<String, String> record : records) {
|
Map<String, String> unitRecord = new LinkedHashMap<>(record);
|
unitRecord.putAll(unitValues);
|
unitRecords.add(unitRecord);
|
}
|
|
CTTbl table = body.addNewTbl();
|
table.set(templateElements.get(detailTableIndex));
|
clearTablePosition(table);
|
renderTable(table, values, unitRecords);
|
configureRecordRows(table, table.sizeOfTrArray() - unitRecords.size());
|
configureUnitColumnVerticalMerge(table);
|
}
|
|
moveSectionPropertiesToEnd(body);
|
}
|
|
private List<XmlObject> snapshotBodyElements(XWPFDocument document) {
|
List<XmlObject> elements = new ArrayList<>();
|
for (Object element : document.getBodyElements()) {
|
if (element instanceof XWPFParagraph) {
|
elements.add(((XWPFParagraph) element).getCTP().copy());
|
} else if (element instanceof XWPFTable) {
|
elements.add(((XWPFTable) element).getCTTbl().copy());
|
}
|
}
|
return elements;
|
}
|
|
private int findDetailTableIndex(List<XmlObject> elements) {
|
for (int i = 0; i < elements.size(); i++) {
|
XmlObject element = elements.get(i);
|
if (element instanceof CTTbl && containsDetailPlaceholder((CTTbl) element)) {
|
return i;
|
}
|
}
|
return -1;
|
}
|
|
private int findBottomTableIndex(List<XmlObject> elements, int detailTableIndex) {
|
int bottomTableIndex = -1;
|
for (int i = detailTableIndex + 1; i < elements.size(); i++) {
|
if (elements.get(i) instanceof CTTbl) {
|
bottomTableIndex = i;
|
}
|
}
|
return bottomTableIndex;
|
}
|
|
private void renderDetailTables(CTBody body, CTTbl table,
|
List<Map<String, String>> records,
|
Map<Integer, String> unitNames) {
|
int rowCount = table.sizeOfTrArray();
|
if (rowCount == 0) {
|
return;
|
}
|
|
int headerRowCount = rowCount - 1;
|
List<CTRow> headerRows = new ArrayList<>();
|
for (int i = 0; i < headerRowCount; i++) {
|
headerRows.add((CTRow) table.getTrArray(i).copy());
|
}
|
CTRow dataRow = (CTRow) table.getTrArray(rowCount - 1).copy();
|
|
CTTbl rowTemplate = (CTTbl) table.copy();
|
while (rowTemplate.sizeOfTrArray() > 0) {
|
rowTemplate.removeTr(0);
|
}
|
|
// Each unit is one continuously paginated table. Word fits as many detail
|
// rows per page as their actual rendered heights allow; cantSplit keeps each
|
// individual detail row intact across page boundaries.
|
for (int unit = 1; unit <= UNIT_COUNT; unit++) {
|
String unitName = text(unitNames.get(unit)).trim();
|
Map<String, String> unitValues = new LinkedHashMap<>();
|
unitValues.put("unitNo", String.valueOf(unit));
|
unitValues.put("unitName", unitName);
|
unitValues.put("unitDisplay", "\u7b2c" + unit + "\u8054"
|
+ (StringUtils.hasText(unitName) ? " " + unitName : ""));
|
|
CTTbl unitTable = (CTTbl) rowTemplate.copy();
|
for (CTRow headerRow : headerRows) {
|
CTRow renderedHeader = unitTable.addNewTr();
|
renderedHeader.set(headerRow);
|
replaceInRow(renderedHeader, unitValues);
|
}
|
|
for (Map<String, String> record : records) {
|
Map<String, String> values = new LinkedHashMap<>(record);
|
values.putAll(unitValues);
|
CTRow renderedData = unitTable.addNewTr();
|
renderedData.set(dataRow);
|
replaceInRow(renderedData, values);
|
}
|
|
configureUnitTablePagination(unitTable, unit > 1, headerRows.size());
|
body.addNewTbl().set(unitTable);
|
}
|
}
|
|
private void configureUnitTablePagination(CTTbl table, boolean pageBreakBefore, int headerRowCount) {
|
configureRecordRows(table, headerRowCount);
|
if (!pageBreakBefore || table.sizeOfTrArray() == 0) {
|
return;
|
}
|
CTRow firstRow = table.getTrArray(0);
|
if (firstRow.sizeOfTcArray() == 0) {
|
return;
|
}
|
CTTc firstCell = firstRow.getTcArray(0);
|
if (firstCell.sizeOfPArray() == 0) {
|
firstCell.addNewP();
|
}
|
setPageBreakBefore(firstCell.getPArray(0));
|
}
|
|
/** Merge the final unit-number column across every row in one unit table. */
|
private void configureUnitColumnVerticalMerge(CTTbl table) {
|
int rowCount = table.sizeOfTrArray();
|
for (int i = 0; i < rowCount; i++) {
|
CTRow row = table.getTrArray(i);
|
if (row.sizeOfTcArray() == 0) {
|
continue;
|
}
|
CTTc unitCell = row.getTcArray(row.sizeOfTcArray() - 1);
|
CTTcPr properties = unitCell.isSetTcPr() ? unitCell.getTcPr() : unitCell.addNewTcPr();
|
if (properties.isSetVMerge()) {
|
properties.unsetVMerge();
|
}
|
properties.addNewVMerge().setVal(i == 0 ? STMerge.RESTART : STMerge.CONTINUE);
|
if (!properties.isSetTextDirection()) {
|
properties.addNewTextDirection();
|
}
|
properties.getTextDirection().setVal(STTextDirection.BT_LR);
|
if (!properties.isSetVAlign()) {
|
properties.addNewVAlign();
|
}
|
properties.getVAlign().setVal(STVerticalJc.CENTER);
|
}
|
}
|
|
private void configureRecordRows(CTTbl table, int headerRowCount) {
|
clearTablePosition(table);
|
for (int i = 0; i < table.sizeOfTrArray(); i++) {
|
CTRow row = table.getTrArray(i);
|
CTTrPr properties = row.isSetTrPr() ? row.getTrPr() : row.addNewTrPr();
|
if (properties.sizeOfCantSplitArray() == 0) {
|
properties.addNewCantSplit();
|
}
|
while (properties.sizeOfTblHeaderArray() > 0) {
|
properties.removeTblHeader(0);
|
}
|
if (i < headerRowCount) {
|
properties.addNewTblHeader();
|
}
|
configureCellParagraphPagination(row, false);
|
}
|
}
|
|
private int tableWidth(CTTbl table) {
|
CTTblGrid grid = table.getTblGrid();
|
if (grid != null) {
|
int width = 0;
|
for (int i = 0; i < grid.sizeOfGridColArray(); i++) {
|
Object value = grid.getGridColArray(i).getW();
|
if (value != null) {
|
width += new BigInteger(String.valueOf(value)).intValue();
|
}
|
}
|
if (width > 0) {
|
return width;
|
}
|
}
|
return totalWidth(TABLE_COLUMN_WIDTHS);
|
}
|
|
private void noBorder(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder border) {
|
border.setVal(STBorder.NIL);
|
border.setSz(BigInteger.ZERO);
|
border.setSpace(BigInteger.ZERO);
|
}
|
|
private void zeroMargin(CTTblWidth margin) {
|
margin.setType(STTblWidth.DXA);
|
margin.setW(BigInteger.ZERO);
|
}
|
|
private void configureCellParagraphPagination(CTRow row, boolean keepWithNext) {
|
// Keep the complete row together. Word measures the final rendered text height dynamically,
|
// so no fixed row height or per-page record count is needed.
|
for (CTTc cell : row.getTcList()) {
|
for (CTP paragraph : cell.getPList()) {
|
CTPPr properties = paragraph.isSetPPr() ? paragraph.getPPr() : paragraph.addNewPPr();
|
if (!properties.isSetKeepLines()) {
|
properties.addNewKeepLines();
|
}
|
if (properties.isSetKeepNext()) {
|
properties.unsetKeepNext();
|
}
|
if (keepWithNext) {
|
properties.addNewKeepNext();
|
}
|
}
|
}
|
}
|
|
private void copyTemplatePrefixToHeader(XWPFDocument document, List<XmlObject> elements,
|
int detailTableIndex, Map<String, String> values,
|
List<Map<String, String>> records) {
|
XWPFHeader header = document.createHeader(HeaderFooterType.DEFAULT);
|
CTHdrFtr headerContent = header._getHdrFtr();
|
for (int i = 0; i < detailTableIndex; i++) {
|
XmlObject element = elements.get(i);
|
if (element instanceof CTP) {
|
CTP paragraph = headerContent.addNewP();
|
paragraph.set(element);
|
replaceInParagraph(paragraph, values);
|
} else if (element instanceof CTTbl) {
|
appendHeaderFooterTable(headerContent, (CTTbl) element, values, records);
|
}
|
}
|
}
|
|
private void copyTemplateTableToFooter(XWPFDocument document, CTTbl source,
|
Map<String, String> values, List<Map<String, String>> records) {
|
XWPFFooter footer = document.createFooter(HeaderFooterType.DEFAULT);
|
appendHeaderFooterTable(footer._getHdrFtr(), source, values, records);
|
}
|
|
private void appendHeaderFooterTable(CTHdrFtr content, CTTbl source,
|
Map<String, String> values,
|
List<Map<String, String>> records) {
|
CTTbl table = content.addNewTbl();
|
table.set(source);
|
clearTablePosition(table);
|
renderTable(table, values, records);
|
}
|
|
private void clearTablePosition(CTTbl table) {
|
CTTblPr properties = table.getTblPr() != null ? table.getTblPr() : table.addNewTblPr();
|
if (properties.isSetTblpPr()) {
|
properties.unsetTblpPr();
|
}
|
}
|
|
private void renderTable(CTTbl table, Map<String, String> unitValues,
|
List<Map<String, String>> records) {
|
boolean expand = containsDetailPlaceholder(table);
|
int rowCount = table.sizeOfTrArray();
|
if (rowCount == 0) {
|
return;
|
}
|
if (expand) {
|
CTRow dataRow = table.getTrArray(rowCount - 1);
|
for (CTTc cell : dataRow.getTcList()) {
|
CTTcPr properties = cell.isSetTcPr() ? cell.getTcPr() : cell.addNewTcPr();
|
if (properties.isSetVMerge()) {
|
properties.unsetVMerge();
|
}
|
}
|
}
|
|
int dataRowIndex = rowCount - 1;
|
if (expand) {
|
CTRow dataRow = table.getTrArray(dataRowIndex);
|
for (int i = 0; i < records.size(); i++) {
|
table.addNewTr().set(dataRow);
|
}
|
table.removeTr(dataRowIndex);
|
}
|
for (int i = 0; i < table.sizeOfTrArray(); i++) {
|
boolean dataRow = expand && i >= table.sizeOfTrArray() - records.size();
|
Map<String, String> values = dataRow
|
? records.get(i - (table.sizeOfTrArray() - records.size()))
|
: unitValues;
|
replaceInRow(table.getTrArray(i), values);
|
}
|
}
|
|
private boolean containsDetailPlaceholder(CTTbl table) {
|
StringBuilder builder = new StringBuilder();
|
for (CTRow row : table.getTrList()) {
|
for (CTTc cell : row.getTcList()) {
|
for (CTP paragraph : cell.getPList()) {
|
for (CTR run : paragraph.getRList()) {
|
for (CTText text : run.getTList()) {
|
builder.append(text.getStringValue());
|
}
|
}
|
}
|
}
|
}
|
|
Matcher matcher = TEMPLATE_PLACEHOLDER.matcher(builder.toString());
|
while (matcher.find()) {
|
String key = matcher.group(1) != null ? matcher.group(1) : matcher.group(2);
|
if (DETAIL_PLACEHOLDERS.contains(key.trim())) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private void replaceInRow(CTRow row, Map<String, String> values) {
|
for (CTTc cell : row.getTcList()) {
|
for (CTP paragraph : cell.getPList()) {
|
replaceInParagraph(paragraph, values);
|
}
|
}
|
}
|
|
private void replaceInParagraph(CTP paragraph, Map<String, String> values) {
|
List<CTR> runs = paragraph.getRList();
|
if (runs.isEmpty()) {
|
return;
|
}
|
|
List<TextChunk> chunks = new ArrayList<>();
|
StringBuilder builder = new StringBuilder();
|
for (CTR run : runs) {
|
for (CTText text : run.getTList()) {
|
String value = text.getStringValue();
|
if (value == null) {
|
value = "";
|
}
|
chunks.add(new TextChunk(text, builder.length(), builder.length() + value.length()));
|
builder.append(value);
|
}
|
}
|
|
String original = builder.toString();
|
if (original.indexOf('{') < 0) {
|
return;
|
}
|
|
Map<CTText, List<TextEdit>> edits = new LinkedHashMap<>();
|
Matcher matcher = TEMPLATE_PLACEHOLDER.matcher(original);
|
while (matcher.find()) {
|
String key = matcher.group(1) != null ? matcher.group(1) : matcher.group(2);
|
String replacement = values.get(key.trim());
|
if (replacement == null) {
|
replacement = "";
|
}
|
for (TextChunk chunk : chunks) {
|
int overlapStart = Math.max(matcher.start(), chunk.start);
|
int overlapEnd = Math.min(matcher.end(), chunk.end);
|
if (overlapStart >= overlapEnd) {
|
continue;
|
}
|
String inserted = overlapStart == matcher.start() ? replacement : "";
|
edits.computeIfAbsent(chunk.text, item -> new ArrayList<>())
|
.add(new TextEdit(overlapStart - chunk.start, overlapEnd - chunk.start, inserted));
|
}
|
}
|
|
for (Map.Entry<CTText, List<TextEdit>> entry : edits.entrySet()) {
|
String value = text(entry.getKey().getStringValue());
|
entry.getValue().sort((left, right) -> Integer.compare(right.start, left.start));
|
for (TextEdit edit : entry.getValue()) {
|
value = value.substring(0, edit.start) + edit.replacement + value.substring(edit.end);
|
}
|
entry.getKey().setStringValue(value);
|
}
|
}
|
|
private static final class TextChunk {
|
private final CTText text;
|
private final int start;
|
private final int end;
|
|
private TextChunk(CTText text, int start, int end) {
|
this.text = text;
|
this.start = start;
|
this.end = end;
|
}
|
}
|
|
private static final class TextEdit {
|
private final int start;
|
private final int end;
|
private final String replacement;
|
|
private TextEdit(int start, int end, String replacement) {
|
this.start = start;
|
this.end = end;
|
this.replacement = replacement;
|
}
|
}
|
|
private void replaceInParagraphLegacy(CTP paragraph, Map<String, String> values) {
|
List<CTR> runs = paragraph.getRList();
|
if (runs.isEmpty()) {
|
return;
|
}
|
StringBuilder builder = new StringBuilder();
|
for (CTR run : runs) {
|
for (CTText text : run.getTList()) {
|
builder.append(text.getStringValue());
|
}
|
}
|
String original = builder.toString();
|
if (original.indexOf('{') < 0) {
|
return;
|
}
|
String replaced = substitute(original, values);
|
if (replaced.equals(original)) {
|
return;
|
}
|
if (runs.size() == 1) {
|
CTR run = runs.get(0);
|
if (run.sizeOfTArray() > 0) {
|
run.getTArray(0).setStringValue(replaced);
|
for (int i = run.sizeOfTArray() - 1; i >= 1; i--) {
|
run.removeT(i);
|
}
|
return;
|
}
|
}
|
for (CTR run : runs) {
|
for (int i = run.sizeOfTArray() - 1; i >= 0; i--) {
|
run.removeT(i);
|
}
|
for (int i = run.sizeOfTabArray() - 1; i >= 0; i--) {
|
run.removeTab(i);
|
}
|
for (int i = run.sizeOfBrArray() - 1; i >= 0; i--) {
|
run.removeBr(i);
|
}
|
}
|
runs.get(0).addNewT().setStringValue(replaced);
|
}
|
|
private String substitute(String text, Map<String, String> values) {
|
Matcher matcher = PLACEHOLDER.matcher(text);
|
StringBuffer buffer = new StringBuffer();
|
while (matcher.find()) {
|
String key = matcher.group(1).trim();
|
String value = values.get(key);
|
matcher.appendReplacement(buffer, Matcher.quoteReplacement(value == null ? "" : value));
|
}
|
matcher.appendTail(buffer);
|
return buffer.toString();
|
}
|
|
private void appendPageBreakParagraph(CTBody body) {
|
CTP paragraph = body.addNewP();
|
CTPPr properties = paragraph.addNewPPr();
|
properties.addNewPageBreakBefore();
|
properties.addNewSpacing().setBefore(BigInteger.ZERO);
|
properties.getSpacing().setAfter(BigInteger.ZERO);
|
properties.addNewRPr().addNewSz().setVal(BigInteger.valueOf(2));
|
}
|
|
private void setPageBreakBefore(CTP paragraph) {
|
CTPPr properties = paragraph.isSetPPr() ? paragraph.getPPr() : paragraph.addNewPPr();
|
if (!properties.isSetPageBreakBefore()) {
|
properties.addNewPageBreakBefore();
|
}
|
}
|
|
private void moveSectionPropertiesToEnd(CTBody body) {
|
if (!body.isSetSectPr()) {
|
return;
|
}
|
CTSectPr section = (CTSectPr) body.getSectPr().copy();
|
body.unsetSectPr();
|
body.setSectPr(section);
|
}
|
|
private String collectText(XWPFDocument document) {
|
StringBuilder builder = new StringBuilder();
|
for (XWPFParagraph paragraph : document.getParagraphs()) {
|
builder.append(paragraph.getText()).append('\n');
|
}
|
for (XWPFTable table : document.getTables()) {
|
for (XWPFTableRow row : table.getRows()) {
|
for (XWPFTableCell cell : row.getTableCells()) {
|
builder.append(cell.getText()).append('\n');
|
}
|
}
|
}
|
return builder.toString();
|
}
|
|
private InputStream openTemplate() throws IOException {
|
Path path = templatePath();
|
if (path != null && Files.exists(path)) {
|
return Files.newInputStream(path);
|
}
|
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
|
try (XWPFDocument document = buildDefaultTemplate()) {
|
document.write(buffer);
|
}
|
return new ByteArrayInputStream(buffer.toByteArray());
|
}
|
|
private Path templatePath() {
|
if (!StringUtils.hasText(templateLocation)) {
|
return null;
|
}
|
return Paths.get(templateLocation).toAbsolutePath().normalize();
|
}
|
|
|
/** 生成一份带占位符的默认工程单模板。 */
|
XWPFDocument buildDefaultTemplate() throws IOException {
|
XWPFDocument document = new XWPFDocument();
|
CTBody body = document.getDocument().getBody();
|
CTSectPr section = body.isSetSectPr() ? body.getSectPr() : body.addNewSectPr();
|
CTPageSz pageSize = section.isSetPgSz() ? section.getPgSz() : section.addNewPgSz();
|
pageSize.setW(A4_LANDSCAPE_WIDTH);
|
pageSize.setH(A4_LANDSCAPE_HEIGHT);
|
pageSize.setOrient(STPageOrientation.LANDSCAPE);
|
CTPageMar margin = section.isSetPgMar() ? section.getPgMar() : section.addNewPgMar();
|
margin.setTop(PAGE_MARGIN);
|
margin.setBottom(PAGE_MARGIN);
|
margin.setLeft(PAGE_MARGIN);
|
margin.setRight(PAGE_MARGIN);
|
int mainColumns = DEFAULT_COLUMNS.length;
|
int columns = mainColumns + 1;
|
XWPFTable table = document.createTable(3, columns);
|
applyBorders(table.getCTTbl());
|
applyGrid(table.getCTTbl(), TABLE_COLUMN_WIDTHS);
|
|
XWPFTableRow headerRow = table.getRow(0);
|
mergeMainColumns(headerRow, mainColumns, document);
|
setCellText(headerRow.getCell(0), DEFAULT_UNIT_HEADER, true);
|
|
XWPFTableRow titleRow = table.getRow(1);
|
XWPFTableRow fieldRow = table.getRow(2);
|
for (int i = 0; i < mainColumns; i++) {
|
setWidth(titleRow.getCell(i), TABLE_COLUMN_WIDTHS[i]);
|
setWidth(fieldRow.getCell(i), TABLE_COLUMN_WIDTHS[i]);
|
setCellText(titleRow.getCell(i), DEFAULT_COLUMNS[i][0], true);
|
setCellText(fieldRow.getCell(i), DEFAULT_COLUMNS[i][1], false);
|
}
|
configureUnitColumn(titleRow, mainColumns, false);
|
configureUnitColumn(fieldRow, mainColumns, false);
|
|
moveSectionPropertiesToEnd(body);
|
document.getProperties().getCoreProperties().setKeywords(TEMPLATE_VERSION);
|
return document;
|
}
|
|
private void applyBorders(CTTbl table) {
|
CTTblPr properties = table.getTblPr() != null ? table.getTblPr() : table.addNewTblPr();
|
CTTblBorders borders = properties.isSetTblBorders() ? properties.getTblBorders() : properties.addNewTblBorders();
|
border(borders.isSetTop() ? borders.getTop() : borders.addNewTop());
|
border(borders.isSetLeft() ? borders.getLeft() : borders.addNewLeft());
|
border(borders.isSetBottom() ? borders.getBottom() : borders.addNewBottom());
|
border(borders.isSetRight() ? borders.getRight() : borders.addNewRight());
|
border(borders.isSetInsideH() ? borders.getInsideH() : borders.addNewInsideH());
|
border(borders.isSetInsideV() ? borders.getInsideV() : borders.addNewInsideV());
|
}
|
|
private void border(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder border) {
|
border.setVal(STBorder.SINGLE);
|
border.setSz(BigInteger.valueOf(4));
|
border.setColor("000000");
|
border.setSpace(BigInteger.ZERO);
|
}
|
|
private void applyGrid(CTTbl table, int[] widths) {
|
CTTblGrid grid = table.getTblGrid() != null ? table.getTblGrid() : table.addNewTblGrid();
|
while (grid.sizeOfGridColArray() > widths.length) {
|
grid.removeGridCol(grid.sizeOfGridColArray() - 1);
|
}
|
while (grid.sizeOfGridColArray() < widths.length) {
|
grid.addNewGridCol();
|
}
|
for (int i = 0; i < widths.length; i++) {
|
grid.getGridColArray(i).setW(BigInteger.valueOf(widths[i]));
|
}
|
CTTblPr properties = table.getTblPr() != null ? table.getTblPr() : table.addNewTblPr();
|
CTTblWidth width = properties.isSetTblW() ? properties.getTblW() : properties.addNewTblW();
|
width.setType(STTblWidth.DXA);
|
width.setW(BigInteger.valueOf(totalWidth(widths)));
|
}
|
|
private int totalWidth(int[] widths) {
|
int total = 0;
|
for (int value : widths) {
|
total += value;
|
}
|
return total;
|
}
|
|
private void mergeMainColumns(XWPFTableRow row, int mainColumns, XWPFDocument document) {
|
CTRow ctRow = row.getCtRow();
|
while (ctRow.sizeOfTcArray() > 2) {
|
ctRow.removeTc(ctRow.sizeOfTcArray() - 2);
|
}
|
CTTc cell = ctRow.getTcArray(0);
|
CTTcPr properties = cell.isSetTcPr() ? cell.getTcPr() : cell.addNewTcPr();
|
if (!properties.isSetGridSpan()) {
|
properties.addNewGridSpan().setVal(BigInteger.valueOf(mainColumns));
|
}
|
CTTblWidth cellWidth = properties.isSetTcW() ? properties.getTcW() : properties.addNewTcW();
|
cellWidth.setType(STTblWidth.DXA);
|
cellWidth.setW(BigInteger.valueOf(totalWidth(TABLE_COLUMN_WIDTHS) - UNIT_COLUMN_WIDTH));
|
|
CTTc unitCell = ctRow.getTcArray(1);
|
XWPFTableCell unitWrapper = new XWPFTableCell(unitCell, row, document);
|
setWidth(unitWrapper, UNIT_COLUMN_WIDTH);
|
configureUnitCell(unitCell, true);
|
setCellText(unitWrapper, "{unitDisplay}", true);
|
}
|
|
private void configureUnitColumn(XWPFTableRow row, int mainColumns, boolean restart) {
|
int index = mainColumns;
|
XWPFTableCell cell = row.getCell(index);
|
setWidth(cell, UNIT_COLUMN_WIDTH);
|
configureUnitCell(cell.getCTTc(), restart);
|
}
|
|
private void configureUnitCell(CTTc cell, boolean restart) {
|
CTTcPr properties = cell.isSetTcPr() ? cell.getTcPr() : cell.addNewTcPr();
|
if (!properties.isSetVMerge()) {
|
properties.addNewVMerge();
|
}
|
properties.getVMerge().setVal(restart ? STMerge.RESTART : STMerge.CONTINUE);
|
if (!properties.isSetTextDirection()) {
|
properties.addNewTextDirection();
|
}
|
properties.getTextDirection().setVal(STTextDirection.BT_LR);
|
if (!properties.isSetVAlign()) {
|
properties.addNewVAlign();
|
}
|
properties.getVAlign().setVal(STVerticalJc.CENTER);
|
}
|
|
private void setWidth(XWPFTableCell cell, int width) {
|
CTTcPr properties = cell.getCTTc().isSetTcPr() ? cell.getCTTc().getTcPr() : cell.getCTTc().addNewTcPr();
|
CTTblWidth cellWidth = properties.isSetTcW() ? properties.getTcW() : properties.addNewTcW();
|
cellWidth.setType(STTblWidth.DXA);
|
cellWidth.setW(BigInteger.valueOf(width));
|
}
|
|
private void setCellText(XWPFTableCell cell, String text, boolean centered) {
|
XWPFParagraph paragraph = cell.getParagraphs().isEmpty() ? cell.addParagraph() : cell.getParagraphs().get(0);
|
if (centered) {
|
paragraph.setAlignment(org.apache.poi.xwpf.usermodel.ParagraphAlignment.CENTER);
|
}
|
org.apache.poi.xwpf.usermodel.XWPFRun run = paragraph.createRun();
|
run.setFontFamily("SimSun");
|
run.setFontSize(9);
|
run.setText(text);
|
for (XWPFParagraph extra : new ArrayList<>(cell.getParagraphs())) {
|
if (extra != paragraph) {
|
cell.removeParagraph(cell.getParagraphs().indexOf(extra));
|
}
|
}
|
}
|
|
|
private static String text(String value) {
|
return value == null ? "" : value;
|
}
|
|
private static String date(LocalDate value) {
|
return value == null ? "" : DATE_FORMAT.format(value);
|
}
|
|
private static String yesNo(Integer value) {
|
return value != null && value == 1 ? "是" : "否";
|
}
|
|
private static String firstText(String... candidates) {
|
for (String candidate : candidates) {
|
if (StringUtils.hasText(candidate)) {
|
return candidate;
|
}
|
}
|
return "";
|
}
|
}
|
