package jnpf.fileStorage.dms;
|
|
import jnpf.dmsEntity.preview.model.DmsWatermarkPositionSnapshot;
|
import jnpf.dmsEntity.preview.model.DmsWatermarkSnapshot;
|
import org.apache.poi.xwpf.usermodel.XWPFDocument;
|
import org.junit.Test;
|
|
import javax.imageio.ImageIO;
|
import javax.xml.parsers.DocumentBuilderFactory;
|
import java.awt.Rectangle;
|
import java.awt.image.BufferedImage;
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.math.BigDecimal;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.Base64;
|
import java.util.List;
|
import java.util.regex.Pattern;
|
|
import static org.junit.Assert.*;
|
import static org.mockito.Mockito.mock;
|
|
public class DmsWatermarkAlignmentTest {
|
private final DmsDocxWatermarkService service = new DmsDocxWatermarkService(mock(DmsCommonFileStorage.class));
|
|
@Test
|
public void configurationPreviewUsesTheExportPixelsAndRejectsUnboundedCanvases() throws Exception {
|
DmsWatermarkSnapshot watermark = mark();
|
watermark.setHorizontalAlign("CENTER");
|
watermark.setVerticalAlign("MIDDLE");
|
for (double[] page : List.of(new double[]{210, 297}, new double[]{297, 210})) {
|
assertArrayEquals(service.renderPdfOverlay(page[0], page[1], List.of(watermark)),
|
service.preview(page[0], page[1], watermark));
|
}
|
assertThrows(jnpf.exception.DataException.class, () -> service.preview(Double.NaN, 297, watermark));
|
assertThrows(jnpf.exception.DataException.class, () -> service.preview(210, 10000, watermark));
|
watermark.setMarkWidthMm(new BigDecimal("10000"));
|
assertThrows(jnpf.exception.DataException.class, () -> service.preview(210, 297, watermark));
|
}
|
|
@Test
|
public void allNineAlignmentsPlaceEachLineAndTheWholeBlockInsideTheRectangle() throws Exception {
|
List<Rectangle> legacyLines = lineInk(pdf(mark()));
|
for (String horizontal : List.of("LEFT", "CENTER", "RIGHT")) {
|
for (String vertical : List.of("TOP", "MIDDLE", "BOTTOM")) {
|
DmsWatermarkSnapshot mark = mark();
|
mark.setHorizontalAlign(horizontal);
|
mark.setVerticalAlign(vertical);
|
BufferedImage image = pdf(mark);
|
List<Rectangle> lines = lineInk(image);
|
assertEquals(2, lines.size());
|
Rectangle block = lines.get(0).union(lines.get(1));
|
assertAligned(block.y, image.getHeight() - block.y - block.height, vertical);
|
for (int index = 0; index < lines.size(); index++) {
|
Rectangle line = lines.get(index);
|
if ("LEFT".equals(horizontal)) assertEquals(legacyLines.get(index).x, line.x);
|
else assertAligned(line.x, image.getWidth() - line.x - line.width, horizontal);
|
}
|
}
|
}
|
}
|
|
@Test
|
public void missingFieldsAndTiledLayoutKeepLegacyPixels() throws Exception {
|
DmsWatermarkSnapshot mark = mark();
|
int[] legacy = pixels(pdf(mark));
|
mark.setHorizontalAlign("LEFT");
|
mark.setVerticalAlign("TOP");
|
assertArrayEquals(legacy, pixels(pdf(mark)));
|
mark.setLayoutMode("TILED");
|
int[] tiled = pixels(pdf(mark));
|
mark.setHorizontalAlign("RIGHT");
|
mark.setVerticalAlign("BOTTOM");
|
assertArrayEquals(tiled, pixels(pdf(mark)));
|
}
|
|
@Test
|
public void emptyAndOversizedTextRemainBounded() throws Exception {
|
DmsWatermarkSnapshot mark = mark();
|
mark.setHorizontalAlign("RIGHT");
|
mark.setVerticalAlign("BOTTOM");
|
mark.setContent("\n\n");
|
assertTrue(lineInk(pdf(mark)).isEmpty());
|
mark.setContent("W".repeat(200) + "\n" + "I\n".repeat(50));
|
BufferedImage image = pdf(mark);
|
assertFalse(lineInk(image).isEmpty());
|
assertEquals((int) Math.round(60 * 144 / 25.4), image.getWidth());
|
assertEquals((int) Math.round(40 * 144 / 25.4), image.getHeight());
|
}
|
|
@Test
|
public void docxAndSelectedPagePicturesKeepAlignmentAndRectangleCoordinates() throws Exception {
|
DmsWatermarkSnapshot mark = mark();
|
mark.setHorizontalAlign("RIGHT");
|
mark.setVerticalAlign("BOTTOM");
|
byte[] source = source();
|
BufferedImage expected = pdf(mark);
|
try (XWPFDocument docx = new XWPFDocument(new ByteArrayInputStream(service.apply(source, List.of(mark))))) {
|
var picture = docx.getPackage().getPartsByName(Pattern.compile("/word/media/.*")).get(0);
|
BufferedImage page = ImageIO.read(picture.getInputStream());
|
Rectangle ink = union(lineInk(page));
|
assertEquals(union(lineInk(expected)), ink);
|
assertEquals("Body stays unchanged", docx.getParagraphArray(0).getText());
|
}
|
mark.setRenderPages(List.of(1));
|
var variant = service.pageOverlays(source, List.of(mark)).get(0).getVariants().get(0);
|
assertEquals(0, variant.getOffsetXMm(), 0.001);
|
assertEquals(0, variant.getOffsetYMm(), 0.001);
|
BufferedImage selected = ImageIO.read(new ByteArrayInputStream(Base64.getDecoder().decode(variant.getPngBase64())));
|
assertEquals(union(lineInk(expected)), union(lineInk(selected)));
|
|
BufferedImage raster = new BufferedImage(expected.getWidth(), expected.getHeight(), BufferedImage.TYPE_INT_ARGB);
|
service.applyImageWatermarks(raster, List.of(mark));
|
Rectangle rasterInk = union(lineInk(raster));
|
assertAligned(rasterInk.x, raster.getWidth() - rasterInk.x - rasterInk.width, "RIGHT");
|
assertAligned(rasterInk.y, raster.getHeight() - rasterInk.y - rasterInk.height, "BOTTOM");
|
}
|
|
@Test
|
public void pageFieldsStayLiveAndUseNativeHorizontalAndVerticalAlignment() throws Exception {
|
String[] horizontal = {"LEFT", "CENTER", "RIGHT"};
|
String[] vertical = {"TOP", "MIDDLE", "BOTTOM"};
|
String[] anchors = {"t", "ctr", "b"};
|
for (String align : horizontal) {
|
for (int index = 0; index < vertical.length; index++) {
|
DmsWatermarkSnapshot mark = mark();
|
mark.setHorizontalAlign(align);
|
mark.setVerticalAlign(vertical[index]);
|
mark.setContent("Page {/CurrPage} / {/TotalPage}");
|
try (XWPFDocument docx = new XWPFDocument(new ByteArrayInputStream(service.apply(source(), List.of(mark))))) {
|
String xml = docx.getHeaderList().get(0)._getHdrFtr().xmlText();
|
assertTrue(xml.contains(" PAGE "));
|
assertTrue(xml.contains(" NUMPAGES "));
|
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
|
factory.setNamespaceAware(true);
|
var header = factory.newDocumentBuilder().parse(new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8)));
|
var paragraphAlignment = (org.w3c.dom.Element) header.getElementsByTagNameNS("*", "jc").item(0);
|
assertEquals(align.toLowerCase(java.util.Locale.ROOT), paragraphAlignment.getAttributeNS(
|
"http://schemas.openxmlformats.org/wordprocessingml/2006/main", "val"));
|
var body = (org.w3c.dom.Element) header.getElementsByTagNameNS("*", "bodyPr").item(0);
|
assertEquals(anchors[index], body.getAttribute("anchor"));
|
}
|
}
|
}
|
}
|
|
private void assertAligned(int before, int after, String alignment) {
|
if ("LEFT".equals(alignment) || "TOP".equals(alignment)) assertTrue(alignment + " margin " + before, before <= 1);
|
else if ("RIGHT".equals(alignment) || "BOTTOM".equals(alignment)) assertTrue(alignment + " margin " + after, after <= 1);
|
else assertTrue("Center margins differ: " + before + "/" + after, Math.abs(before - after) <= 2);
|
}
|
|
private BufferedImage pdf(DmsWatermarkSnapshot mark) throws Exception {
|
return ImageIO.read(new ByteArrayInputStream(service.renderPdfOverlay(60, 40, List.of(mark))));
|
}
|
|
private int[] pixels(BufferedImage image) {
|
return image.getRGB(0, 0, image.getWidth(), image.getHeight(), null, 0, image.getWidth());
|
}
|
|
private Rectangle union(List<Rectangle> lines) {
|
return lines.stream().reduce(Rectangle::union).orElseThrow();
|
}
|
|
private List<Rectangle> lineInk(BufferedImage image) {
|
List<Rectangle> lines = new ArrayList<>();
|
Rectangle line = null;
|
for (int y = 0; y < image.getHeight(); y++) {
|
Rectangle row = null;
|
for (int x = 0; x < image.getWidth(); x++) {
|
if ((image.getRGB(x, y) >>> 24) != 0) {
|
Rectangle pixel = new Rectangle(x, y, 1, 1);
|
row = row == null ? pixel : row.union(pixel);
|
}
|
}
|
if (row != null) line = line == null ? row : line.union(row);
|
else if (line != null) {
|
lines.add(line);
|
line = null;
|
}
|
}
|
if (line != null) lines.add(line);
|
return lines;
|
}
|
|
private DmsWatermarkSnapshot mark() {
|
DmsWatermarkSnapshot mark = new DmsWatermarkSnapshot();
|
mark.setWatermarkType("TEXT");
|
mark.setContent("WWWW\nI");
|
mark.setFontFamily("SansSerif");
|
mark.setFontColor("#000000");
|
mark.setFontSize(14);
|
mark.setOpacity(100);
|
mark.setRotationAngle(0);
|
mark.setLayoutMode("POSITION");
|
mark.setMarkWidthMm(new BigDecimal("60"));
|
mark.setMarkHeightMm(new BigDecimal("40"));
|
DmsWatermarkPositionSnapshot position = new DmsWatermarkPositionSnapshot();
|
position.setPaperWidthMm(new BigDecimal("40"));
|
position.setPaperHeightMm(new BigDecimal("60"));
|
position.setPortraitXMm(BigDecimal.ZERO);
|
position.setPortraitYMm(BigDecimal.ZERO);
|
position.setLandscapeXMm(BigDecimal.ZERO);
|
position.setLandscapeYMm(BigDecimal.ZERO);
|
mark.setPositions(List.of(position));
|
return mark;
|
}
|
|
private byte[] source() throws Exception {
|
try (XWPFDocument docx = new XWPFDocument(); ByteArrayOutputStream output = new ByteArrayOutputStream()) {
|
docx.createParagraph().createRun().setText("Body stays unchanged");
|
docx.write(output);
|
return output.toByteArray();
|
}
|
}
|
}
|
