Versendung: doppelseitiges Sammel PDF und diverse Verbesserungen
This commit is contained in:
1 parent
4b88aca958
commit
feab6135ff
31 files changed
+1302
-96
No files matched your search
+40
-12
@@ -6,6 +6,8 @@ import (
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/go-pdf/fpdf"
|
||||
|
||||
"lektorenplan/domain"
|
||||
)
|
||||
|
||||
@@ -15,7 +17,7 @@ type DispatchAssignment struct {
|
||||
TimeMinutes int
|
||||
Church string
|
||||
Title string
|
||||
Role domain.Role
|
||||
RoleLabel string
|
||||
}
|
||||
|
||||
// CoverData describes the personal cover sheet of a dispatch packet.
|
||||
@@ -39,7 +41,7 @@ func AssignmentLines(assignments []DispatchAssignment) []string {
|
||||
domain.MediumString(assignment.Date),
|
||||
domain.TimeString(assignment.TimeMinutes),
|
||||
assignment.Church,
|
||||
assignment.Role.Title()))
|
||||
assignment.RoleLabel))
|
||||
}
|
||||
return lines
|
||||
}
|
||||
@@ -48,6 +50,34 @@ func coverOptions(data CoverData) Options {
|
||||
return Options{TenantName: data.TenantName, Diocese: data.Diocese, GeneratedAt: data.GeneratedAt}
|
||||
}
|
||||
|
||||
// writeCoverText writes letter paragraphs with manual page breaks. Cover pages
|
||||
// are laid out with explicit coordinates, so fpdf's own page breaking would
|
||||
// reset the cursor to the default margin and misalign the letter. A long
|
||||
// introduction or greeting must nevertheless appear completely instead of
|
||||
// running off the page.
|
||||
func writeCoverText(pdf *fpdf.Fpdf, tr func(string) string, text string, x, y, width, lineHeight, pageTop, bottom float64) float64 {
|
||||
text = strings.TrimSpace(strings.ReplaceAll(text, "\r\n", "\n"))
|
||||
if text == "" {
|
||||
return y
|
||||
}
|
||||
for _, paragraph := range strings.Split(text, "\n") {
|
||||
if strings.TrimSpace(paragraph) == "" {
|
||||
y += lineHeight
|
||||
continue
|
||||
}
|
||||
for _, line := range pdf.SplitLines([]byte(tr(paragraph)), width) {
|
||||
if y+lineHeight > bottom {
|
||||
pdf.AddPage()
|
||||
y = pageTop
|
||||
}
|
||||
pdf.SetXY(x, y)
|
||||
pdf.CellFormat(width, lineHeight, string(line), "", 0, "L", false, 0, "")
|
||||
y += lineHeight
|
||||
}
|
||||
}
|
||||
return y
|
||||
}
|
||||
|
||||
// Cover writes an A4 portrait cover letter with the personal assignment overview.
|
||||
func Cover(w io.Writer, data CoverData) error {
|
||||
pdf := newPDF("P")
|
||||
@@ -109,9 +139,8 @@ func Cover(w io.Writer, data CoverData) error {
|
||||
y += 10
|
||||
setColor(pdf, colors.ink)
|
||||
pdf.SetFont("Times", "", 11.5)
|
||||
pdf.SetXY(margin, y)
|
||||
pdf.MultiCell(contentW, 5.6, tr(strings.TrimSpace(data.Intro)), "", "L", false)
|
||||
y = pdf.GetY() + 8
|
||||
y = writeCoverText(pdf, tr, data.Intro, margin, y, contentW, 5.6, margin, 278)
|
||||
y += 8
|
||||
|
||||
// Assignment table -----------------------------------------------------
|
||||
setColor(pdf, colors.ink)
|
||||
@@ -162,7 +191,7 @@ func Cover(w io.Writer, data CoverData) error {
|
||||
dayLabel,
|
||||
domain.TimeString(assignment.TimeMinutes),
|
||||
assignment.Church,
|
||||
assignment.Role.Title() + " · " + assignment.Title,
|
||||
assignment.RoleLabel + " · " + assignment.Title,
|
||||
}
|
||||
for index, column := range columns {
|
||||
pdf.SetXY(x, y+2.1)
|
||||
@@ -179,16 +208,15 @@ func Cover(w io.Writer, data CoverData) error {
|
||||
|
||||
// Greeting -------------------------------------------------------------
|
||||
if strings.TrimSpace(data.Greeting) != "" {
|
||||
if y > 245 {
|
||||
pdf.AddPage()
|
||||
y = margin
|
||||
}
|
||||
setColor(pdf, colors.ink)
|
||||
pdf.SetFont("Times", "", 11.5)
|
||||
pdf.SetXY(margin, y)
|
||||
pdf.MultiCell(contentW, 5.6, tr(strings.TrimSpace(data.Greeting)), "", "L", false)
|
||||
y = writeCoverText(pdf, tr, data.Greeting, margin, y, contentW, 5.6, margin, 278)
|
||||
y += 8
|
||||
}
|
||||
|
||||
// The recipient is already named explicitly in the address block above,
|
||||
// so the cover does not repeat the name in parentheses at the end.
|
||||
|
||||
// Footer ---------------------------------------------------------------
|
||||
setColor(pdf, colors.tertiary)
|
||||
pdf.SetFont("Helvetica", "", 6.5)
|
||||
|
||||
+130
-30
@@ -4,48 +4,148 @@ import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"runtime"
|
||||
|
||||
"github.com/go-pdf/fpdf"
|
||||
"github.com/go-pdf/fpdf/contrib/gofpdi"
|
||||
)
|
||||
|
||||
// Merge concatenates PDF documents page by page, preserving page sizes and
|
||||
// orientation. It is used for printable dispatch packets that combine a cover
|
||||
// sheet with the selected plan variant for every recipient.
|
||||
func Merge(documents [][]byte) ([]byte, error) {
|
||||
// PDF page boxes are reported in PostScript points while fpdf works in
|
||||
// millimetres.
|
||||
const mmPerPoint = 25.4 / 72.0
|
||||
|
||||
type documentPage struct {
|
||||
width float64
|
||||
height float64
|
||||
}
|
||||
|
||||
func pointsToMillimetres(value float64) float64 {
|
||||
return value * mmPerPoint
|
||||
}
|
||||
|
||||
// documentPages returns the page geometry of a PDF in millimetres.
|
||||
func documentPages(raw []byte) ([]documentPage, error) {
|
||||
out := fpdf.New("P", "mm", "A4", "")
|
||||
out.SetMargins(0, 0, 0)
|
||||
out.SetAutoPageBreak(false, 0)
|
||||
|
||||
for _, raw := range documents {
|
||||
if len(raw) == 0 {
|
||||
continue
|
||||
importer := gofpdi.NewImporter()
|
||||
reader := new(io.ReadSeeker)
|
||||
*reader = bytes.NewReader(raw)
|
||||
importer.ImportPageFromStream(out, reader, 1, "/MediaBox")
|
||||
|
||||
sizes := importer.GetPageSizes()
|
||||
if len(sizes) == 0 {
|
||||
return nil, fmt.Errorf("PDF ohne Seiten")
|
||||
}
|
||||
pages := make([]documentPage, len(sizes))
|
||||
for page := 1; page <= len(sizes); page++ {
|
||||
size, ok := sizes[page]["/MediaBox"]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("PDF-Seite %d ohne MediaBox", page)
|
||||
}
|
||||
var reader io.ReadSeeker = bytes.NewReader(raw)
|
||||
importer := gofpdi.NewImporter()
|
||||
template := importer.ImportPageFromStream(out, &reader, 1, "/MediaBox")
|
||||
sizes := importer.GetPageSizes()
|
||||
pages := len(sizes)
|
||||
if pages == 0 {
|
||||
return nil, fmt.Errorf("PDF ohne Seiten")
|
||||
}
|
||||
for page := 1; page <= pages; page++ {
|
||||
size, ok := sizes[page]["/MediaBox"]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("PDF-Seite %d ohne MediaBox", page)
|
||||
}
|
||||
width, height := size["w"], size["h"]
|
||||
orientation := "P"
|
||||
if width > height {
|
||||
orientation = "L"
|
||||
}
|
||||
out.AddPageFormat(orientation, fpdf.SizeType{Wd: width, Ht: height})
|
||||
if page > 1 {
|
||||
template = importer.ImportPageFromStream(out, &reader, page, "/MediaBox")
|
||||
}
|
||||
importer.UseImportedTemplate(out, template, 0, 0, width, height)
|
||||
pages[page-1] = documentPage{
|
||||
width: pointsToMillimetres(size["w"]),
|
||||
height: pointsToMillimetres(size["h"]),
|
||||
}
|
||||
}
|
||||
return pages, nil
|
||||
}
|
||||
|
||||
// PageCount returns the number of pages in a PDF document.
|
||||
func PageCount(raw []byte) (int, error) {
|
||||
pages, err := documentPages(raw)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return len(pages), nil
|
||||
}
|
||||
|
||||
// PadToEvenPages appends one blank page to documents with an odd page count so
|
||||
// that every cover sheet and every service list starts on the front side of a
|
||||
// sheet when printed duplex. Documents with an even page count are returned
|
||||
// unchanged.
|
||||
func PadToEvenPages(raw []byte) ([]byte, error) {
|
||||
pages, err := documentPages(raw)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(pages)%2 == 0 {
|
||||
return raw, nil
|
||||
}
|
||||
last := pages[len(pages)-1]
|
||||
blank, err := blankPage(last.width, last.height)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return Merge([][]byte{raw, blank})
|
||||
}
|
||||
|
||||
func blankPage(width, height float64) ([]byte, error) {
|
||||
out := fpdf.New("P", "mm", "A4", "")
|
||||
out.SetMargins(0, 0, 0)
|
||||
out.SetAutoPageBreak(false, 0)
|
||||
out.AddPageFormat("P", fpdf.SizeType{Wd: width, Ht: height})
|
||||
|
||||
var buffer bytes.Buffer
|
||||
if err := out.Output(&buffer); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := out.Error(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return buffer.Bytes(), nil
|
||||
}
|
||||
|
||||
// Merge concatenates PDF documents page by page, preserving page sizes and
|
||||
// orientation. It is used for printable dispatch packets that combine a cover
|
||||
// sheet with the selected plan variant for every recipient.
|
||||
//
|
||||
// All documents share one importer. A new importer per document would restart
|
||||
// the internal template numbering, so later documents would silently overwrite
|
||||
// earlier templates and their pages would show the wrong content.
|
||||
func Merge(documents [][]byte) ([]byte, error) {
|
||||
out := fpdf.New("P", "mm", "A4", "")
|
||||
out.SetMargins(0, 0, 0)
|
||||
out.SetAutoPageBreak(false, 0)
|
||||
|
||||
importer := gofpdi.NewImporter()
|
||||
// Keep each source stream pointer alive so gofpdi sees a distinct source
|
||||
// identifier for every document.
|
||||
var readers []*io.ReadSeeker
|
||||
|
||||
for _, raw := range documents {
|
||||
if len(raw) == 0 {
|
||||
continue
|
||||
}
|
||||
reader := new(io.ReadSeeker)
|
||||
*reader = bytes.NewReader(raw)
|
||||
readers = append(readers, reader)
|
||||
|
||||
template := importer.ImportPageFromStream(out, reader, 1, "/MediaBox")
|
||||
sizes := importer.GetPageSizes()
|
||||
pages := len(sizes)
|
||||
if pages == 0 {
|
||||
return nil, fmt.Errorf("PDF ohne Seiten")
|
||||
}
|
||||
for page := 1; page <= pages; page++ {
|
||||
size, ok := sizes[page]["/MediaBox"]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("PDF-Seite %d ohne MediaBox", page)
|
||||
}
|
||||
width := pointsToMillimetres(size["w"])
|
||||
height := pointsToMillimetres(size["h"])
|
||||
// A4 portrait is passed explicitly: fpdf swaps width and height for
|
||||
// "L", which would turn an already landscape-sized box back into
|
||||
// portrait. "P" keeps the requested dimensions as they are.
|
||||
out.AddPageFormat("P", fpdf.SizeType{Wd: width, Ht: height})
|
||||
if page > 1 {
|
||||
template = importer.ImportPageFromStream(out, reader, page, "/MediaBox")
|
||||
}
|
||||
importer.UseImportedTemplate(out, template, 0, 0, width, height)
|
||||
}
|
||||
}
|
||||
runtime.KeepAlive(readers)
|
||||
|
||||
var buffer bytes.Buffer
|
||||
if err := out.Output(&buffer); err != nil {
|
||||
|
||||
+186
-1
@@ -115,7 +115,7 @@ func TestPDFUmlautsAreEncoded(t *testing.T) {
|
||||
Greeting: "Herzliche Grüße",
|
||||
Assignments: []DispatchAssignment{{
|
||||
Date: domain.MustDate("2026-11-15"), TimeMinutes: 9*60 + 30,
|
||||
Church: "St. Mariä Himmelfahrt", Title: "Hochamt für die Gemeinde", Role: domain.RoleLector,
|
||||
Church: "St. Mariä Himmelfahrt", Title: "Hochamt für die Gemeinde", RoleLabel: "Lektor",
|
||||
}},
|
||||
GeneratedAt: time.Now(),
|
||||
}
|
||||
@@ -311,3 +311,188 @@ func TestCompactPlanPaginatesWithoutContinuationTitle(t *testing.T) {
|
||||
t.Fatalf("footer count = %d, want %d", got, total)
|
||||
}
|
||||
}
|
||||
|
||||
// A cover sheet placed between plan pages used to be overwritten by the next
|
||||
// document's imported templates, so its letter text disappeared from the
|
||||
// dispatch packet.
|
||||
func TestMergeKeepsCoverBetweenPlanDocuments(t *testing.T) {
|
||||
r, rows, _, people := sampleRows()
|
||||
var cover bytes.Buffer
|
||||
if err := Cover(&cover, CoverData{
|
||||
TenantName: "Köln", Diocese: "Erzbistum Köln", Range: r, Person: people[0],
|
||||
Intro: "Liebe Lektorinnen und Lektoren, liebe Kommunionhelferinnen und -helfer,",
|
||||
Greeting: "Mit freundlichen Grüßen",
|
||||
GeneratedAt: time.Now(),
|
||||
}); err != nil {
|
||||
t.Fatalf("cover: %v", err)
|
||||
}
|
||||
var plan bytes.Buffer
|
||||
if err := CompactPlan(&plan, r, rows, people, Options{TenantName: "Köln"}); err != nil {
|
||||
t.Fatalf("plan: %v", err)
|
||||
}
|
||||
|
||||
merged, err := Merge([][]byte{plan.Bytes(), cover.Bytes(), plan.Bytes()})
|
||||
if err != nil {
|
||||
t.Fatalf("merge: %v", err)
|
||||
}
|
||||
content := string(pdfContentStreams(t, merged))
|
||||
if !strings.Contains(content, "Liebe Lektorinnen") {
|
||||
t.Fatal("cover letter text is missing from the merged packet")
|
||||
}
|
||||
if !strings.Contains(content, "Gottesdienstliste") {
|
||||
t.Fatal("plan text is missing from the merged packet")
|
||||
}
|
||||
|
||||
pages, err := documentPages(merged)
|
||||
if err != nil {
|
||||
t.Fatalf("page sizes: %v", err)
|
||||
}
|
||||
if len(pages) != 3 {
|
||||
t.Fatalf("merged page count = %d, want 3", len(pages))
|
||||
}
|
||||
for _, page := range pages {
|
||||
if page.width < 200 || page.width > 220 || page.height < 285 || page.height > 305 {
|
||||
t.Fatalf("page size = %.1f x %.1f mm, want A4 portrait", page.width, page.height)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPadToEvenPages(t *testing.T) {
|
||||
r, _, _, people := sampleRows()
|
||||
var cover bytes.Buffer
|
||||
if err := Cover(&cover, CoverData{
|
||||
TenantName: "Köln", Range: r, Person: people[0],
|
||||
Intro: "Ein kurzer Text.", GeneratedAt: time.Now(),
|
||||
}); err != nil {
|
||||
t.Fatalf("cover: %v", err)
|
||||
}
|
||||
if count, err := PageCount(cover.Bytes()); err != nil || count != 1 {
|
||||
t.Fatalf("cover page count = %d, %v; want 1", count, err)
|
||||
}
|
||||
padded, err := PadToEvenPages(cover.Bytes())
|
||||
if err != nil {
|
||||
t.Fatalf("pad cover: %v", err)
|
||||
}
|
||||
if count, err := PageCount(padded); err != nil || count != 2 {
|
||||
t.Fatalf("padded cover page count = %d, %v; want 2", count, err)
|
||||
}
|
||||
|
||||
even, err := Merge([][]byte{cover.Bytes(), cover.Bytes()})
|
||||
if err != nil {
|
||||
t.Fatalf("merge even document: %v", err)
|
||||
}
|
||||
unchanged, err := PadToEvenPages(even)
|
||||
if err != nil {
|
||||
t.Fatalf("pad even document: %v", err)
|
||||
}
|
||||
if !bytes.Equal(unchanged, even) {
|
||||
t.Fatal("a document with an even page count must not be changed")
|
||||
}
|
||||
|
||||
r, rows, churches, people := sampleRows()
|
||||
var landscape bytes.Buffer
|
||||
if err := FullPlan(&landscape, r, rows, churches, people, Options{TenantName: "Köln"}); err != nil {
|
||||
t.Fatalf("full plan: %v", err)
|
||||
}
|
||||
padded, err = PadToEvenPages(landscape.Bytes())
|
||||
if err != nil {
|
||||
t.Fatalf("pad full plan: %v", err)
|
||||
}
|
||||
pages, err := documentPages(padded)
|
||||
if err != nil {
|
||||
t.Fatalf("page sizes: %v", err)
|
||||
}
|
||||
if len(pages) != 2 {
|
||||
t.Fatalf("padded full plan page count = %d, want 2", len(pages))
|
||||
}
|
||||
for _, page := range pages {
|
||||
if page.width < 285 || page.width > 305 || page.height < 200 || page.height > 220 {
|
||||
t.Fatalf("page size = %.1f x %.1f mm, want A4 landscape", page.width, page.height)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The address block already names the recipient. The cover must not repeat the
|
||||
// name in parentheses at the end.
|
||||
func TestCoverNamesRecipientOnlyInAddressBlock(t *testing.T) {
|
||||
r, _, _, people := sampleRows()
|
||||
var buf bytes.Buffer
|
||||
if err := Cover(&buf, CoverData{
|
||||
TenantName: "Köln", Range: r, Person: people[0],
|
||||
Intro: "Ein kurzer Text.", Greeting: "Mit freundlichen Grüßen",
|
||||
GeneratedAt: time.Now(),
|
||||
}); err != nil {
|
||||
t.Fatalf("cover: %v", err)
|
||||
}
|
||||
content := string(pdfContentStreams(t, buf.Bytes()))
|
||||
if count := strings.Count(content, "Anna Berg"); count != 1 {
|
||||
t.Fatalf("recipient name appears %d times, want only the address block:\n%s", count, content)
|
||||
}
|
||||
if strings.Contains(content, "\\(Anna Berg\\)") {
|
||||
t.Fatalf("cover must not repeat the recipient in parentheses:\n%s", content)
|
||||
}
|
||||
}
|
||||
|
||||
// A dispatch packet mixes the portrait cover with the optional landscape plan.
|
||||
// Passing landscape dimensions together with fpdf's "L" orientation used to
|
||||
// swap them back to portrait and crop the plan.
|
||||
func TestMergeKeepsPortraitAndLandscapePages(t *testing.T) {
|
||||
r, rows, churches, people := sampleRows()
|
||||
var cover bytes.Buffer
|
||||
if err := Cover(&cover, CoverData{
|
||||
TenantName: "Köln", Range: r, Person: people[0],
|
||||
Intro: "Ein kurzer Text.", GeneratedAt: time.Now(),
|
||||
}); err != nil {
|
||||
t.Fatalf("cover: %v", err)
|
||||
}
|
||||
var plan bytes.Buffer
|
||||
if err := FullPlan(&plan, r, rows, churches, people, Options{TenantName: "Köln"}); err != nil {
|
||||
t.Fatalf("full plan: %v", err)
|
||||
}
|
||||
merged, err := Merge([][]byte{cover.Bytes(), plan.Bytes()})
|
||||
if err != nil {
|
||||
t.Fatalf("merge: %v", err)
|
||||
}
|
||||
pages, err := documentPages(merged)
|
||||
if err != nil {
|
||||
t.Fatalf("page sizes: %v", err)
|
||||
}
|
||||
if len(pages) != 2 {
|
||||
t.Fatalf("merged page count = %d, want 2", len(pages))
|
||||
}
|
||||
if pages[0].width >= pages[0].height {
|
||||
t.Fatalf("cover page is not portrait: %.1f x %.1f mm", pages[0].width, pages[0].height)
|
||||
}
|
||||
if pages[1].width <= pages[1].height {
|
||||
t.Fatalf("plan page is not landscape: %.1f x %.1f mm", pages[1].width, pages[1].height)
|
||||
}
|
||||
}
|
||||
|
||||
// The cover sheet must render the same letter text as the e-mail. A long
|
||||
// introduction used to run past the page because the cover is laid out with
|
||||
// explicit coordinates and page breaking was disabled.
|
||||
func TestCoverKeepsCompleteLetterText(t *testing.T) {
|
||||
r, _, _, people := sampleRows()
|
||||
firstParagraph := "Liebe Lektorinnen und Lektoren, liebe Kommunionhelferinnen und -helfer,"
|
||||
lastParagraph := "Der Schluss des langen Freitextes bleibt sichtbar."
|
||||
longMiddle := strings.Repeat("Dieser Satz füllt das Vorblatt über mehrere Seiten hinweg. ", 90)
|
||||
greeting := "Mit freundlichen Grüßen\nIhr Pfarreiteam"
|
||||
|
||||
var buf bytes.Buffer
|
||||
if err := Cover(&buf, CoverData{
|
||||
TenantName: "Köln", Range: r, Person: people[0],
|
||||
Intro: firstParagraph + "\n\n" + longMiddle + "\n\n" + lastParagraph,
|
||||
Greeting: greeting, GeneratedAt: time.Now(),
|
||||
}); err != nil {
|
||||
t.Fatalf("cover: %v", err)
|
||||
}
|
||||
content := string(pdfContentStreams(t, buf.Bytes()))
|
||||
for _, want := range []string{firstParagraph, lastParagraph, "Mit freundlichen"} {
|
||||
if !strings.Contains(content, want) {
|
||||
t.Fatalf("cover is missing %q:\n%s", want, content)
|
||||
}
|
||||
}
|
||||
if pages, err := PageCount(buf.Bytes()); err != nil || pages < 2 {
|
||||
t.Fatalf("long cover text should span several pages, got %d (%v)", pages, err)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user