package jnpf.bizcommon.onlyoffice.service.impl;
|
|
import com.google.zxing.BarcodeFormat;
|
import com.google.zxing.EncodeHintType;
|
import com.google.zxing.MultiFormatWriter;
|
import com.google.zxing.common.BitMatrix;
|
import jnpf.bizcommon.onlyoffice.entity.OnlyOfficeProperties;
|
import jnpf.dmsEntity.preview.model.DmsFilePreviewTicket;
|
import jnpf.dmsEntity.preview.model.DmsWatermarkPositionSnapshot;
|
import jnpf.dmsEntity.preview.model.DmsWatermarkSnapshot;
|
import jnpf.dms.fonts.DmsWatermarkFonts;
|
import jnpf.exception.DataException;
|
import lombok.RequiredArgsConstructor;
|
import org.apache.pdfbox.Loader;
|
import org.apache.pdfbox.pdmodel.PDDocument;
|
import org.apache.pdfbox.pdmodel.PDPage;
|
import org.apache.pdfbox.pdmodel.PDPageContentStream;
|
import org.apache.pdfbox.pdmodel.common.PDRectangle;
|
import org.apache.pdfbox.pdmodel.graphics.image.LosslessFactory;
|
import org.apache.pdfbox.pdmodel.graphics.image.PDImageXObject;
|
import org.apache.pdfbox.util.Matrix;
|
import org.springframework.stereotype.Component;
|
|
import java.awt.AlphaComposite;
|
import java.awt.Color;
|
import java.awt.Font;
|
import java.awt.FontMetrics;
|
import java.awt.Graphics2D;
|
import java.awt.RenderingHints;
|
import java.awt.image.BufferedImage;
|
import java.io.ByteArrayOutputStream;
|
import java.math.BigDecimal;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.Map;
|
import java.util.Set;
|
|
/** Builds only the physical pages that will actually be printed and stamps copy-specific barcodes. */
|
@Component
|
@RequiredArgsConstructor
|
public class DmsOnlyOfficePrintPdfComposer {
|
private static final double POINTS_PER_MM = 72D / 25.4D;
|
private static final double RENDER_DPI = 144D;
|
private static final int BARCODE_TEXT_FONT_SIZE = 10;
|
private static final int BARCODE_TEXT_PADDING_PX = 2;
|
private static final int MAX_TILED_MARKS = 300;
|
|
private final OnlyOfficeProperties properties;
|
|
public byte[] compose(byte[] basePdf, List<DmsFilePreviewTicket> copies) {
|
return compose(basePdf, copies, true);
|
}
|
|
public byte[] composePreview(byte[] basePdf, DmsFilePreviewTicket ticket) {
|
return compose(basePdf, Collections.singletonList(ticket), false);
|
}
|
|
private byte[] compose(byte[] basePdf, List<DmsFilePreviewTicket> copies,
|
boolean enforceBatchSize) {
|
if (basePdf == null || basePdf.length == 0 || copies == null || copies.isEmpty()) {
|
throw new DataException("打印 PDF 或打印副本为空");
|
}
|
OnlyOfficeProperties.DmsPrint limits = properties.getDmsPrint();
|
if (copies.size() > limits.getMaxBatchItems()) {
|
throw new DataException("单批打印份数超过系统限制");
|
}
|
try (PDDocument source = Loader.loadPDF(basePdf);
|
PDDocument output = new PDDocument();
|
ByteArrayOutputStream bytes = new ByteArrayOutputStream()) {
|
if (source.getNumberOfPages() < 1) throw new DataException("基础打印 PDF 没有页面");
|
int expectedPages = 0;
|
List<List<Integer>> pagesByCopy = new ArrayList<>(copies.size());
|
for (DmsFilePreviewTicket copy : copies) {
|
List<Integer> pages = parsePages(copy.getPrintPages(), source.getNumberOfPages());
|
if (pages.isEmpty()) {
|
throw new DataException("打印页码未匹配到文档页面");
|
}
|
expectedPages = Math.addExact(expectedPages, pages.size());
|
pagesByCopy.add(pages);
|
}
|
if (copies.size() > 1 && expectedPages > limits.getMaxBatchPages()) {
|
throw new DataException("单批打印页数超过系统限制");
|
}
|
if (expectedPages > limits.getMaxPages()) {
|
throw new DataException("打印 PDF 页数超过系统限制");
|
}
|
|
for (int copyIndex = 0; copyIndex < copies.size(); copyIndex++) {
|
DmsFilePreviewTicket ticket = copies.get(copyIndex);
|
for (Integer pageNo : pagesByCopy.get(copyIndex)) {
|
PDPage page = output.importPage(source.getPage(pageNo - 1));
|
stamp(output, page, pageNo, ticket.getWatermarks());
|
}
|
}
|
output.save(bytes);
|
long sizeLimit = enforceBatchSize
|
? Math.min(limits.getMaxPdfBytes(), limits.getMaxBatchPdfBytes())
|
: limits.getMaxPdfBytes();
|
if (bytes.size() > sizeLimit) throw new DataException("单批打印 PDF 超过系统大小限制");
|
return bytes.toByteArray();
|
} catch (DataException exception) {
|
throw exception;
|
} catch (ArithmeticException exception) {
|
throw new DataException("打印页数超过系统限制");
|
} catch (Exception exception) {
|
throw new DataException("生成按页条码打印 PDF 失败");
|
}
|
}
|
|
private void stamp(PDDocument document, PDPage page, int sourcePageNo,
|
List<DmsWatermarkSnapshot> watermarks) throws Exception {
|
if (watermarks == null || watermarks.isEmpty()) return;
|
PDRectangle box = page.getCropBox();
|
if (box == null || box.getWidth() <= 0 || box.getHeight() <= 0) {
|
throw new DataException("打印 PDF 页面尺寸无效");
|
}
|
int rotation = Math.floorMod(page.getRotation(), 360);
|
boolean quarterTurn = rotation == 90 || rotation == 270;
|
float visualWidthPt = quarterTurn ? box.getHeight() : box.getWidth();
|
float visualHeightPt = quarterTurn ? box.getWidth() : box.getHeight();
|
PageSize size = new PageSize(visualWidthPt / POINTS_PER_MM, visualHeightPt / POINTS_PER_MM);
|
try (PDPageContentStream stream = new PDPageContentStream(document, page,
|
PDPageContentStream.AppendMode.APPEND, true, true)) {
|
stream.transform(pageTransform(box, rotation));
|
for (DmsWatermarkSnapshot mark : watermarks) {
|
if (mark == null || !Boolean.TRUE.equals(mark.getCustomBarcode())
|
|| mark.getRenderPages() != null && !mark.getRenderPages().contains(sourcePageNo)) {
|
continue;
|
}
|
double markWidth = positive(mark.getMarkWidthMm(), 80D);
|
double markHeight = positive(mark.getMarkHeightMm(), 20D);
|
BufferedImage barcode = barcode(mark, px(markWidth), px(markHeight));
|
for (Point point : points(size, mark, markWidth, markHeight)) {
|
PositionedImage positioned = rotate(barcode, markWidth, markHeight,
|
value(mark.getRotationAngle(), 0), value(mark.getOpacity(), 100), point, size);
|
PDImageXObject image = LosslessFactory.createFromImage(document, positioned.image);
|
float x = (float) (positioned.x * POINTS_PER_MM);
|
float y = (float) (visualHeightPt - (positioned.y + positioned.height) * POINTS_PER_MM);
|
stream.drawImage(image, x, y,
|
(float) (positioned.width * POINTS_PER_MM),
|
(float) (positioned.height * POINTS_PER_MM));
|
}
|
}
|
}
|
}
|
|
private Matrix pageTransform(PDRectangle box, int rotation) {
|
// Undo the page's display rotation so the barcode stays upright in visual coordinates.
|
float x = box.getLowerLeftX();
|
float y = box.getLowerLeftY();
|
float width = box.getWidth();
|
float height = box.getHeight();
|
switch (rotation) {
|
case 0: return new Matrix(1, 0, 0, 1, x, y);
|
case 90: return new Matrix(0, 1, -1, 0, x + width, y);
|
case 180: return new Matrix(-1, 0, 0, -1, x + width, y + height);
|
case 270: return new Matrix(0, -1, 1, 0, x, y + height);
|
default: throw new DataException("PDF 页面旋转角度无效");
|
}
|
}
|
|
private PositionedImage rotate(BufferedImage source, double width, double height, int angle,
|
int opacity, Point point, PageSize page) {
|
double radians = Math.toRadians(Math.floorMod(angle, 360));
|
double drawingWidth = Math.abs(width * Math.cos(radians)) + Math.abs(height * Math.sin(radians));
|
double drawingHeight = Math.abs(width * Math.sin(radians)) + Math.abs(height * Math.cos(radians));
|
BufferedImage image = new BufferedImage(Math.max(1, px(drawingWidth)),
|
Math.max(1, px(drawingHeight)), BufferedImage.TYPE_INT_ARGB);
|
Graphics2D graphics = image.createGraphics();
|
try {
|
graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
|
graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
|
graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
|
Math.max(0, Math.min(100, opacity)) / 100F));
|
graphics.translate(image.getWidth() / 2D, image.getHeight() / 2D);
|
graphics.rotate(radians);
|
graphics.drawImage(source, -px(width) / 2, -px(height) / 2, px(width), px(height), null);
|
} finally {
|
graphics.dispose();
|
}
|
double x = clamp(point.x - (drawingWidth - width) / 2D, 0D, Math.max(0D, page.width - drawingWidth));
|
double y = clamp(point.y - (drawingHeight - height) / 2D, 0D, Math.max(0D, page.height - drawingHeight));
|
return new PositionedImage(image, drawingWidth, drawingHeight, x, y);
|
}
|
|
private BufferedImage barcode(DmsWatermarkSnapshot mark, int width, int height) throws Exception {
|
String configured = mark.getBarcodeFormat();
|
if (!"QR_CODE".equalsIgnoreCase(configured) && !"CODE_128".equalsIgnoreCase(configured)) {
|
throw new DataException("不支持的打印条码格式");
|
}
|
BarcodeFormat format = BarcodeFormat.valueOf(configured.toUpperCase(Locale.ROOT));
|
String content = text(mark.getContent());
|
if (content.isEmpty()) throw new DataException("打印条码内容不能为空");
|
if (!Boolean.TRUE.equals(mark.getShowBarcodeText())) {
|
return barcodeSymbol(content, format, width, height);
|
}
|
String label = mark.getBarcodeText() == null ? content : mark.getBarcodeText();
|
Font font = chooseFont(mark.getFontFamily(), label,
|
Math.max(1, (int) Math.round(BARCODE_TEXT_FONT_SIZE * RENDER_DPI / 72D)));
|
BufferedImage metricsImage = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
|
Graphics2D metricsGraphics = metricsImage.createGraphics();
|
int textHeight;
|
try {
|
metricsGraphics.setFont(font);
|
textHeight = metricsGraphics.getFontMetrics().getHeight() + BARCODE_TEXT_PADDING_PX * 2;
|
} finally {
|
metricsGraphics.dispose();
|
}
|
BufferedImage symbol = barcodeSymbol(content, format, width, Math.max(1, height - textHeight));
|
BufferedImage image = new BufferedImage(Math.max(width, symbol.getWidth()),
|
Math.max(height, symbol.getHeight() + textHeight), BufferedImage.TYPE_INT_ARGB);
|
Graphics2D graphics = image.createGraphics();
|
try {
|
graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
graphics.drawImage(symbol, (image.getWidth() - symbol.getWidth()) / 2, 0, null);
|
graphics.setFont(font);
|
graphics.setColor(Color.BLACK);
|
FontMetrics metrics = graphics.getFontMetrics();
|
graphics.drawString(label, Math.max(BARCODE_TEXT_PADDING_PX,
|
(image.getWidth() - metrics.stringWidth(label)) / 2),
|
image.getHeight() - BARCODE_TEXT_PADDING_PX - metrics.getDescent());
|
} finally {
|
graphics.dispose();
|
}
|
return image;
|
}
|
|
private BufferedImage barcodeSymbol(String content, BarcodeFormat format,
|
int width, int height) throws Exception {
|
Map<EncodeHintType, Object> hints = new LinkedHashMap<>();
|
hints.put(EncodeHintType.CHARACTER_SET, StandardCharsets.UTF_8.name());
|
BitMatrix matrix = new MultiFormatWriter().encode(content, format, width, height, hints);
|
BufferedImage image = new BufferedImage(matrix.getWidth(), matrix.getHeight(), BufferedImage.TYPE_INT_ARGB);
|
for (int y = 0; y < matrix.getHeight(); y++) {
|
for (int x = 0; x < matrix.getWidth(); x++) {
|
if (matrix.get(x, y)) image.setRGB(x, y, Color.BLACK.getRGB());
|
}
|
}
|
return image;
|
}
|
|
private Font chooseFont(String requested, String content, int pixels) {
|
return DmsWatermarkFonts.configured().choose(requested, content, pixels);
|
}
|
|
private List<Integer> parsePages(String value, int pageCount) {
|
if (value == null || value.trim().isEmpty()) {
|
List<Integer> pages = new ArrayList<>(pageCount);
|
for (int page = 1; page <= pageCount; page++) pages.add(page);
|
return pages;
|
}
|
Set<Integer> pages = new LinkedHashSet<>();
|
for (String raw : value.split(",", -1)) {
|
String token = raw.trim();
|
if (token.isEmpty() || !token.matches("\\d+(?:\\s*-\\s*\\d+)?")) {
|
throw new DataException("打印页码格式无效");
|
}
|
String[] bounds = token.split("\\s*-\\s*");
|
int start = Integer.parseInt(bounds[0]);
|
int end = bounds.length == 1 ? start : Integer.parseInt(bounds[1]);
|
if (start < 1 || end < start) throw new DataException("打印页码格式无效");
|
for (int page = start; page <= Math.min(end, pageCount); page++) pages.add(page);
|
}
|
return new ArrayList<>(pages);
|
}
|
|
private List<Point> points(PageSize page, DmsWatermarkSnapshot mark,
|
double width, double height) {
|
DmsWatermarkPositionSnapshot position = closestPosition(page, mark.getPositions());
|
double x = coordinate(page, position, true);
|
double y = coordinate(page, position, false);
|
if (!"TILED".equalsIgnoreCase(mark.getLayoutMode())) {
|
return Collections.singletonList(new Point(clamp(x, 0D, Math.max(0D, page.width - width)),
|
clamp(y, 0D, Math.max(0D, page.height - height))));
|
}
|
double stepX = Math.max(1D, width + nonNegative(mark.getRepeatSpacingXMm(), 20D));
|
double stepY = Math.max(1D, height + nonNegative(mark.getRepeatSpacingYMm(), 20D));
|
List<Point> result = new ArrayList<>();
|
for (double yy = y; yy < page.height && result.size() < MAX_TILED_MARKS; yy += stepY) {
|
for (double xx = x; xx < page.width && result.size() < MAX_TILED_MARKS; xx += stepX) {
|
result.add(new Point(xx, yy));
|
}
|
}
|
return result;
|
}
|
|
private DmsWatermarkPositionSnapshot closestPosition(PageSize page,
|
List<DmsWatermarkPositionSnapshot> positions) {
|
if (positions == null || positions.isEmpty()) throw new DataException("条码水印缺少页面位置");
|
DmsWatermarkPositionSnapshot best = null;
|
double distance = Double.MAX_VALUE;
|
for (DmsWatermarkPositionSnapshot candidate : positions) {
|
double width = positive(candidate.getPaperWidthMm(), 210D);
|
double height = positive(candidate.getPaperHeightMm(), 297D);
|
double current = Math.min(Math.abs(width - page.width) + Math.abs(height - page.height),
|
Math.abs(height - page.width) + Math.abs(width - page.height));
|
if (current < distance) {
|
distance = current;
|
best = candidate;
|
}
|
}
|
return best;
|
}
|
|
private double coordinate(PageSize page, DmsWatermarkPositionSnapshot position, boolean x) {
|
BigDecimal coordinate = page.width > page.height
|
? (x ? position.getLandscapeXMm() : position.getLandscapeYMm())
|
: (x ? position.getPortraitXMm() : position.getPortraitYMm());
|
return coordinate == null ? 0D : coordinate.doubleValue();
|
}
|
|
private int px(double mm) { return Math.max(1, (int) Math.round(mm * RENDER_DPI / 25.4D)); }
|
private double positive(BigDecimal value, double fallback) { return value == null || value.doubleValue() <= 0 ? fallback : value.doubleValue(); }
|
private double positive(Integer value, double fallback) { return value == null || value <= 0 ? fallback : value.doubleValue(); }
|
private double nonNegative(BigDecimal value, double fallback) { return value == null || value.doubleValue() < 0 ? fallback : value.doubleValue(); }
|
private double clamp(double value, double min, double max) { return Math.max(min, Math.min(max, value)); }
|
private int value(Integer value, int fallback) { return value == null ? fallback : value; }
|
private String text(String value) { return value == null ? "" : value; }
|
|
private static final class PageSize {
|
private final double width;
|
private final double height;
|
private PageSize(double width, double height) { this.width = width; this.height = height; }
|
}
|
private static final class Point {
|
private final double x;
|
private final double y;
|
private Point(double x, double y) { this.x = x; this.y = y; }
|
}
|
private static final class PositionedImage {
|
private final BufferedImage image;
|
private final double width;
|
private final double height;
|
private final double x;
|
private final double y;
|
private PositionedImage(BufferedImage image, double width, double height, double x, double y) {
|
this.image = image; this.width = width; this.height = height; this.x = x; this.y = y;
|
}
|
}
|
}
|
