Files
LektorenPlan/web/pdf/pdf.go
T

874 lines
25 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Package pdf renders printable service plans using only core PDF fonts.
package pdf
import (
"fmt"
"io"
"sort"
"strconv"
"strings"
"time"
"github.com/go-pdf/fpdf"
"lektorenplan/domain"
)
// Options configures the printable document.
type Options struct {
TenantName string
Diocese string
GeneratedAt time.Time
}
func (o Options) tenant() string {
if strings.TrimSpace(o.TenantName) == "" {
return "LektorenPlan"
}
return o.TenantName
}
func (o Options) diocese() string {
if strings.TrimSpace(o.Diocese) == "" {
return "Erzbistum Köln"
}
return o.Diocese
}
func (o Options) generated() time.Time {
if o.GeneratedAt.IsZero() {
return time.Now()
}
return o.GeneratedAt
}
// Palette is shared by both layouts.
type palette struct {
ink [3]int
secondary [3]int
tertiary [3]int
line [3]int
accent [3]int
gold [3]int
burgundy [3]int
sundayWash [3]int
feastWash [3]int
open [3]int
headerWash [3]int
}
var colors = palette{
ink: [3]int{31, 34, 40},
secondary: [3]int{97, 98, 99},
tertiary: [3]int{133, 130, 125},
line: [3]int{215, 210, 201},
accent: [3]int{46, 92, 87},
gold: [3]int{184, 135, 59},
burgundy: [3]int{125, 61, 74},
sundayWash: [3]int{251, 244, 226},
feastWash: [3]int{255, 244, 201},
open: [3]int{179, 107, 33},
headerWash: [3]int{245, 243, 238},
}
func newPDF(orientation string) *fpdf.Fpdf {
pdf := fpdf.New(orientation, "mm", "A4", "")
pdf.SetAutoPageBreak(false, 0)
pdf.SetCreator("LektorenPlan Web", true)
pdf.SetTitle("LektorenPlan – Gottesdienstplan", true)
pdf.SetMargins(8.5, 8.5, 8.5)
// The footer uses this alias for the total page count, which is only known
// when the document is closed.
pdf.AliasNbPages("{nb}")
return pdf
}
func translator(pdf *fpdf.Fpdf) func(string) string {
return pdf.UnicodeTranslatorFromDescriptor("cp1252")
}
func setColor(pdf *fpdf.Fpdf, c [3]int) {
pdf.SetTextColor(c[0], c[1], c[2])
}
func setFill(pdf *fpdf.Fpdf, c [3]int) {
pdf.SetFillColor(c[0], c[1], c[2])
}
func setDraw(pdf *fpdf.Fpdf, c [3]int) {
pdf.SetDrawColor(c[0], c[1], c[2])
}
func hexColor(value string, fallback [3]int) [3]int {
cleaned := strings.TrimPrefix(strings.TrimSpace(value), "#")
if len(cleaned) != 6 {
return fallback
}
parsed, err := strconv.ParseUint(cleaned, 16, 32)
if err != nil {
return fallback
}
return [3]int{int(parsed >> 16 & 0xFF), int(parsed >> 8 & 0xFF), int(parsed & 0xFF)}
}
// fitShorten truncates already encoded text to width. Both text and ellipsis
// must already be encoded for the current font, because core fonts are
// single-byte code pages and widths are measured per output byte.
func fitShorten(pdf *fpdf.Fpdf, text string, width float64, ellipsis string) string {
text = strings.TrimSpace(text)
if text == "" {
return ""
}
if pdf.GetStringWidth(text) <= width {
return text
}
for len(text) > 0 {
text = strings.TrimSpace(text[:len(text)-1])
candidate := text + ellipsis
if pdf.GetStringWidth(candidate) <= width {
return candidate
}
}
return ""
}
// fit translates text to the PDF code page and truncates it to width.
func fit(pdf *fpdf.Fpdf, tr func(string) string, text string, width float64) string {
return fitShorten(pdf, tr(text), width, tr("…"))
}
// wrap splits text into at most maxLines lines fitting width and returns them
// already encoded for the current font.
func wrap(pdf *fpdf.Fpdf, tr func(string) string, text string, width float64, maxLines int) []string {
return wrapEncoded(pdf, tr(text), width, maxLines, tr("…"))
}
func wrapEncoded(pdf *fpdf.Fpdf, text string, width float64, maxLines int, ellipsis string) []string {
text = strings.TrimSpace(text)
if text == "" || maxLines < 1 {
return nil
}
words := strings.Fields(text)
var lines []string
current := ""
for _, word := range words {
candidate := word
if current != "" {
candidate = current + " " + word
}
if pdf.GetStringWidth(candidate) <= width {
current = candidate
continue
}
if current != "" {
lines = append(lines, current)
if len(lines) == maxLines {
break
}
current = word
} else {
current = fitShorten(pdf, word, width, ellipsis)
}
}
if len(lines) < maxLines && current != "" {
lines = append(lines, current)
} else if len(lines) == maxLines && current != "" {
lines[len(lines)-1] = fitShorten(pdf, lines[len(lines)-1]+" "+current, width, ellipsis)
}
return lines
}
// writeLines writes lines that are already encoded for the current font; do
// not pass raw UTF-8 text here.
func writeLines(pdf *fpdf.Fpdf, lines []string, x, y, width, lineHeight float64) float64 {
for _, line := range lines {
pdf.SetXY(x, y)
pdf.CellFormat(width, lineHeight, line, "", 0, "L", false, 0, "")
y += lineHeight
}
return y
}
func drawBadge(pdf *fpdf.Fpdf, tr func(string) string, text string, x, y float64, color [3]int) {
pdf.SetFont("Helvetica", "B", 5.4)
width := pdf.GetStringWidth(tr(text)) + 3.2
setFill(pdf, color)
pdf.SetTextColor(255, 255, 255)
pdf.RoundedRect(x, y, width, 3.4, 1, "1234", "F")
pdf.SetXY(x, y+0.55)
pdf.CellFormat(width, 2.4, tr(text), "", 0, "C", false, 0, "")
}
func feastBadge(day *domain.LiturgicalDay) (string, [3]int) {
if day == nil {
return "", colors.accent
}
switch {
case day.IsHighFeast():
return "HOCHFEST", colors.gold
case day.Rank == domain.RankFeast:
return "FEST", colors.burgundy
case day.Rank == domain.RankObligatoryMemorial:
return "GEDENKTAG", colors.accent
case day.IsObligation && !day.IsSunday():
return "GEBOTEN", colors.accent
default:
return "", colors.accent
}
}
func shortWeekday(date time.Time) string {
return strings.ToUpper(domain.ShortWeekdayName(date))
}
func feastHint(day *domain.LiturgicalDay) string {
if day == nil || day.Title == "" {
return "Hochfest"
}
title := day.Title
if index := strings.Index(title, " – "); index >= 0 {
return title[index+len(" – "):]
}
if len([]rune(title)) <= 30 {
return title
}
if strings.Contains(strings.ToLower(title), "hochfest") {
return "Hochfest"
}
runes := []rune(title)
return string(runes[:28]) + "…"
}
func namesFor(service domain.ServiceWithAssignments, role domain.Role, people map[string]domain.Person) (string, int) {
needed := service.Service.RequiredCount(role)
assigned := service.AssignmentsFor(role)
lastNames := make([]string, 0, len(assigned))
for _, assignment := range assigned {
if person, ok := people[assignment.PersonID]; ok {
lastNames = append(lastNames, person.LastName)
}
}
open := needed - len(lastNames)
if open < 0 {
open = 0
}
parts := append([]string{}, lastNames...)
if open > 0 {
parts = append(parts, "offen")
}
if len(parts) == 0 {
return "offen", 0
}
return strings.Join(parts, ", "), open
}
// FullPlan writes the A4 landscape calendar.
func FullPlan(w io.Writer, r domain.DayRange, rows []domain.DayPlanRow, churches []domain.Church, people []domain.Person, opts Options) error {
pdf := newPDF("L")
tr := translator(pdf)
peopleByID := map[string]domain.Person{}
for _, person := range people {
peopleByID[person.ID] = person
}
const (
pageWidth = 297.0
pageHeight = 210.0
margin = 8.5
headerH = 26.0
colH = 8.5
footerH = 7.0
dateW = 17.0
liturgyW = 57.0
gap = 1.35
)
churchWidth := (pageWidth - margin*2 - dateW - liturgyW - gap*5) / 4
contentTop := margin + headerH + colH + 1.5
contentBottom := pageHeight - margin - footerH
columns := churches
if len(columns) > 4 {
columns = columns[:4]
}
drawHeader := func() {
setColor(pdf, colors.accent)
pdf.SetFont("Helvetica", "B", 6.4)
pdf.SetXY(margin, margin)
pdf.CellFormat(150, 3.4, tr("LEKTORENPLAN · "+strings.ToUpper(opts.tenant())), "", 0, "L", false, 0, "")
setColor(pdf, colors.ink)
pdf.SetFont("Times", "B", 15.5)
pdf.SetXY(margin, margin+4.6)
pdf.CellFormat(150, 7, tr("Gottesdienstplan"), "", 0, "L", false, 0, "")
setColor(pdf, colors.secondary)
pdf.SetFont("Helvetica", "", 8.2)
pdf.SetXY(margin, margin+13.2)
pdf.CellFormat(160, 4, tr(r.LongTitle()), "", 0, "L", false, 0, "")
rightX := pageWidth - margin - 82
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "", 6.8)
pdf.SetXY(rightX, margin)
pdf.CellFormat(82, 3.2, tr("Erstellt am "+domain.MediumString(opts.generated())), "", 0, "R", false, 0, "")
pdf.SetXY(rightX, margin+4.4)
pdf.CellFormat(82, 3.2, tr("Liturgischer Kalender: "+opts.diocese()), "", 0, "R", false, 0, "")
pdf.SetXY(rightX, margin+8.8)
pdf.CellFormat(82, 3.2, tr("Daten von www.eucharistiefeier.de"), "", 0, "R", false, 0, "")
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.25)
pdf.Line(margin, margin+headerH-2.2, pageWidth-margin, margin+headerH-2.2)
}
drawColumnHeader := func() {
y := margin + headerH
setFill(pdf, colors.headerWash)
pdf.Rect(margin, y, pageWidth-margin*2, colH, "F")
x := margin + 2
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "B", 5.8)
pdf.SetXY(x, y+2.8)
pdf.CellFormat(dateW-2, 3, tr("TAG"), "", 0, "L", false, 0, "")
x += dateW
pdf.SetXY(x, y+2.8)
pdf.CellFormat(liturgyW, 3, tr("LITURGIE & LESUNGEN"), "", 0, "L", false, 0, "")
x += liturgyW + gap
for _, church := range columns {
color := hexColor(church.ColorHex, colors.accent)
setColor(pdf, color)
pdf.SetFont("Times", "B", 8.2)
pdf.SetXY(x+1.3, y+1.2)
pdf.CellFormat(churchWidth-2.6, 4, fit(pdf, tr, church.Name, churchWidth-2.6), "", 0, "L", false, 0, "")
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "", 5.2)
pdf.SetXY(x+1.3, y+5.1)
pdf.CellFormat(churchWidth-2.6, 2.6, fit(pdf, tr, church.Address, churchWidth-2.6), "", 0, "L", false, 0, "")
x += churchWidth + gap
}
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.3)
pdf.Line(margin, y+colH, pageWidth-margin, y+colH)
}
drawFooter := func(page int) {
y := pageHeight - margin - footerH
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.25)
pdf.Line(margin, y+1.5, pageWidth-margin, y+1.5)
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "", 5.8)
pdf.SetXY(margin, y+2.6)
pdf.CellFormat(150, 3, tr("LektorenPlan · "+r.ShortTitle()), "", 0, "L", false, 0, "")
pdf.SetXY(pageWidth-margin-45, y+2.6)
pdf.CellFormat(45, 3, tr(fmt.Sprintf("Seite %d von {nb}", page)), "", 0, "R", false, 0, "")
}
rowHeight := func(row domain.DayPlanRow) float64 {
return fullPlanRowHeight(pdf, tr, row, churchWidth, peopleByID)
}
pdf.AddPage()
drawHeader()
drawColumnHeader()
page := 1
y := contentTop
if len(rows) == 0 {
setColor(pdf, colors.secondary)
pdf.SetFont("Times", "", 12)
pdf.SetXY(margin, y+4)
pdf.CellFormat(pageWidth-margin*2, 6, tr("Für den gewählten Zeitraum sind keine Gottesdienste hinterlegt."), "", 0, "L", false, 0, "")
}
for index, row := range rows {
height := rowHeight(row)
if y+height > contentBottom {
drawFooter(page)
page++
pdf.AddPage()
drawHeader()
drawColumnHeader()
y = contentTop
}
isSunday := row.IsSunday()
isFeast := row.IsHighFeast()
isHoliday := row.IsObligation() && !isSunday
if isFeast {
setFill(pdf, colors.feastWash)
pdf.Rect(margin, y, pageWidth-margin*2, height, "F")
} else if isSunday || isHoliday {
setFill(pdf, colors.sundayWash)
pdf.Rect(margin, y, pageWidth-margin*2, height, "F")
}
x := margin
// Date cell.
setColor(pdf, colors.tertiary)
if isSunday {
setColor(pdf, colors.burgundy)
}
pdf.SetFont("Helvetica", "B", 5.9)
pdf.SetXY(x+1.5, y+1.5)
pdf.CellFormat(dateW-1.5, 3, tr(shortWeekday(row.Date)), "", 0, "L", false, 0, "")
if isFeast {
setColor(pdf, colors.gold)
} else if isSunday {
setColor(pdf, colors.burgundy)
} else {
setColor(pdf, colors.ink)
}
pdf.SetFont("Times", "B", 13.5)
pdf.SetXY(x+1.5, y+4)
pdf.CellFormat(dateW-1.5, 6, tr(fmt.Sprintf("%d.", domain.DayNumber(row.Date))), "", 0, "L", false, 0, "")
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "", 5.9)
pdf.SetXY(x+1.5, y+11)
pdf.CellFormat(dateW-1.5, 3, tr(domain.ShortMonthName(row.Date)), "", 0, "L", false, 0, "")
if isSunday {
setColor(pdf, colors.burgundy)
pdf.SetFont("Helvetica", "B", 4.9)
pdf.SetXY(x+1.5, y+14.5)
pdf.CellFormat(dateW, 2.5, tr("SONNTAG"), "", 0, "L", false, 0, "")
}
x += dateW
// Liturgy.
textY := y + 1.6
if day := row.LiturgicalDay; day != nil {
if badge, color := feastBadge(day); badge != "" {
drawBadge(pdf, tr, badge, x+1.2, textY, color)
textY += 4.2
}
titleColor := colors.ink
if isSunday {
titleColor = colors.burgundy
}
setColor(pdf, titleColor)
fontStyle := "B"
if !day.IsFeast() {
fontStyle = ""
}
pdf.SetFont("Times", fontStyle, 8.2)
titleLines := wrap(pdf, tr, day.DisplayTitle(), liturgyW-4, 3)
textY = writeLines(pdf, titleLines, x+1.2, textY, liturgyW-4, 3.3)
if !day.Readings.IsEmpty() {
setColor(pdf, colors.secondary)
pdf.SetFont("Helvetica", "", 5.6)
readingLines := wrap(pdf, tr, day.Readings.ShortLabel(), liturgyW-4, 3)
writeLines(pdf, readingLines, x+1.2, textY+0.4, liturgyW-4, 2.5)
}
}
x += liturgyW + gap
// Church columns.
for _, church := range columns {
services := row.ServicesForChurch(church.ID)
serviceY := y + 1.4
color := hexColor(church.ColorHex, colors.accent)
for _, service := range services {
setColor(pdf, color)
pdf.SetFont("Helvetica", "B", 6.2)
label := fit(pdf, tr, service.Service.TimeLabel()+" "+service.Service.Title, churchWidth-4)
pdf.SetXY(x+1.2, serviceY)
pdf.CellFormat(churchWidth-2.4, 3.6, label, "", 0, "L", false, 0, "")
serviceY += 3.4
if service.Service.Location != nil && strings.TrimSpace(*service.Service.Location) != "" {
setColor(pdf, colors.burgundy)
pdf.SetFont("Helvetica", "B", 5.4)
pdf.SetXY(x+1.6, serviceY)
pdf.CellFormat(churchWidth-3, 2.8, fit(pdf, tr, *service.Service.Location, churchWidth-3), "", 0, "L", false, 0, "")
serviceY += 3.0
}
for _, role := range domain.AllRoles {
if service.Service.RequiredCount(role) <= 0 {
continue
}
names, open := namesFor(service, role, peopleByID)
prefix := "L: "
if role == domain.RoleHelper {
prefix = "K: "
}
text := prefix + names
if open > 0 {
setColor(pdf, colors.open)
pdf.SetFont("Helvetica", "B", 5.4)
} else {
setColor(pdf, colors.secondary)
pdf.SetFont("Helvetica", "", 5.4)
}
lines := wrap(pdf, tr, text, churchWidth-3, 2)
serviceY = writeLines(pdf, lines, x+1.6, serviceY, churchWidth-3, 3.0)
}
serviceY += 1.5
if serviceY > y+height-2 {
break
}
}
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.15)
pdf.Line(x, y+1.5, x, y+height-1.5)
x += churchWidth + gap
}
if index < len(rows)-1 {
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.2)
pdf.Line(margin, y+height, pageWidth-margin, y+height)
}
y += height
}
drawFooter(page)
if err := pdf.Output(w); err != nil {
return err
}
return pdf.Error()
}
// fullPlanRowHeight measures the space a day row actually needs. It mirrors the
// drawing code so a day with several services in one church grows instead of
// clipping the additional services.
func fullPlanRowHeight(pdf *fpdf.Fpdf, tr func(string) string, row domain.DayPlanRow, churchWidth float64, people map[string]domain.Person) float64 {
const liturgyWidth = 57.0
// Base height covers the date cell including the optional SONNTAG label.
height := 15.0
if row.IsSunday() {
height = 18.0
}
if row.LiturgicalDay != nil {
style := "B"
if !row.LiturgicalDay.IsFeast() {
style = ""
}
pdf.SetFont("Times", style, 8.2)
titles := wrap(pdf, tr, row.LiturgicalDay.DisplayTitle(), liturgyWidth-4, 3)
lit := 1.6 + float64(len(titles))*3.3
if badge, _ := feastBadge(row.LiturgicalDay); badge != "" {
lit += 4.2
}
if !row.LiturgicalDay.Readings.IsEmpty() {
pdf.SetFont("Helvetica", "", 5.6)
readings := wrap(pdf, tr, row.LiturgicalDay.Readings.ShortLabel(), liturgyWidth-4, 3)
lit += 0.4 + float64(len(readings))*2.5
}
lit += 2.0
if lit > height {
height = lit
}
}
churchHeights := map[string]float64{}
var churchOrder []string
for _, service := range row.Services {
// 1.4 top padding + 3.4 service line + 1.5 gap below the service.
h := 6.3
if service.Service.Location != nil && strings.TrimSpace(*service.Service.Location) != "" {
h += 3.0
}
for _, role := range domain.AllRoles {
if service.Service.RequiredCount(role) <= 0 {
continue
}
prefix := "L: "
if role == domain.RoleHelper {
prefix = "K: "
}
names, open := namesFor(service, role, people)
weight := ""
if open > 0 {
weight = "B"
}
pdf.SetFont("Helvetica", weight, 5.4)
lines := wrap(pdf, tr, prefix+names, churchWidth-3, 2)
h += float64(len(lines)) * 3.0
}
// Services in the same church column stack vertically.
if _, ok := churchHeights[service.Church.ID]; !ok {
churchOrder = append(churchOrder, service.Church.ID)
}
churchHeights[service.Church.ID] += h
}
for _, id := range churchOrder {
if churchHeights[id] > height {
height = churchHeights[id]
}
}
return height
}
// CompactPlan writes the A4 portrait service list.
func CompactPlan(w io.Writer, r domain.DayRange, rows []domain.DayPlanRow, people []domain.Person, opts Options) error {
pdf := newPDF("P")
tr := translator(pdf)
peopleByID := map[string]domain.Person{}
for _, person := range people {
peopleByID[person.ID] = person
}
const (
pageWidth = 210.0
pageHeight = 297.0
margin = 12.7
headerH = 24.7
colH = 8.1
footerH = 8.5
dateW = 25.0
serviceW = 69.0
lectorW = 41.0
gap = 2.8
)
helperW := pageWidth - margin*2 - dateW - serviceW - lectorW - gap*3
contentTop := margin + headerH + colH + 2
contentBottom := pageHeight - margin - footerH
drawHeader := func(continuation bool) {
setColor(pdf, colors.accent)
pdf.SetFont("Helvetica", "B", 6.2)
pdf.SetXY(margin, margin)
pdf.CellFormat(120, 3.2, tr("LEKTORENPLAN · "+strings.ToUpper(opts.tenant())), "", 0, "L", false, 0, "")
setColor(pdf, colors.ink)
pdf.SetFont("Times", "B", 17)
title := "Gottesdienstliste"
if continuation {
title = "Gottesdienstliste · Fortsetzung"
}
pdf.SetXY(margin, margin+4.4)
pdf.CellFormat(130, 6.5, tr(title), "", 0, "L", false, 0, "")
setColor(pdf, colors.secondary)
pdf.SetFont("Helvetica", "", 7.8)
pdf.SetXY(margin, margin+13)
pdf.CellFormat(120, 4, tr(r.LongTitle()), "", 0, "L", false, 0, "")
rightX := pageWidth - margin - 62
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "B", 6.4)
pdf.SetXY(rightX, margin)
pdf.CellFormat(62, 3.2, tr("A4 hoch · kompakte Liste"), "", 0, "R", false, 0, "")
pdf.SetFont("Helvetica", "", 6.4)
pdf.SetXY(rightX, margin+4.5)
pdf.CellFormat(62, 3.2, tr("Erstellt am "+domain.MediumString(opts.generated())), "", 0, "R", false, 0, "")
pdf.SetXY(rightX, margin+9)
pdf.CellFormat(62, 3.2, tr("Daten von www.eucharistiefeier.de"), "", 0, "R", false, 0, "")
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.25)
pdf.Line(margin, margin+headerH-2.2, pageWidth-margin, margin+headerH-2.2)
}
drawColumnHeader := func() {
y := margin + headerH
setFill(pdf, colors.headerWash)
pdf.Rect(margin, y, pageWidth-margin*2, colH, "F")
x := margin + 2
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "B", 5.8)
headers := []struct {
Text string
Width float64
}{
{"TAG", dateW - 2}, {"GOTTESDIENST", serviceW}, {"LEKTOREN", lectorW}, {"KOMMUNIONHELFER", helperW},
}
for _, header := range headers {
pdf.SetXY(x, y+2.7)
pdf.CellFormat(header.Width, 3, tr(header.Text), "", 0, "L", false, 0, "")
x += header.Width + gap
}
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.3)
pdf.Line(margin, y+colH, pageWidth-margin, y+colH)
}
drawFooter := func(page int) {
y := pageHeight - margin - footerH
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.25)
pdf.Line(margin, y+1.5, pageWidth-margin, y+1.5)
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "", 5.8)
pdf.SetXY(margin, y+2.6)
pdf.CellFormat(150, 3, tr("LektorenPlan · kompakte Liste · "+r.ShortTitle()), "", 0, "L", false, 0, "")
pdf.SetXY(pageWidth-margin-45, y+2.6)
pdf.CellFormat(45, 3, tr(fmt.Sprintf("Seite %d von {nb}", page)), "", 0, "R", false, 0, "")
}
rowHeight := func(service domain.ServiceWithAssignments) float64 {
height := 7.0
if service.Service.Title != "" {
height += 1.8
}
lectorNames, _ := namesFor(service, domain.RoleLector, peopleByID)
helperNames, _ := namesFor(service, domain.RoleHelper, peopleByID)
lectorLines := len(wrap(pdf, tr, lectorNames, lectorW-2, 2))
helperLines := len(wrap(pdf, tr, helperNames, helperW-2, 2))
if lines := maxInt(lectorLines, helperLines); float64(lines)*3 > height {
height = float64(lines) * 3
}
if len(service.AssignmentsFor(domain.RoleLector)) == 0 && service.Service.RequiredCount(domain.RoleLector) > 0 {
height += 1.2
}
return maxFloat(height, 8.2) + 1.6
}
pdf.AddPage()
drawHeader(false)
drawColumnHeader()
page := 1
y := contentTop
visibleDays := 0
for _, row := range rows {
if len(row.Services) > 0 {
visibleDays++
}
}
if visibleDays == 0 {
setColor(pdf, colors.secondary)
pdf.SetFont("Times", "", 12)
pdf.SetXY(margin, y+5)
pdf.CellFormat(pageWidth-margin*2, 6, tr("Für den gewählten Zeitraum sind keine Gottesdienste hinterlegt."), "", 0, "L", false, 0, "")
}
for dayIndex, row := range rows {
if len(row.Services) == 0 {
continue
}
services := append([]domain.ServiceWithAssignments(nil), row.Services...)
sortServices(services)
for serviceIndex, service := range services {
height := rowHeight(service)
if y+height > contentBottom {
drawFooter(page)
page++
pdf.AddPage()
drawHeader(true)
drawColumnHeader()
y = contentTop
}
if row.IsHighFeast() {
setFill(pdf, colors.feastWash)
pdf.Rect(margin, y, pageWidth-margin*2, height, "F")
} else if row.IsSunday() {
setFill(pdf, colors.sundayWash)
pdf.Rect(margin, y, pageWidth-margin*2, height, "F")
}
if serviceIndex == 0 {
setColor(pdf, colors.tertiary)
if row.IsSunday() || row.IsHighFeast() {
setColor(pdf, colors.burgundy)
}
pdf.SetFont("Helvetica", "B", 5.8)
pdf.SetXY(margin+1.5, y+1.8)
pdf.CellFormat(dateW-2, 3, tr(shortWeekday(row.Date)), "", 0, "L", false, 0, "")
if row.IsHighFeast() {
setColor(pdf, colors.gold)
} else if row.IsSunday() {
setColor(pdf, colors.burgundy)
} else {
setColor(pdf, colors.ink)
}
pdf.SetFont("Times", "B", 12.5)
pdf.SetXY(margin+1.5, y+4.3)
pdf.CellFormat(dateW-2, 5, tr(fmt.Sprintf("%d.%d.", domain.DayNumber(row.Date), domain.Month(row.Date))), "", 0, "L", false, 0, "")
if row.IsHighFeast() {
setColor(pdf, colors.gold)
pdf.SetFont("Helvetica", "B", 5.2)
hint := wrap(pdf, tr, feastHint(row.LiturgicalDay), dateW-4, 3)
writeLines(pdf, hint, margin+1.5, y+10, dateW-4, 2.4)
}
}
x := margin + dateW + gap
churchColor := hexColor(service.Church.ColorHex, colors.accent)
setColor(pdf, churchColor)
pdf.SetFont("Helvetica", "B", 7.2)
place := service.Service.PlaceName(service.Church)
line := fit(pdf, tr, service.Service.TimeLabel()+" · "+place, serviceW-2)
pdf.SetXY(x, y+1.6)
pdf.CellFormat(serviceW-2, 3.4, line, "", 0, "L", false, 0, "")
if service.Service.Title != "" {
setColor(pdf, colors.secondary)
if service.Service.Kind == domain.KindSpecial {
setColor(pdf, colors.burgundy)
}
pdf.SetFont("Helvetica", "", 6.1)
title := service.Service.Title
if service.Service.Kind == domain.KindSpecial {
title += " · Sondergottesdienst"
}
pdf.SetXY(x, y+4.8)
pdf.CellFormat(serviceW-2, 3, fit(pdf, tr, title, serviceW-2), "", 0, "L", false, 0, "")
}
x += serviceW + gap
drawRole := func(role domain.Role, width float64) {
needed := service.Service.RequiredCount(role)
if needed <= 0 {
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "", 6.6)
pdf.SetXY(x, y+1.8)
pdf.CellFormat(width, 3, tr("—"), "", 0, "L", false, 0, "")
return
}
names, open := namesFor(service, role, peopleByID)
if open > 0 {
setColor(pdf, colors.open)
pdf.SetFont("Helvetica", "B", 6.6)
} else {
setColor(pdf, colors.ink)
pdf.SetFont("Helvetica", "", 6.6)
}
lines := wrap(pdf, tr, names, width, 2)
writeLines(pdf, lines, x, y+1.8, width, 3)
}
drawRole(domain.RoleLector, lectorW)
x += lectorW + gap
drawRole(domain.RoleHelper, helperW)
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.15)
pdf.Line(margin, y+height, pageWidth-margin, y+height)
y += height
}
if dayIndex < len(rows)-1 {
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.3)
pdf.Line(margin+1, y, pageWidth-margin-1, y)
}
}
drawFooter(page)
if err := pdf.Output(w); err != nil {
return err
}
return pdf.Error()
}
func sortServices(services []domain.ServiceWithAssignments) {
sort.SliceStable(services, func(i, j int) bool {
a, b := services[i].Service, services[j].Service
if a.TimeMinutes != b.TimeMinutes {
return a.TimeMinutes < b.TimeMinutes
}
return services[i].Church.SortIndex < services[j].Church.SortIndex
})
}
func maxInt(a, b int) int {
if a > b {
return a
}
return b
}
func maxFloat(a, b float64) float64 {
if a > b {
return a
}
return b
}