1. Version Versendung

This commit is contained in:
concierge committed 2026-11-14 09:33:17 +01:00
1 parent d7113afa5f
commit 781aa20253
31 files changed
+4023 -10

No files matched your search

+2
View File
@@ -13,6 +13,8 @@ require (
github.com/google/uuid v1.6.0 // indirect
github.com/mattn/go-isatty v0.0.24 // indirect
github.com/ncruces/go-strftime v1.1.0 // indirect
github.com/phpdave11/gofpdi v1.0.16 // indirect
github.com/pkg/errors v0.9.1 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
golang.org/x/sys v0.50.0 // indirect
modernc.org/libc v1.80.1 // indirect
+5
View File
@@ -12,6 +12,11 @@ github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsRe
github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
github.com/ncruces/go-strftime v1.1.0 h1:vtPmPWMkb539RGV9WpWT9EwJGvrOCKvMNI4obWL47Hk=
github.com/ncruces/go-strftime v1.1.0/go.mod h1:yVaq7iwCN09vHRrKBrrflXT0M9tTMG2KmZ9Fj7xeG/g=
github.com/phpdave11/gofpdi v1.0.16 h1:4qi0x31yujXmS4F6L4ZJKtd1DqG/3H/bpQzEZh2dmhY=
github.com/phpdave11/gofpdi v1.0.16/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
golang.org/x/crypto v0.59.0 h1:xS2jhqYbzNrpvkWP2YTDf4TJwBy3ykR03i8vFDxEc7c=
+202
View File
@@ -0,0 +1,202 @@
package pdf
import (
"fmt"
"io"
"strings"
"time"
"lektorenplan/domain"
)
// DispatchAssignment is one entry in a recipient's personal overview.
type DispatchAssignment struct {
Date time.Time
TimeMinutes int
Church string
Title string
Role domain.Role
}
// CoverData describes the personal cover sheet of a dispatch packet.
type CoverData struct {
TenantName string
Diocese string
Range domain.DayRange
Person domain.Person
Intro string
Greeting string
Assignments []DispatchAssignment
GeneratedAt time.Time
}
// AssignmentLines returns the personal assignments as readable lines.
func AssignmentLines(assignments []DispatchAssignment) []string {
lines := make([]string, 0, len(assignments))
for _, assignment := range assignments {
lines = append(lines, fmt.Sprintf("%s · %s · %s · %s (%s)",
domain.ShortWeekdayName(assignment.Date),
domain.MediumString(assignment.Date),
domain.TimeString(assignment.TimeMinutes),
assignment.Church,
assignment.Role.Title()))
}
return lines
}
func coverOptions(data CoverData) Options {
return Options{TenantName: data.TenantName, Diocese: data.Diocese, GeneratedAt: data.GeneratedAt}
}
// Cover writes an A4 portrait cover letter with the personal assignment overview.
func Cover(w io.Writer, data CoverData) error {
pdf := newPDF("P")
tr := translator(pdf)
opts := coverOptions(data)
const (
pageWidth = 210.0
margin = 18.0
contentW = pageWidth - margin*2
)
pdf.AddPage()
// Header ---------------------------------------------------------------
setColor(pdf, colors.accent)
pdf.SetFont("Helvetica", "B", 7)
pdf.SetXY(margin, margin)
pdf.CellFormat(contentW, 4, tr("LEKTORENPLAN · "+strings.ToUpper(opts.tenant())), "", 0, "L", false, 0, "")
setColor(pdf, colors.ink)
pdf.SetFont("Times", "B", 20)
pdf.SetXY(margin, margin+6)
pdf.CellFormat(contentW, 9, tr("Gottesdienstplan"), "", 0, "L", false, 0, "")
setColor(pdf, colors.secondary)
pdf.SetFont("Helvetica", "", 10)
pdf.SetXY(margin, margin+16)
pdf.CellFormat(contentW, 5, tr(data.Range.LongTitle()), "", 0, "L", false, 0, "")
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.3)
pdf.Line(margin, margin+24, pageWidth-margin, margin+24)
// Recipient ------------------------------------------------------------
y := margin + 33
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "B", 6.5)
pdf.SetXY(margin, y)
pdf.CellFormat(contentW, 3.5, tr("EMPFÄNGER"), "", 0, "L", false, 0, "")
setColor(pdf, colors.ink)
pdf.SetFont("Times", "B", 13)
pdf.SetXY(margin, y+4.5)
pdf.CellFormat(contentW, 6, tr(data.Person.FullName()), "", 0, "L", false, 0, "")
if strings.TrimSpace(data.Person.Email) != "" {
setColor(pdf, colors.secondary)
pdf.SetFont("Helvetica", "", 8)
pdf.SetXY(margin, y+10.5)
pdf.CellFormat(contentW, 4, tr(data.Person.Email), "", 0, "L", false, 0, "")
}
y += 22
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "", 7)
pdf.SetXY(margin, y)
pdf.CellFormat(contentW, 4, tr("Erstellt am "+domain.MediumString(opts.generated())), "", 0, "R", false, 0, "")
// Letter text ----------------------------------------------------------
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
// Assignment table -----------------------------------------------------
setColor(pdf, colors.ink)
pdf.SetFont("Times", "B", 12.5)
pdf.SetXY(margin, y)
pdf.CellFormat(contentW, 6, tr("Ihre Einsätze im Planungszeitraum"), "", 0, "L", false, 0, "")
y += 9
if len(data.Assignments) == 0 {
setColor(pdf, colors.secondary)
pdf.SetFont("Times", "", 10.5)
pdf.SetXY(margin, y)
pdf.MultiCell(contentW, 5.2, tr("Für Sie sind in diesem Zeitraum keine Einsätze eingetragen."), "", "L", false)
y = pdf.GetY() + 8
} else {
columns := []struct {
Label string
Width float64
}{
{"Tag", 50}, {"Zeit", 20}, {"Ort", 44}, {"Dienst", contentW - 114},
}
setFill(pdf, colors.headerWash)
pdf.Rect(margin, y, contentW, 7.5, "F")
x := margin + 2
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "B", 6.3)
for _, column := range columns {
pdf.SetXY(x, y+2.2)
pdf.CellFormat(column.Width-2, 3.4, tr(strings.ToUpper(column.Label)), "", 0, "L", false, 0, "")
x += column.Width
}
y += 7.5
setDraw(pdf, colors.line)
pdf.Line(margin, y, pageWidth-margin, y)
for _, assignment := range data.Assignments {
if y > 252 {
pdf.AddPage()
y = margin
}
rowHeight := 8.2
setColor(pdf, colors.ink)
pdf.SetFont("Helvetica", "", 7.6)
x = margin + 2
dayLabel := fmt.Sprintf("%s, %d.%d.%d", domain.ShortWeekdayName(assignment.Date),
domain.DayNumber(assignment.Date), domain.Month(assignment.Date), domain.Year(assignment.Date))
values := []string{
dayLabel,
domain.TimeString(assignment.TimeMinutes),
assignment.Church,
assignment.Role.Title() + " · " + assignment.Title,
}
for index, column := range columns {
pdf.SetXY(x, y+2.1)
pdf.CellFormat(column.Width-2, 3.8, tr(fit(pdf, values[index], column.Width-2)), "", 0, "L", false, 0, "")
x += column.Width
}
y += rowHeight
setDraw(pdf, colors.line)
pdf.SetLineWidth(0.15)
pdf.Line(margin, y, pageWidth-margin, y)
}
y += 8
}
// 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)
}
// Footer ---------------------------------------------------------------
setColor(pdf, colors.tertiary)
pdf.SetFont("Helvetica", "", 6.5)
pdf.SetXY(margin, 284)
pdf.CellFormat(contentW, 3.4, tr("LektorenPlan · "+opts.tenant()+" · "+data.Range.ShortTitle()), "", 0, "L", false, 0, "")
if err := pdf.Output(w); err != nil {
return err
}
return pdf.Error()
}
+58
View File
@@ -0,0 +1,58 @@
package pdf
import (
"bytes"
"fmt"
"io"
"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) {
out := fpdf.New("P", "mm", "A4", "")
out.SetMargins(0, 0, 0)
out.SetAutoPageBreak(false, 0)
for _, raw := range documents {
if len(raw) == 0 {
continue
}
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)
}
}
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
}
+30 -1
View File
@@ -250,6 +250,35 @@ CREATE TABLE IF NOT EXISTS tenant_settings (
value TEXT NOT NULL,
PRIMARY KEY (tenant_id, key)
);
CREATE TABLE IF NOT EXISTS dispatch_preferences (
tenant_id TEXT NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
person_id TEXT NOT NULL,
channel TEXT NOT NULL DEFAULT 'email',
variant TEXT NOT NULL DEFAULT 'compact',
cover INTEGER NOT NULL DEFAULT 1,
updated_at TEXT NOT NULL,
PRIMARY KEY (tenant_id, person_id)
);
CREATE TABLE IF NOT EXISTS dispatch_log (
id TEXT PRIMARY KEY,
tenant_id TEXT NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
batch_id TEXT NOT NULL,
range_start TEXT NOT NULL,
range_end TEXT NOT NULL,
person_id TEXT NOT NULL DEFAULT '',
person_name TEXT NOT NULL DEFAULT '',
channel TEXT NOT NULL,
variant TEXT NOT NULL DEFAULT '',
cover INTEGER NOT NULL DEFAULT 0,
email TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL,
detail TEXT NOT NULL DEFAULT '',
created_at TEXT NOT NULL,
created_by TEXT NOT NULL DEFAULT ''
);
CREATE INDEX IF NOT EXISTS idx_dispatch_log_tenant ON dispatch_log(tenant_id, created_at);
`
func (s *Store) migrate(ctx context.Context) error {
@@ -280,7 +309,7 @@ func (s *Store) migrate(ctx context.Context) error {
}
}
if _, err := s.db.ExecContext(ctx,
"INSERT INTO schema_meta(key, value) VALUES('schemaVersion', '2') "+
"INSERT INTO schema_meta(key, value) VALUES('schemaVersion', '3') "+
"ON CONFLICT(key) DO UPDATE SET value=excluded.value"); err != nil {
return fmt.Errorf("record schema version: %w", err)
}
+136
View File
@@ -0,0 +1,136 @@
package store
import (
"context"
"database/sql"
"time"
"lektorenplan/domain"
)
// DispatchPreference stores how one person receives the plan.
type DispatchPreference struct {
Channel string
Variant string
Cover bool
}
// DispatchLogEntry records one dispatch action for one person.
type DispatchLogEntry struct {
ID string
TenantID string
BatchID string
RangeStart time.Time
RangeEnd time.Time
PersonID string
PersonName string
Channel string
Variant string
Cover bool
Email string
Status string
Detail string
CreatedAt time.Time
CreatedBy string
}
// DispatchPreferences loads the saved preferences of a tenant.
func (s *Store) DispatchPreferences(ctx context.Context, tenantID string) (map[string]DispatchPreference, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT person_id, channel, variant, cover
FROM dispatch_preferences WHERE tenant_id=?`, tenantID)
if err != nil {
return nil, err
}
defer rows.Close()
out := map[string]DispatchPreference{}
for rows.Next() {
var personID string
var cover int
var preference DispatchPreference
if err := rows.Scan(&personID, &preference.Channel, &preference.Variant, &cover); err != nil {
return nil, err
}
preference.Cover = cover != 0
out[personID] = preference
}
return out, rows.Err()
}
// SaveDispatchPreference stores one person's dispatch preference.
func (s *Store) SaveDispatchPreference(ctx context.Context, tenantID, personID, channel, variant string, cover bool) error {
_, err := s.db.ExecContext(ctx, `
INSERT INTO dispatch_preferences(tenant_id, person_id, channel, variant, cover, updated_at)
VALUES(?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, person_id) DO UPDATE SET
channel=excluded.channel, variant=excluded.variant,
cover=excluded.cover, updated_at=excluded.updated_at`,
tenantID, personID, channel, variant, boolInt(cover), nowText())
return err
}
// DispatchLog returns the most recent dispatch entries of a tenant.
func (s *Store) DispatchLog(ctx context.Context, tenantID string, limit int) ([]DispatchLogEntry, error) {
if limit < 1 {
limit = 1
}
if limit > 500 {
limit = 500
}
rows, err := s.db.QueryContext(ctx, `
SELECT id, tenant_id, batch_id, range_start, range_end, person_id, person_name,
channel, variant, cover, email, status, detail, created_at, created_by
FROM dispatch_log WHERE tenant_id=?
ORDER BY created_at DESC, id DESC LIMIT ?`, tenantID, limit)
if err != nil {
return nil, err
}
defer rows.Close()
var out []DispatchLogEntry
for rows.Next() {
var entry DispatchLogEntry
var rangeStart, rangeEnd, created string
var cover int
if err := rows.Scan(&entry.ID, &entry.TenantID, &entry.BatchID, &rangeStart,
&rangeEnd, &entry.PersonID, &entry.PersonName, &entry.Channel,
&entry.Variant, &cover, &entry.Email, &entry.Status, &entry.Detail,
&created, &entry.CreatedBy); err != nil {
return nil, err
}
entry.RangeStart = domain.MustDate(rangeStart)
entry.RangeEnd = domain.MustDate(rangeEnd)
entry.Cover = cover != 0
entry.CreatedAt = parseTime(created)
out = append(out, entry)
}
return out, rows.Err()
}
// AppendDispatchLog records a batch of dispatch actions.
func (s *Store) AppendDispatchLog(ctx context.Context, entries []DispatchLogEntry) error {
if len(entries) == 0 {
return nil
}
return s.transaction(ctx, func(tx *sql.Tx) error {
for _, entry := range entries {
if entry.ID == "" {
entry.ID = domain.NewID()
}
if entry.CreatedAt.IsZero() {
entry.CreatedAt = time.Now().UTC()
}
if _, err := tx.ExecContext(ctx, `
INSERT INTO dispatch_log(id, tenant_id, batch_id, range_start, range_end,
person_id, person_name, channel, variant, cover, email, status, detail,
created_at, created_by)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
entry.ID, entry.TenantID, entry.BatchID, domain.Key(entry.RangeStart),
domain.Key(entry.RangeEnd), entry.PersonID, entry.PersonName, entry.Channel,
entry.Variant, boolInt(entry.Cover), entry.Email, entry.Status, entry.Detail,
entry.CreatedAt.Format(time.RFC3339), entry.CreatedBy); err != nil {
return err
}
}
return nil
})
}
+2
View File
@@ -99,6 +99,8 @@ func (s *Store) DeleteAllTenantData(ctx context.Context, tenantID string) error
"DELETE FROM absences WHERE tenant_id=?",
"DELETE FROM people WHERE tenant_id=?",
"DELETE FROM churches WHERE tenant_id=?",
"DELETE FROM dispatch_preferences WHERE tenant_id=?",
"DELETE FROM dispatch_log WHERE tenant_id=?",
"DELETE FROM tenant_settings WHERE tenant_id=?",
}
for _, statement := range statements {
+678
View File
@@ -0,0 +1,678 @@
package web
import (
"bytes"
"context"
"fmt"
"net/http"
"sort"
"strconv"
"strings"
"text/tabwriter"
"time"
"lektorenplan/domain"
"lektorenplan/pdf"
"lektorenplan/store"
)
const (
defaultDispatchIntro = "Liebe Lektorinnen und Lektoren, liebe Kommunionhelferinnen und -helfer,\n\n" +
"anbei sende ich den Plan für den Zeitraum von {start} bis {end}. " +
"Dabei konnten hoffentlich alle Wünsche und Termine berücksichtigt werden."
defaultDispatchGreeting = "Mit freundlichen Grüßen\nIhr Pfarreiteam"
dispatchChannelEmail = "email"
dispatchChannelPrint = "print"
dispatchChannelNone = "none"
dispatchVariantCompact = "compact"
dispatchVariantFull = "full"
dispatchIntroKey = "dispatch.intro"
dispatchGreetingKey = "dispatch.greeting"
)
type dispatchAssignmentView struct {
Date time.Time
DateLabel string
TimeLabel string
Church string
Title string
Role domain.Role
RoleLabel string
SortMinutes int
}
type dispatchPersonView struct {
Person domain.Person
Channel string
Variant string
Cover bool
Effective string
Assignments []dispatchAssignmentView
AssignmentCount int
}
type dispatchPageData struct {
Range domain.DayRange
Start string
End string
PrevStart string
PrevEnd string
NextStart string
NextEnd string
People []dispatchPersonView
Intro string
Greeting string
SMTPConfigured bool
SMTPFrom string
EmailCount int
PrintCount int
NoneCount int
LastEntry *store.DispatchLogEntry
LastBatch []store.DispatchLogEntry
History []store.DispatchLogEntry
OpenSlots int
ServiceCount int
}
type dispatchSelection struct {
Channel string
Variant string
Cover bool
}
type dispatchForm struct {
Range domain.DayRange
Intro string
Greeting string
Selections map[string]dispatchSelection
}
func dispatchDateLabel(t time.Time) string {
return fmt.Sprintf("%d. %s %d", domain.DayNumber(t), domain.MonthName(t), domain.Year(t))
}
func dispatchChannelLabel(channel string) string {
switch channel {
case dispatchChannelEmail:
return "E-Mail"
case dispatchChannelPrint:
return "Ausdruck"
case dispatchChannelNone:
return "Nicht versenden"
default:
return channel
}
}
func dispatchVariantLabel(variant string) string {
if normalizeDispatchVariant(variant) == dispatchVariantFull {
return "Ausführlicher Plan"
}
return "Kompaktansicht"
}
func dispatchStatusLabel(status string) string {
switch status {
case "sent":
return "E-Mail versendet"
case "failed":
return "Fehlgeschlagen"
case "pdf":
return "Druck-PDF erzeugt"
default:
return status
}
}
func resolveDispatchText(value string, rng domain.DayRange) string {
value = strings.ReplaceAll(value, "{start}", dispatchDateLabel(rng.Start))
value = strings.ReplaceAll(value, "{end}", dispatchDateLabel(rng.End))
value = strings.ReplaceAll(value, "{{start}}", dispatchDateLabel(rng.Start))
value = strings.ReplaceAll(value, "{{end}}", dispatchDateLabel(rng.End))
return strings.TrimSpace(value)
}
// dispatchTexts returns the stored intro and greeting. An empty stored intro
// falls back to the default wording, while an empty greeting stays empty so
// editors can deliberately omit it.
func (s *Server) dispatchTexts(ctx context.Context, tenantID string) (intro, greeting string) {
settings, err := s.store.AllTenantSettings(ctx, tenantID)
if err != nil {
return defaultDispatchIntro, defaultDispatchGreeting
}
intro = defaultDispatchIntro
if value, ok := settings[dispatchIntroKey]; ok && strings.TrimSpace(value) != "" {
intro = value
}
greeting = defaultDispatchGreeting
if value, ok := settings[dispatchGreetingKey]; ok {
greeting = value
}
return intro, greeting
}
func normalizeDispatchChannel(channel, email string) string {
switch strings.ToLower(strings.TrimSpace(channel)) {
case dispatchChannelEmail:
return dispatchChannelEmail
case dispatchChannelPrint:
return dispatchChannelPrint
case dispatchChannelNone:
return dispatchChannelNone
}
if strings.TrimSpace(email) != "" {
return dispatchChannelEmail
}
return dispatchChannelPrint
}
func normalizeDispatchVariant(variant string) string {
if strings.EqualFold(strings.TrimSpace(variant), dispatchVariantFull) {
return dispatchVariantFull
}
return dispatchVariantCompact
}
func effectiveDispatchChannel(channel, email string) string {
if channel == dispatchChannelEmail && strings.TrimSpace(email) == "" {
return dispatchChannelPrint
}
return channel
}
func dispatchAssignments(rows []domain.DayPlanRow, personID string) []dispatchAssignmentView {
var out []dispatchAssignmentView
for _, row := range rows {
for _, service := range row.Services {
for _, assignment := range service.Assignments {
if assignment.PersonID != personID {
continue
}
out = append(out, dispatchAssignmentView{
Date: row.Date, DateLabel: domain.MediumString(row.Date),
TimeLabel: domain.TimeString(service.Service.TimeMinutes),
Church: service.Church.ShortName, Title: service.Service.Title,
Role: assignment.Role, RoleLabel: assignment.Role.Title(),
SortMinutes: service.Service.TimeMinutes,
})
}
}
}
sort.SliceStable(out, func(i, j int) bool {
if !out[i].Date.Equal(out[j].Date) {
return out[i].Date.Before(out[j].Date)
}
return out[i].SortMinutes < out[j].SortMinutes
})
return out
}
func (s *Server) dispatchPeople(ctx context.Context, tenantID string, rows []domain.DayPlanRow) ([]dispatchPersonView, error) {
people, err := s.store.People(ctx, tenantID)
if err != nil {
return nil, err
}
preferences, err := s.store.DispatchPreferences(ctx, tenantID)
if err != nil {
return nil, err
}
var out []dispatchPersonView
for _, person := range people {
if !person.Active {
continue
}
preference := store.DispatchPreference{
Channel: normalizeDispatchChannel("", person.Email),
Variant: dispatchVariantCompact,
Cover: true,
}
if saved, ok := preferences[person.ID]; ok {
preference.Channel = normalizeDispatchChannel(saved.Channel, person.Email)
preference.Variant = normalizeDispatchVariant(saved.Variant)
preference.Cover = saved.Cover
}
// A selected e-mail channel without an address falls back to print.
preference.Channel = effectiveDispatchChannel(preference.Channel, person.Email)
assignments := dispatchAssignments(rows, person.ID)
out = append(out, dispatchPersonView{
Person: person, Channel: preference.Channel, Variant: preference.Variant,
Cover: preference.Cover, Effective: effectiveDispatchChannel(preference.Channel, person.Email),
Assignments: assignments, AssignmentCount: len(assignments),
})
}
return out, nil
}
func (s *Server) handleDispatch(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
rng := s.rangeFromRequest(r)
rows, err := s.store.PlanRows(r.Context(), tenant.ID, rng)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Versendung", err.Error())
return
}
people, err := s.dispatchPeople(r.Context(), tenant.ID, rows)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Versendung", err.Error())
return
}
history, err := s.store.DispatchLog(r.Context(), tenant.ID, 200)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Versendung", err.Error())
return
}
config := s.loadSMTPConfig(r.Context(), tenant.ID)
intro, greeting := s.dispatchTexts(r.Context(), tenant.ID)
prev := domain.MonthRange(domain.AddingMonths(-1, rng.Start))
next := domain.MonthRange(domain.AddingMonths(1, rng.Start))
page := dispatchPageData{
Range: rng, Start: domain.Key(rng.Start), End: domain.Key(rng.End),
PrevStart: domain.Key(prev.Start), PrevEnd: domain.Key(prev.End),
NextStart: domain.Key(next.Start), NextEnd: domain.Key(next.End),
People: people, Intro: intro, Greeting: greeting,
SMTPConfigured: config.configured(), SMTPFrom: config.FromAddress,
History: history,
}
for _, person := range people {
switch person.Effective {
case dispatchChannelEmail:
page.EmailCount++
case dispatchChannelPrint:
page.PrintCount++
default:
page.NoneCount++
}
}
for _, row := range rows {
page.ServiceCount += len(row.Services)
for _, service := range row.Services {
page.OpenSlots += service.OpenSlots()
}
}
if len(history) > 0 {
page.LastEntry = &history[0]
for _, entry := range history {
if entry.BatchID != history[0].BatchID {
break
}
page.LastBatch = append(page.LastBatch, entry)
}
if len(history) > 20 {
history = history[:20]
}
page.History = history
}
data := s.baseView(w, r, "Versendung", "dispatch")
data.Data = page
s.renderPage(w, r, "dispatch", data)
}
func (s *Server) dispatchFormFromRequest(r *http.Request, people []domain.Person) dispatchForm {
rng := formRange(r)
form := dispatchForm{
Range: rng, Intro: strings.TrimSpace(r.FormValue("intro")),
Greeting: strings.TrimSpace(r.FormValue("greeting")),
Selections: map[string]dispatchSelection{},
}
if len([]rune(form.Intro)) > 6000 {
form.Intro = string([]rune(form.Intro)[:6000])
}
if len([]rune(form.Greeting)) > 2000 {
form.Greeting = string([]rune(form.Greeting)[:2000])
}
for _, person := range people {
selection := dispatchSelection{
Channel: normalizeDispatchChannel(r.FormValue("channel_"+person.ID), person.Email),
Variant: normalizeDispatchVariant(r.FormValue("variant_" + person.ID)),
Cover: r.FormValue("cover_"+person.ID) == "1",
}
form.Selections[person.ID] = selection
}
return form
}
func (s *Server) saveDispatchForm(r *http.Request, tenantID string, form dispatchForm) error {
// An emptied intro field resets the default wording.
if err := s.store.SetTenantSetting(r.Context(), tenantID, dispatchIntroKey, form.Intro); err != nil {
return err
}
if err := s.store.SetTenantSetting(r.Context(), tenantID, dispatchGreetingKey, form.Greeting); err != nil {
return err
}
for personID, selection := range form.Selections {
if err := s.store.SaveDispatchPreference(r.Context(), tenantID, personID,
selection.Channel, selection.Variant, selection.Cover); err != nil {
return err
}
}
return nil
}
func (s *Server) handleDispatchSave(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/plan")
return
}
people, err := s.store.People(r.Context(), tenant.ID)
if err != nil {
s.setFlash(w, "Die Empfänger konnten nicht geladen werden: "+err.Error(), "error")
s.redirect(w, r, "/dispatch")
return
}
form := s.dispatchFormFromRequest(r, people)
if err := s.saveDispatchForm(r, tenant.ID, form); err != nil {
s.setFlash(w, "Die Versendung konnte nicht gespeichert werden: "+err.Error(), "error")
} else {
s.setFlash(w, "Versendung gespeichert.", "success")
}
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
}
func (s *Server) dispatchContextData(ctx context.Context, tenantID string, rng domain.DayRange) ([]domain.DayPlanRow, []domain.Church, []domain.Person, map[string]domain.Person, error) {
rows, err := s.store.PlanRows(ctx, tenantID, rng)
if err != nil {
return nil, nil, nil, nil, err
}
churches, err := s.store.Churches(ctx, tenantID)
if err != nil {
return nil, nil, nil, nil, err
}
people, err := s.store.People(ctx, tenantID)
if err != nil {
return nil, nil, nil, nil, err
}
byID := make(map[string]domain.Person, len(people))
for _, person := range people {
byID[person.ID] = person
}
return rows, churches, people, byID, nil
}
func (s *Server) planPDF(variant string, rng domain.DayRange, rows []domain.DayPlanRow, churches []domain.Church, people []domain.Person, tenant *store.Tenant) ([]byte, error) {
options := pdf.Options{TenantName: tenant.Name, Diocese: s.opts.Diocese, GeneratedAt: domain.Today()}
var buffer bytes.Buffer
if normalizeDispatchVariant(variant) == dispatchVariantCompact {
if err := pdf.CompactPlan(&buffer, rng, rows, people, options); err != nil {
return nil, err
}
} else {
if err := pdf.FullPlan(&buffer, rng, rows, churches, people, options); err != nil {
return nil, err
}
}
return buffer.Bytes(), nil
}
func emailAssignmentTable(assignments []dispatchAssignmentView) string {
if len(assignments) == 0 {
return "Für Sie sind in diesem Zeitraum keine Einsätze eingetragen."
}
var buffer bytes.Buffer
writer := tabwriter.NewWriter(&buffer, 0, 4, 2, ' ', 0)
fmt.Fprintln(writer, "Tag\tZeit\tOrt\tDienst")
fmt.Fprintln(writer, "---\t----\t---\t------")
for _, assignment := range assignments {
fmt.Fprintf(writer, "%s\t%s\t%s\t%s (%s)\n",
assignment.DateLabel, assignment.TimeLabel, assignment.Church,
assignment.Title, assignment.RoleLabel)
}
_ = writer.Flush()
return strings.TrimRight(buffer.String(), "\n")
}
func dispatchEmailBody(intro, greeting string, rng domain.DayRange, assignments []dispatchAssignmentView) string {
parts := []string{resolveDispatchText(intro, rng)}
parts = append(parts, "Ihre Einsätze im Zeitraum:\n\n"+emailAssignmentTable(assignments))
if strings.TrimSpace(greeting) != "" {
parts = append(parts, resolveDispatchText(greeting, rng))
}
return strings.Join(parts, "\n\n")
}
func (s *Server) handleDispatchSend(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/plan")
return
}
people, err := s.store.People(r.Context(), tenant.ID)
if err != nil {
s.setFlash(w, "Die Empfänger konnten nicht geladen werden: "+err.Error(), "error")
s.redirect(w, r, "/dispatch")
return
}
form := s.dispatchFormFromRequest(r, people)
if err := s.saveDispatchForm(r, tenant.ID, form); err != nil {
s.setFlash(w, "Der Versand konnte nicht vorbereitet werden: "+err.Error(), "error")
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
return
}
config := s.loadSMTPConfig(r.Context(), tenant.ID)
if !config.configured() {
s.setFlash(w, "Bitte zuerst die SMTP-Parameter in den Einstellungen hinterlegen.", "error")
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
return
}
rows, churches, peopleList, _, err := s.dispatchContextData(r.Context(), tenant.ID, form.Range)
if err != nil {
s.setFlash(w, "Der Plan konnte nicht geladen werden: "+err.Error(), "error")
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
return
}
batchID := domain.NewID()
now := time.Now().UTC()
attachments := map[string][]byte{}
sent, failed, fallback := 0, 0, 0
var firstError string
var entries []store.DispatchLogEntry
for _, person := range peopleList {
if !person.Active {
continue
}
selection, ok := form.Selections[person.ID]
if !ok {
continue
}
channel := effectiveDispatchChannel(selection.Channel, person.Email)
if channel == dispatchChannelNone {
continue
}
if channel != dispatchChannelEmail {
fallback++
continue
}
if _, ok := attachments[selection.Variant]; !ok {
document, err := s.planPDF(selection.Variant, form.Range, rows, churches, peopleList, tenant)
if err != nil {
firstError = err.Error()
failed++
continue
}
attachments[selection.Variant] = document
}
assignments := dispatchAssignments(rows, person.ID)
body := dispatchEmailBody(form.Intro, form.Greeting, form.Range, assignments)
subject := "Gottesdienstplan " + form.Range.ShortTitle() + " · " + tenant.Name
filename := fmt.Sprintf("LektorenPlan-%s-%s-%s.pdf", tenant.Slug,
normalizeDispatchVariant(selection.Variant), domain.Key(form.Range.Start))
err := sendMail(config, person.Email, subject, body, attachments[selection.Variant], filename)
entry := store.DispatchLogEntry{
TenantID: tenant.ID, BatchID: batchID, RangeStart: form.Range.Start,
RangeEnd: form.Range.End, PersonID: person.ID, PersonName: person.FullName(),
Channel: dispatchChannelEmail, Variant: selection.Variant, Cover: false,
Email: person.Email, CreatedAt: now, CreatedBy: user.DisplayName,
}
if err != nil {
failed++
entry.Status = "failed"
entry.Detail = err.Error()
if firstError == "" {
firstError = err.Error()
}
} else {
sent++
entry.Status = "sent"
}
entries = append(entries, entry)
}
if err := s.store.AppendDispatchLog(r.Context(), entries); err != nil {
s.setFlash(w, "Der Versand wurde ausgeführt, das Protokoll konnte aber nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
return
}
switch {
case sent == 0 && failed == 0:
s.setFlash(w, "Es wurden keine Empfänger mit E-Mail-Adresse ausgewählt. Nutzen Sie stattdessen die Druck-PDF.", "info")
case failed == 0:
message := fmt.Sprintf("%d E-Mails versendet.", sent)
if fallback > 0 {
message += fmt.Sprintf(" %d Empfänger ohne E-Mail-Adresse wurden für den Ausdruck vorgemerkt.", fallback)
}
s.setFlash(w, message, "success")
default:
message := fmt.Sprintf("%d E-Mails versendet, %d fehlgeschlagen.", sent, failed)
if firstError != "" {
message += " Erster Fehler: " + firstError
}
s.setFlash(w, message, "error")
}
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
}
func (s *Server) handleDispatchPrint(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/plan")
return
}
people, err := s.store.People(r.Context(), tenant.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Versendung", err.Error())
return
}
form := s.dispatchFormFromRequest(r, people)
if err := s.saveDispatchForm(r, tenant.ID, form); err != nil {
s.setFlash(w, "Die Druckliste konnte nicht vorbereitet werden: "+err.Error(), "error")
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
return
}
rows, churches, peopleList, _, err := s.dispatchContextData(r.Context(), tenant.ID, form.Range)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Versendung", err.Error())
return
}
variantPDFs := map[string][]byte{}
var documents [][]byte
var recipients []dispatchPersonView
now := time.Now().UTC()
batchID := domain.NewID()
for _, person := range peopleList {
if !person.Active {
continue
}
selection, ok := form.Selections[person.ID]
if !ok {
continue
}
if effectiveDispatchChannel(selection.Channel, person.Email) != dispatchChannelPrint {
continue
}
assignments := dispatchAssignments(rows, person.ID)
if selection.Cover {
var cover bytes.Buffer
coverData := pdf.CoverData{
TenantName: tenant.Name, Diocese: s.opts.Diocese, Range: form.Range,
Person: person, Intro: resolveDispatchText(form.Intro, form.Range),
Greeting: resolveDispatchText(form.Greeting, form.Range),
Assignments: make([]pdf.DispatchAssignment, 0, len(assignments)),
GeneratedAt: domain.Today(),
}
for _, assignment := range assignments {
coverData.Assignments = append(coverData.Assignments, pdf.DispatchAssignment{
Date: assignment.Date, TimeMinutes: parseTimeLabel(assignment.TimeLabel),
Church: assignment.Church, Title: assignment.Title, Role: assignment.Role,
})
}
if err := pdf.Cover(&cover, coverData); err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Versendung", err.Error())
return
}
documents = append(documents, cover.Bytes())
}
variant := normalizeDispatchVariant(selection.Variant)
if _, ok := variantPDFs[variant]; !ok {
document, err := s.planPDF(variant, form.Range, rows, churches, peopleList, tenant)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Versendung", err.Error())
return
}
variantPDFs[variant] = document
}
documents = append(documents, variantPDFs[variant])
recipients = append(recipients, dispatchPersonView{
Person: person, Channel: dispatchChannelPrint, Variant: variant,
Cover: selection.Cover, Assignments: assignments,
})
}
if len(recipients) == 0 {
s.setFlash(w, "Es sind keine Empfänger für den Ausdruck ausgewählt.", "info")
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
return
}
packet, err := pdf.Merge(documents)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Versendung", err.Error())
return
}
entries := make([]store.DispatchLogEntry, 0, len(recipients))
for _, recipient := range recipients {
entries = append(entries, store.DispatchLogEntry{
TenantID: tenant.ID, BatchID: batchID, RangeStart: form.Range.Start,
RangeEnd: form.Range.End, PersonID: recipient.Person.ID,
PersonName: recipient.Person.FullName(), Channel: dispatchChannelPrint,
Variant: recipient.Variant, Cover: recipient.Cover, Email: recipient.Person.Email,
Status: "pdf", Detail: "Druck-PDF erzeugt", CreatedAt: now, CreatedBy: user.DisplayName,
})
}
if err := s.store.AppendDispatchLog(r.Context(), entries); err != nil {
s.setFlash(w, "Das Druck-PDF wurde erzeugt, das Protokoll konnte aber nicht gespeichert werden: "+err.Error(), "error")
}
name := fmt.Sprintf("LektorenPlan-%s-Versand-%s.pdf", tenant.Slug, domain.Key(form.Range.Start))
w.Header().Set("Content-Type", "application/pdf")
w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, name))
w.Header().Set("Content-Length", strconv.Itoa(len(packet)))
_, _ = w.Write(packet)
}
func parseTimeLabel(label string) int {
parts := strings.Split(strings.TrimSpace(label), ":")
if len(parts) != 2 {
return 0
}
hours, err := strconv.Atoi(parts[0])
if err != nil {
return 0
}
minutes, err := strconv.Atoi(parts[1])
if err != nil {
return 0
}
return hours*60 + minutes
}
func (s *Server) loadSMTPConfig(ctx context.Context, tenantID string) smtpConfig {
port, _ := strconv.Atoi(strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.port")))
return smtpConfig{
Host: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.host")),
Port: port,
Username: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.username")),
Password: s.store.TenantSetting(ctx, tenantID, "smtp.password"),
FromAddress: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.fromAddress")),
FromName: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.fromName")),
Encryption: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.encryption")),
}
}
+309
View File
@@ -0,0 +1,309 @@
package web
import (
"context"
"io"
"net/http"
"net/url"
"strings"
"testing"
)
// dispatchRange is a range with seeded demo services and liturgical days.
const dispatchRange = "start=2026-03-01&end=2026-03-31"
func postForm(t *testing.T, client *http.Client, target string, form url.Values) *http.Response {
t.Helper()
resp, err := client.PostForm(target, form)
if err != nil {
t.Fatalf("POST %s: %v", target, err)
}
return resp
}
func TestDispatchPageAndPreferences(t *testing.T) {
ts, st := newTestServer(t)
client := newClient(t)
login(t, client, ts.URL, "editor", "editor123")
body := get(t, client, ts.URL+"/dispatch?"+dispatchRange, http.StatusOK)
if !strings.Contains(body, "Versendung") {
t.Fatal("dispatch page is missing its heading")
}
csrf := extractCSRF(t, body)
ctx := context.Background()
tenants, err := st.Tenants(ctx)
if err != nil || len(tenants) == 0 {
t.Fatalf("tenants: %v", err)
}
tenantID := ""
for _, tenant := range tenants {
people, _ := st.People(ctx, tenant.ID)
for _, person := range people {
if person.ID == "p-markus" {
tenantID = tenant.ID
}
}
}
if tenantID == "" {
t.Fatal("demo tenant with p-markus not found")
}
resp := postForm(t, client, ts.URL+"/dispatch/save", url.Values{
"csrf": {csrf},
"start": {"2026-03-01"},
"end": {"2026-03-31"},
"intro": {"Liebe Leute, anbei der Plan von {start} bis {end}."},
"greeting": {"Mit Grüßen"},
"channel_p-markus": {"print"},
"variant_p-markus": {"full"},
"cover_p-markus": {"1"},
})
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther {
t.Fatalf("save dispatch = %d, want 303", resp.StatusCode)
}
preferences, err := st.DispatchPreferences(ctx, tenantID)
if err != nil {
t.Fatalf("preferences: %v", err)
}
preference, ok := preferences["p-markus"]
if !ok {
t.Fatal("p-markus preference was not stored")
}
if preference.Channel != "print" || preference.Variant != "full" || !preference.Cover {
t.Fatalf("unexpected preference: %+v", preference)
}
if got := st.TenantSetting(ctx, tenantID, dispatchIntroKey); !strings.Contains(got, "{start}") {
t.Fatalf("intro setting = %q", got)
}
if got := st.TenantSetting(ctx, tenantID, dispatchGreetingKey); got != "Mit Grüßen" {
t.Fatalf("greeting setting = %q", got)
}
}
func TestDispatchRequiresEditor(t *testing.T) {
ts, _ := newTestServer(t)
reader := newClient(t)
login(t, reader, ts.URL, "reader", "reader123")
get(t, reader, ts.URL+"/dispatch", http.StatusForbidden)
anonymous := newClient(t)
resp, err := anonymous.Get(ts.URL + "/dispatch")
if err != nil {
t.Fatalf("GET /dispatch: %v", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther {
t.Fatalf("anonymous /dispatch = %d, want 303", resp.StatusCode)
}
}
func TestDispatchPrintPacketAndLog(t *testing.T) {
ts, st := newTestServer(t)
client := newClient(t)
login(t, client, ts.URL, "editor", "editor123")
body := get(t, client, ts.URL+"/dispatch?"+dispatchRange, http.StatusOK)
csrf := extractCSRF(t, body)
resp := postForm(t, client, ts.URL+"/dispatch/print", url.Values{
"csrf": {csrf},
"start": {"2026-03-01"},
"end": {"2026-03-31"},
"channel_p-maria": {"print"},
"variant_p-maria": {"compact"},
"cover_p-maria": {"1"},
})
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
raw, _ := io.ReadAll(resp.Body)
t.Fatalf("print = %d, want 200\n%s", resp.StatusCode, firstBytes(raw, 300))
}
if contentType := resp.Header.Get("Content-Type"); contentType != "application/pdf" {
t.Fatalf("content type = %q", contentType)
}
raw, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatalf("read PDF: %v", err)
}
if !strings.HasPrefix(string(raw), "%PDF") {
t.Fatalf("response is not a PDF: %q", firstBytes(raw, 20))
}
ctx := context.Background()
tenants, _ := st.Tenants(ctx)
found := false
for _, tenant := range tenants {
entries, err := st.DispatchLog(ctx, tenant.ID, 20)
if err != nil {
t.Fatalf("dispatch log: %v", err)
}
for _, entry := range entries {
if entry.PersonID == "p-maria" && entry.Channel == "print" && entry.Status == "pdf" {
found = true
}
}
}
if !found {
t.Fatal("print dispatch was not logged")
}
}
func TestDispatchSendWithoutSMTPIsRejected(t *testing.T) {
ts, st := newTestServer(t)
client := newClient(t)
login(t, client, ts.URL, "editor", "editor123")
body := get(t, client, ts.URL+"/dispatch?"+dispatchRange, http.StatusOK)
csrf := extractCSRF(t, body)
resp := postForm(t, client, ts.URL+"/dispatch/send", url.Values{
"csrf": {csrf},
"start": {"2026-03-01"},
"end": {"2026-03-31"},
"channel_p-anna": {"email"},
"variant_p-anna": {"compact"},
})
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther {
t.Fatalf("send without SMTP = %d, want 303", resp.StatusCode)
}
if strings.Contains(resp.Header.Get("Location"), "dispatch") == false {
t.Fatalf("redirect = %q, want dispatch page", resp.Header.Get("Location"))
}
// A refused send must not be logged as successful.
ctx := context.Background()
tenants, _ := st.Tenants(ctx)
for _, tenant := range tenants {
entries, _ := st.DispatchLog(ctx, tenant.ID, 10)
for _, entry := range entries {
if entry.Status == "sent" {
t.Fatalf("unexpected sent log entry: %+v", entry)
}
}
}
}
func TestEditorManagesTenantSMTP(t *testing.T) {
ts, st := newTestServer(t)
client := newClient(t)
login(t, client, ts.URL, "editor", "editor123")
body := get(t, client, ts.URL+"/settings", http.StatusOK)
if !strings.Contains(body, "E-Mail-Versand (SMTP)") {
t.Fatal("editor settings do not offer SMTP fields")
}
csrf := extractCSRF(t, body)
resp := postForm(t, client, ts.URL+"/settings/save", url.Values{
"csrf": {csrf},
"smtp_host": {"smtp.example.org"},
"smtp_port": {"587"},
"smtp_username": {"plan"},
"smtp_password": {"secret"},
"smtp_from_address": {"plan@example.org"},
"smtp_from_name": {"Pfarrei"},
"smtp_encryption": {"starttls"},
})
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther {
t.Fatalf("save settings = %d, want 303", resp.StatusCode)
}
ctx := context.Background()
tenants, _ := st.Tenants(ctx)
found := false
for _, tenant := range tenants {
if st.TenantSetting(ctx, tenant.ID, "smtp.host") == "smtp.example.org" {
found = true
if got := st.TenantSetting(ctx, tenant.ID, "smtp.port"); got != "587" {
t.Fatalf("smtp port = %q", got)
}
if got := st.TenantSetting(ctx, tenant.ID, "smtp.password"); got != "secret" {
t.Fatalf("smtp password = %q", got)
}
}
}
if !found {
t.Fatal("SMTP host was not stored as a tenant setting")
}
// The dispatch page now reports a ready SMTP configuration.
page := get(t, client, ts.URL+"/dispatch", http.StatusOK)
if !strings.Contains(page, "SMTP bereit") {
t.Fatal("dispatch page does not reflect the SMTP configuration")
}
// Readers may not change these settings.
reader := newClient(t)
login(t, reader, ts.URL, "reader", "reader123")
readerPage := get(t, reader, ts.URL+"/settings", http.StatusOK)
if strings.Contains(readerPage, "E-Mail-Versand (SMTP)") {
t.Fatal("reader settings must not expose SMTP")
}
}
func TestGuestAccessIsReadOnlyAndAnonymous(t *testing.T) {
ts, st := newTestServer(t)
client := newClient(t)
body := get(t, client, ts.URL+"/guest", http.StatusOK)
if !strings.Contains(body, "Gastzugang") {
t.Fatal("guest page is missing the guest badge")
}
if strings.Contains(body, "/settings") {
t.Fatal("guest page must not link to settings")
}
if !strings.Contains(body, "schott.erzabtei-beuron.de") {
t.Fatal("guest page should link the liturgical readings")
}
if strings.Contains(body, "Anna Berg") || strings.Contains(body, "Markus Weber") {
t.Fatal("guest page must not name assigned people")
}
if !strings.Contains(body, "Lektor") && !strings.Contains(body, "Kommunionhelfer") {
t.Fatal("guest page should still show assignment roles")
}
// Guest data must never contain person records.
ctx := context.Background()
tenants, _ := st.Tenants(ctx)
people, _ := st.People(ctx, tenants[0].ID)
for _, person := range people {
if person.Email != "" && strings.Contains(body, person.Email) {
t.Fatalf("guest page leaks e-mail address %q", person.Email)
}
}
// The guest range picker and tenant switch keep working.
get(t, client, ts.URL+"/guest?"+dispatchRange, http.StatusOK)
get(t, client, ts.URL+"/guest?tid="+url.QueryEscape(tenants[len(tenants)-1].ID), http.StatusOK)
// Write routes stay protected.
loginPage := get(t, client, ts.URL+"/login", http.StatusOK)
if !strings.Contains(loginPage, `href="/guest"`) {
t.Fatal("login page is missing the guest access button")
}
}
func TestGuestHandlerDoesNotExposePeople(t *testing.T) {
ts, _ := newTestServer(t)
resp, err := http.Get(ts.URL + "/guest?start=2025-01-01&end=2025-12-31")
if err != nil {
t.Fatalf("GET /guest: %v", err)
}
defer resp.Body.Close()
raw, _ := io.ReadAll(resp.Body)
body := string(raw)
if !strings.Contains(body, "Liturgie") {
t.Fatal("guest year plan is missing liturgical data")
}
for _, leaked := range []string{"mailto:", "/team", "passwort", "SMTP"} {
if strings.Contains(strings.ToLower(body), strings.ToLower(leaked)) {
t.Fatalf("guest page contains %q", leaked)
}
}
}
+88
View File
@@ -0,0 +1,88 @@
package web
import (
"net/http"
"strings"
"lektorenplan/domain"
"lektorenplan/store"
)
// guestPageData is the read-only public plan. It deliberately contains no
// person records: assignments are shown by role only.
type guestPageData struct {
Range domain.DayRange
Start string
End string
PrevStart string
PrevEnd string
NextStart string
NextEnd string
Rows []domain.DayPlanRow
Churches []domain.Church
Tenants []store.Tenant
TenantID string
TenantName string
ServiceCount int
OpenSlots int
Today string
}
// handleGuest renders the plan without authentication. It never exposes
// settings, write actions or the names of assigned people.
func (s *Server) handleGuest(w http.ResponseWriter, r *http.Request) {
tenants, err := s.store.Tenants(r.Context())
if err != nil {
http.Error(w, "Der Gastzugang ist derzeit nicht verfügbar.", http.StatusInternalServerError)
return
}
if len(tenants) == 0 {
http.Error(w, "Es ist noch keine Pfarrei eingerichtet.", http.StatusNotFound)
return
}
tenant := tenants[0]
if wanted := strings.TrimSpace(r.URL.Query().Get("tid")); wanted != "" {
for i := range tenants {
if tenants[i].ID == wanted || strings.EqualFold(tenants[i].Slug, wanted) {
tenant = tenants[i]
break
}
}
}
rng := s.rangeFromRequest(r)
rows, err := s.store.PlanRows(r.Context(), tenant.ID, rng)
if err != nil {
http.Error(w, "Der Gastzugang ist derzeit nicht verfügbar.", http.StatusInternalServerError)
return
}
churches, err := s.store.Churches(r.Context(), tenant.ID)
if err != nil {
http.Error(w, "Der Gastzugang ist derzeit nicht verfügbar.", http.StatusInternalServerError)
return
}
prev := domain.MonthRange(domain.AddingMonths(-1, rng.Start))
next := domain.MonthRange(domain.AddingMonths(1, rng.Start))
page := guestPageData{
Range: rng, Start: domain.Key(rng.Start), End: domain.Key(rng.End),
PrevStart: domain.Key(prev.Start), PrevEnd: domain.Key(prev.End),
NextStart: domain.Key(next.Start), NextEnd: domain.Key(next.End),
Rows: rows, Churches: churches, Tenants: tenants,
TenantID: tenant.ID, TenantName: tenant.Name,
Today: domain.Key(domain.Today()),
}
for _, row := range rows {
page.ServiceCount += len(row.Services)
page.OpenSlots += row.OpenSlots()
}
data := viewData{
Title: "Gottesdienstplan", Active: "guest", Guest: true,
Version: s.opts.Version, Tenant: &tenant,
LoginQuote: s.loginQuote(r), LoginQuoteSource: s.loginQuoteSource(r),
}
data.Data = page
s.renderPage(w, r, "guest", data)
}
+197
View File
@@ -0,0 +1,197 @@
package web
import (
"bytes"
"crypto/rand"
"crypto/tls"
"encoding/base64"
"encoding/hex"
"fmt"
"mime"
"net"
"net/mail"
"net/smtp"
"strconv"
"strings"
"time"
)
type smtpConfig struct {
Host string
Port int
Username string
Password string
FromAddress string
FromName string
Encryption string
}
func (c smtpConfig) configured() bool {
return strings.TrimSpace(c.Host) != "" && strings.TrimSpace(c.FromAddress) != ""
}
func (c smtpConfig) encryption() string {
switch strings.ToLower(strings.TrimSpace(c.Encryption)) {
case "ssl", "tls":
return "ssl"
case "none", "plain":
return "none"
default:
return "starttls"
}
}
func (c smtpConfig) port() int {
if c.Port > 0 && c.Port <= 65535 {
return c.Port
}
if c.encryption() == "ssl" {
return 465
}
return 587
}
func (c smtpConfig) sender() string {
address := sanitizeHeader(c.FromAddress)
name := sanitizeHeader(c.FromName)
if name == "" {
return address
}
return (&mail.Address{Name: name, Address: address}).String()
}
func sanitizeHeader(value string) string {
value = strings.ReplaceAll(value, "\r", "")
value = strings.ReplaceAll(value, "\n", "")
return strings.TrimSpace(value)
}
func randomBoundary() string {
buffer := make([]byte, 12)
if _, err := rand.Read(buffer); err != nil {
return "lektorenplan-boundary"
}
return "lektorenplan-" + hex.EncodeToString(buffer)
}
func encodeBase64Lines(value []byte) string {
encoded := base64.StdEncoding.EncodeToString(value)
var out strings.Builder
for len(encoded) > 76 {
out.WriteString(encoded[:76])
out.WriteString("\r\n")
encoded = encoded[76:]
}
out.WriteString(encoded)
return out.String()
}
func buildMailMessage(config smtpConfig, to, subject, body string, attachment []byte, attachmentName string) []byte {
boundary := randomBoundary()
var message bytes.Buffer
message.WriteString("From: " + config.sender() + "\r\n")
message.WriteString("To: " + sanitizeHeader(to) + "\r\n")
message.WriteString("Subject: " + mime.QEncoding.Encode("utf-8", sanitizeHeader(subject)) + "\r\n")
message.WriteString("Date: " + time.Now().Format(time.RFC1123Z) + "\r\n")
message.WriteString("MIME-Version: 1.0\r\n")
message.WriteString("Content-Type: multipart/mixed; boundary=\"" + boundary + "\"\r\n")
message.WriteString("\r\n")
message.WriteString("--" + boundary + "\r\n")
message.WriteString("Content-Type: text/plain; charset=utf-8\r\n")
message.WriteString("Content-Transfer-Encoding: base64\r\n\r\n")
message.WriteString(encodeBase64Lines([]byte(body)))
message.WriteString("\r\n")
if len(attachment) > 0 {
name := sanitizeHeader(attachmentName)
if name == "" {
name = "Gottesdienstplan.pdf"
}
message.WriteString("--" + boundary + "\r\n")
message.WriteString("Content-Type: application/pdf; name=\"" + name + "\"\r\n")
message.WriteString("Content-Transfer-Encoding: base64\r\n")
message.WriteString("Content-Disposition: attachment; filename=\"" + name + "\"\r\n\r\n")
message.WriteString(encodeBase64Lines(attachment))
message.WriteString("\r\n")
}
message.WriteString("--" + boundary + "--\r\n")
return message.Bytes()
}
func sendMail(config smtpConfig, to, subject, body string, attachment []byte, attachmentName string) error {
if !config.configured() {
return fmt.Errorf("SMTP ist noch nicht konfiguriert")
}
recipient, err := mail.ParseAddress(strings.TrimSpace(to))
if err != nil {
return fmt.Errorf("ungültige E-Mail-Adresse: %w", err)
}
address := net.JoinHostPort(config.Host, strconv.Itoa(config.port()))
tlsConfig := &tls.Config{ServerName: config.Host, MinVersion: tls.VersionTLS12}
dialer := &net.Dialer{Timeout: 20 * time.Second}
var client *smtp.Client
switch config.encryption() {
case "ssl":
connection, err := tls.DialWithDialer(dialer, "tcp", address, tlsConfig)
if err != nil {
return fmt.Errorf("TLS-Verbindung zu %s: %w", address, err)
}
client, err = smtp.NewClient(connection, config.Host)
if err != nil {
connection.Close()
return err
}
case "none":
connection, err := dialer.Dial("tcp", address)
if err != nil {
return fmt.Errorf("Verbindung zu %s: %w", address, err)
}
client, err = smtp.NewClient(connection, config.Host)
if err != nil {
connection.Close()
return err
}
default:
client, err = smtp.Dial(address)
if err != nil {
return fmt.Errorf("Verbindung zu %s: %w", address, err)
}
if ok, _ := client.Extension("STARTTLS"); !ok {
client.Close()
return fmt.Errorf("der Server unterstützt kein STARTTLS")
}
if err := client.StartTLS(tlsConfig); err != nil {
client.Close()
return fmt.Errorf("STARTTLS: %w", err)
}
}
defer client.Close()
if config.Username != "" {
auth := smtp.PlainAuth("", config.Username, config.Password, config.Host)
if err := client.Auth(auth); err != nil {
return fmt.Errorf("SMTP-Anmeldung: %w", err)
}
}
if err := client.Mail(config.FromAddress); err != nil {
return err
}
if err := client.Rcpt(recipient.Address); err != nil {
return err
}
writer, err := client.Data()
if err != nil {
return err
}
if _, err := writer.Write(buildMailMessage(config, recipient.Address, subject, body, attachment, attachmentName)); err != nil {
writer.Close()
return err
}
if err := writer.Close(); err != nil {
return err
}
return client.Quit()
}
+60
View File
@@ -0,0 +1,60 @@
package web
import (
"encoding/base64"
"net/mail"
"strings"
"testing"
)
func TestBuildMailMessageCarriesTextAndPDF(t *testing.T) {
config := smtpConfig{
Host: "smtp.example.org",
Port: 587,
FromAddress: "plan@example.org",
FromName: "Pfarrei Sankt Michael",
}
attachment := []byte("%PDF-1.4\nfake dispatch packet\n%%EOF")
subject := "Gottesdienstplan März 2026 · Pfarrei"
body := "Hallo Anna"
raw := buildMailMessage(config, "anna@example.org", subject, body, attachment, "Plan.pdf")
message, err := mail.ReadMessage(strings.NewReader(string(raw)))
if err != nil {
t.Fatalf("message is not valid mail: %v", err)
}
if got := message.Header.Get("To"); got != "anna@example.org" {
t.Fatalf("To = %q", got)
}
if got := message.Header.Get("MIME-Version"); got != "1.0" {
t.Fatalf("MIME-Version = %q", got)
}
if contentType := message.Header.Get("Content-Type"); !strings.HasPrefix(contentType, "multipart/mixed;") {
t.Fatalf("Content-Type = %q", contentType)
}
text := string(raw)
for _, want := range []string{
"Content-Type: text/plain; charset=utf-8",
"Content-Type: application/pdf",
`filename="Plan.pdf"`,
"Content-Disposition: attachment",
} {
if !strings.Contains(text, want) {
t.Fatalf("message misses %q", want)
}
}
if !strings.Contains(text, base64.StdEncoding.EncodeToString(attachment)) {
t.Fatal("PDF attachment is not base64 encoded in the message")
}
if !strings.Contains(text, base64.StdEncoding.EncodeToString([]byte(body))) {
t.Fatal("mail body is not base64 encoded in the message")
}
}
func TestSanitizeHeaderStripsLineBreaks(t *testing.T) {
if got := sanitizeHeader("Pfarrei\r\nBcc: evil@example.org"); got != "PfarreiBcc: evil@example.org" {
t.Fatalf("sanitizeHeader = %q", got)
}
}
+6
View File
@@ -27,6 +27,7 @@ type viewData struct {
FlashKind string
IsEditor bool
IsAdmin bool
Guest bool
Version string
DemoMode bool
LoginQuote string
@@ -144,6 +145,9 @@ func templateFunctions() template.FuncMap {
"roleTitle": func(role domain.Role) string { return role.Title() },
"rolePlural": func(role domain.Role) string { return role.Plural() },
"roleShort": func(role domain.Role) string { return role.ShortCode() },
"channelLabel": dispatchChannelLabel,
"variantLabel": dispatchVariantLabel,
"statusLabel": dispatchStatusLabel,
"userRole": func(role store.UserRole) string { return store.UserRoleTitle(role) },
"dioceses": func() any { return dioceseOptions },
"percent": percentLabel,
@@ -397,6 +401,8 @@ var iconPaths = map[string]string{
"settings": `<circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.7 1.7 0 0 0 .34 1.87l.06.06a2 2 0 1 1-2.83 2.83l-.06-.06A1.7 1.7 0 0 0 15 19.4a1.7 1.7 0 0 0-1 .6 1.7 1.7 0 0 0-.4 1.1V21a2 2 0 1 1-4 0v-.09A1.7 1.7 0 0 0 8.6 19.4a1.7 1.7 0 0 0-1.87.34l-.06.06a2 2 0 1 1-2.83-2.83l.06-.06A1.7 1.7 0 0 0 4.6 15a1.7 1.7 0 0 0-.6-1 1.7 1.7 0 0 0-1.1-.4H3a2 2 0 1 1 0-4h.09A1.7 1.7 0 0 0 4.6 8.6a1.7 1.7 0 0 0-.34-1.87l-.06-.06a2 2 0 1 1 2.83-2.83l.06.06A1.7 1.7 0 0 0 9 4.6a1.7 1.7 0 0 0 1-.6 1.7 1.7 0 0 0 .4-1.1V3a2 2 0 1 1 4 0v.09A1.7 1.7 0 0 0 15 4.6a1.7 1.7 0 0 0 1.87-.34l.06-.06a2 2 0 1 1 2.83 2.83l-.06.06A1.7 1.7 0 0 0 19.4 9c.1.4.3.8.6 1 .3.3.7.4 1.1.4H21a2 2 0 1 1 0 4h-.09a1.7 1.7 0 0 0-1.51.6z"/>`,
"shield": `<path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/><path d="M9 12l2 2 4-4"/>`,
"printer": `<path d="M6 9V2h12v7M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"/><rect x="6" y="14" width="12" height="8"/>`,
"send": `<path d="M22 2L11 13M22 2l-7 20-4-9-9-4z"/>`,
"mail": `<rect x="2" y="4" width="20" height="16" rx="2"/><path d="M3 6l9 7 9-7"/>`,
"plus": `<path d="M12 5v14M5 12h14"/>`,
"left": `<path d="M15 18l-6-6 6-6"/>`,
"right": `<path d="M9 18l6-6-6-6"/>`,
+7 -1
View File
@@ -62,7 +62,7 @@ func New(st *store.Store, opts Options) (*Server, error) {
funcs := templateFunctions()
names := []string{
"login", "plan", "service", "services", "team", "person", "statistics",
"exchange", "settings", "liturgy", "admin_tenants", "admin_users",
"exchange", "settings", "liturgy", "dispatch", "guest", "admin_tenants", "admin_users",
"admin_churches", "password", "error", "no_tenant",
}
views := make(map[string]*template.Template, len(names))
@@ -122,6 +122,7 @@ func (s *Server) Handler() http.Handler {
mux.HandleFunc("GET /login", s.handleLoginGet)
mux.HandleFunc("POST /login", s.handleLoginPost)
mux.HandleFunc("GET /guest", s.handleGuest)
mux.HandleFunc("POST /logout", s.auth(s.handleLogout))
mux.HandleFunc("GET /password", s.auth(s.handlePasswordGet))
mux.HandleFunc("POST /password", s.auth(s.handlePasswordChange))
@@ -164,6 +165,11 @@ func (s *Server) Handler() http.Handler {
mux.HandleFunc("POST /liturgy/sync", s.editor(s.handleLiturgySync))
mux.HandleFunc("GET /pdf", s.auth(s.handlePDF))
mux.HandleFunc("GET /dispatch", s.editor(s.handleDispatch))
mux.HandleFunc("POST /dispatch/save", s.editor(s.handleDispatchSave))
mux.HandleFunc("POST /dispatch/send", s.editor(s.handleDispatchSend))
mux.HandleFunc("POST /dispatch/print", s.editor(s.handleDispatchPrint))
mux.HandleFunc("GET /admin", s.admin(s.handleAdminRoot))
mux.HandleFunc("GET /admin/tenants", s.admin(s.handleAdminTenants))
mux.HandleFunc("POST /admin/tenants/save", s.admin(s.handleAdminTenantSave))
+63
View File
@@ -21,6 +21,14 @@ type settingsPageData struct {
DemoReset bool
LoginQuote string
LoginQuoteSource string
SMTPHost string
SMTPPort string
SMTPUsername string
SMTPPasswordSet bool
SMTPFromAddress string
SMTPFromName string
SMTPEncryption string
SMTPConfigured bool
}
const (
@@ -101,6 +109,19 @@ func (s *Server) handleSettings(w http.ResponseWriter, r *http.Request, user *st
LoginQuote: s.loginQuote(r),
LoginQuoteSource: s.loginQuoteSource(r),
}
if page.CanEdit {
config := s.loadSMTPConfig(r.Context(), tenant.ID)
page.SMTPHost = config.Host
if config.Port > 0 {
page.SMTPPort = fmt.Sprintf("%d", config.Port)
}
page.SMTPUsername = config.Username
page.SMTPPasswordSet = config.Password != ""
page.SMTPFromAddress = config.FromAddress
page.SMTPFromName = config.FromName
page.SMTPEncryption = config.encryption()
page.SMTPConfigured = config.configured()
}
if page.Diocese == "" {
page.Diocese = "koeln"
}
@@ -141,6 +162,37 @@ func (s *Server) handleSettingsSave(w http.ResponseWriter, r *http.Request, user
}
}
// SMTP settings for dispatch e-mails are administered per tenant by the
// editors. The password is only replaced when a new value is entered so
// it never has to be echoed back.
if s.store.CanEditTenant(r.Context(), user, tenant.ID) {
smtpValues := map[string]string{
"smtp.host": strings.TrimSpace(r.FormValue("smtp_host")),
"smtp.username": strings.TrimSpace(r.FormValue("smtp_username")),
"smtp.fromAddress": strings.TrimSpace(r.FormValue("smtp_from_address")),
"smtp.fromName": strings.TrimSpace(r.FormValue("smtp_from_name")),
"smtp.encryption": smtpEncryptionSetting(r.FormValue("smtp_encryption")),
}
if port := parseInt(r.FormValue("smtp_port"), 0); port > 0 && port <= 65535 {
smtpValues["smtp.port"] = fmt.Sprintf("%d", port)
} else {
smtpValues["smtp.port"] = ""
}
for key, value := range smtpValues {
if err := s.store.SetTenantSetting(r.Context(), tenant.ID, key, value); err != nil {
s.setFlash(w, "Die SMTP-Einstellungen konnten nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, "/settings")
return
}
}
switch {
case r.FormValue("smtp_clear_password") == "1":
_ = s.store.SetTenantSetting(r.Context(), tenant.ID, "smtp.password", "")
case strings.TrimSpace(r.FormValue("smtp_password")) != "":
_ = s.store.SetTenantSetting(r.Context(), tenant.ID, "smtp.password", r.FormValue("smtp_password"))
}
}
tenantValues := map[string]string{
"planner.replaceExisting": boolSetting(r.FormValue("replace_existing")),
"planner.respectPreferredWeekdays": boolSetting(r.FormValue("respect_weekdays")),
@@ -205,6 +257,17 @@ func (s *Server) handleDeleteTenantData(w http.ResponseWriter, r *http.Request,
s.redirect(w, r, "/settings")
}
func smtpEncryptionSetting(value string) string {
switch strings.ToLower(strings.TrimSpace(value)) {
case "ssl":
return "ssl"
case "none":
return "none"
default:
return "starttls"
}
}
func boolSetting(value string) string {
if value == "1" || value == "on" || value == "true" {
return "1"
+25
View File
@@ -173,6 +173,30 @@
});
}
/* Versandweg für alle Empfänger setzen -------------------------------- */
function initDispatchBulk() {
var form = document.querySelector("[data-dispatch-form]");
if (!form) return;
var selects = Array.prototype.slice.call(form.querySelectorAll("[data-dispatch-channel]"));
if (!selects.length) return;
form.querySelectorAll("[data-dispatch-all]").forEach(function (button) {
button.addEventListener("click", function () {
var mode = button.getAttribute("data-dispatch-all");
selects.forEach(function (select) {
if (mode === "reset") {
select.selectedIndex = 0;
return;
}
var option = select.querySelector('option[value="' + mode + '"]');
if (!option && mode === "email") {
option = select.querySelector('option[value="print"]');
}
if (option) option.selected = true;
});
});
});
}
/* Formular-Doppelversand verhindern ------------------------------------ */
function initSubmitGuards() {
document.querySelectorAll("form").forEach(function (form) {
@@ -195,6 +219,7 @@
initPersonSearch();
initFileDrop();
initRangeOutputs();
initDispatchBulk();
initSubmitGuards();
});
})();
+62
View File
@@ -812,6 +812,65 @@ hr { border: 0; border-top: 1px solid var(--line); margin: 1rem 0; }
.error-page h2 { margin-bottom: .35rem; }
.error-page p { color: var(--muted); font-size: .9rem; margin-bottom: 1rem; }
/* ---------- Versendung ---------- */
.dispatch-page .range-label { font-family: var(--serif); font-size: .95rem; color: var(--ink-soft); }
.dispatch-bulk { display: flex; gap: .3rem; flex-wrap: wrap; justify-content: flex-end; }
.dispatch-table td { vertical-align: top; }
.dispatch-table select { min-width: 9.5rem; }
.dispatch-person { display: flex; flex-direction: column; gap: .1rem; min-width: 11rem; }
.dispatch-person strong { font-size: .9rem; }
.dispatch-person small { color: var(--muted); }
.dispatch-person a { font-size: .78rem; color: var(--green); word-break: break-all; }
.dispatch-no-mail { font-size: .78rem; color: var(--burgundy); }
.dispatch-warn { display: block; color: var(--burgundy); font-size: .72rem; }
.dispatch-cover { white-space: nowrap; }
.dispatch-cover .check { font-size: .8rem; }
.dispatch-details summary { cursor: pointer; color: var(--green-dark); font-size: .8rem; }
.dispatch-details ul { list-style: none; margin: .4rem 0 0; padding: 0; display: flex; flex-direction: column; gap: .2rem; }
.dispatch-details li {
display: grid; grid-template-columns: 6.5rem 3.2rem minmax(4rem, 1fr) auto; gap: .45rem;
font-size: .74rem; color: var(--muted); padding: .18rem .4rem;
border-left: 2px solid var(--line-soft); background: var(--card-alt); border-radius: 0 5px 5px 0;
}
.dispatch-actions { gap: .5rem; flex-wrap: wrap; }
.dispatch-last-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 1rem; margin-bottom: .9rem; }
.dispatch-last-grid div { display: flex; flex-direction: column; gap: .1rem; }
.dispatch-last-grid strong { font-family: var(--serif); font-size: 1rem; }
.dispatch-log-list { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; }
.dispatch-log-list li {
display: flex; flex-wrap: wrap; align-items: baseline; gap: .55rem;
padding: .45rem .2rem; border-bottom: 1px solid var(--line-soft); font-size: .82rem;
}
.dispatch-log-list li:last-child { border-bottom: 0; }
.dispatch-log-list li strong { min-width: 11rem; }
.dispatch-log-list li small { flex-basis: 100%; color: var(--muted); }
.dispatch-log-status { font-size: .72rem; font-weight: 700; letter-spacing: .02em; color: var(--muted); }
.dispatch-log-status.status-sent, .dispatch-log-status.status-pdf { color: var(--green-dark); }
.dispatch-log-status.status-failed { color: var(--burgundy); }
.notice-gold { border-style: dashed; }
/* ---------- Gastzugang ---------- */
.auth-guest {
display: flex; flex-direction: column; gap: .45rem;
margin-top: .9rem; padding-top: .9rem; border-top: 1px dashed var(--line);
}
.auth-guest-note { color: var(--muted); font-size: .76rem; line-height: 1.45; }
.guest-page { background: linear-gradient(180deg, #fbf7ed 0%, var(--paper) 46%, #f1e9d9 100%); }
.guest-shell { min-height: 100vh; display: flex; flex-direction: column; }
.guest-bar {
display: flex; align-items: center; justify-content: space-between; gap: 1rem; flex-wrap: wrap;
padding: .85rem clamp(1rem, 3vw, 2.2rem);
background: rgba(255, 253, 247, .92); border-bottom: 1px solid var(--line);
backdrop-filter: blur(6px);
}
.guest-bar .brand { display: flex; align-items: center; gap: .7rem; color: var(--ink); }
.guest-actions { display: flex; align-items: center; gap: .5rem; flex-wrap: wrap; }
.guest-content { width: 100%; max-width: 1380px; margin: 0 auto; flex: 1; }
.guest-foot { display: flex; justify-content: space-between; gap: 1rem; flex-wrap: wrap; }
.guest-service { cursor: default; }
.guest-service:hover { transform: none; }
.stat-strip.three { grid-template-columns: repeat(3, minmax(0, 1fr)); }
/* ---------- Utilities and responsive ---------- */
[data-plan-row].filtered { display: none; }
[data-plan-row].filtered + [data-plan-row].filtered { border-top: 0; }
@@ -882,6 +941,9 @@ hr { border: 0; border-top: 1px solid var(--line); margin: 1rem 0; }
.demo-account-grid { grid-template-columns: 1fr; }
.church-overview { grid-template-columns: 1fr; }
.topbar-actions .btn span { display: none; }
.dispatch-last-grid { grid-template-columns: 1fr; }
.dispatch-actions .btn { width: 100%; justify-content: center; }
.dispatch-bulk { justify-content: flex-start; }
}
@media print {
+215
View File
@@ -0,0 +1,215 @@
{{define "content"}}
<div class="page-stack dispatch-page">
<section class="page-intro">
<div>
<span class="eyebrow">Planung · Versendung</span>
<h2>Den Plan an alle Empfänger bringen</h2>
<p>Legen Sie je Person fest, ob der Plan per E-Mail oder als Ausdruck verschickt wird und welche Liste beiliegt. Der E-Mail-Text wird für jede Person mit einer kleinen Übersicht der eigenen Einsätze ergänzt.</p>
</div>
<div class="intro-actions">
{{if .Data.SMTPConfigured}}
<span class="badge badge-green">{{icon "mail"}} SMTP bereit · {{.Data.SMTPFrom}}</span>
{{else}}
<span class="badge badge-gold">{{icon "mail"}} SMTP nicht konfiguriert</span>
{{end}}
</div>
</section>
<section class="toolbar card">
<div class="toolbar-group range-nav">
<a class="icon-button" href="/dispatch?start={{.Data.PrevStart}}&amp;end={{.Data.PrevEnd}}" title="Vorheriger Monat">{{icon "left"}}</a>
<form class="range-form" method="get" action="/dispatch">
<label class="field field-inline"><span>Von</span><input type="date" name="start" value="{{.Data.Start}}"></label>
<label class="field field-inline"><span>Bis</span><input type="date" name="end" value="{{.Data.End}}"></label>
<button class="btn btn-secondary btn-small" type="submit">Anzeigen</button>
</form>
<a class="icon-button" href="/dispatch?start={{.Data.NextStart}}&amp;end={{.Data.NextEnd}}" title="Nächster Monat">{{icon "right"}}</a>
</div>
<div class="toolbar-group">
<span class="range-label">{{rangeLong .Data.Range}}</span>
<a class="chip" href="/dispatch">{{icon "calendar"}} Dieser Monat</a>
</div>
</section>
<section class="stat-strip four">
<article class="mini-stat"><span class="mini-stat-label">E-Mail</span><strong>{{.Data.EmailCount}}</strong><small>Empfänger mit Adresse</small></article>
<article class="mini-stat"><span class="mini-stat-label">Ausdruck</span><strong>{{.Data.PrintCount}}</strong><small>im Sammel-PDF</small></article>
<article class="mini-stat"><span class="mini-stat-label">Ohne Versand</span><strong>{{.Data.NoneCount}}</strong><small>bewusst ausgelassen</small></article>
<article class="mini-stat"><span class="mini-stat-label">Offene Dienste</span><strong>{{.Data.OpenSlots}}</strong><small>in {{.Data.ServiceCount}} Gottesdiensten</small></article>
</section>
{{if not .Data.SMTPConfigured}}
<div class="notice notice-gold">
<span class="notice-mark">{{icon "mail"}}</span>
<div>
<strong>E-Mail-Versand noch nicht eingerichtet</strong>
<p>Hinterlegen Sie die SMTP-Zugangsdaten in den Einstellungen, damit E-Mails direkt verschickt werden können. Ausdrucke funktionieren bereits ohne SMTP.</p>
</div>
<a class="btn btn-secondary btn-small" href="/settings">{{icon "settings"}} Zu den Einstellungen</a>
</div>
{{end}}
<form method="post" action="/dispatch/save" class="page-stack" data-dispatch-form>
<input type="hidden" name="csrf" value="{{.CSRF}}">
<input type="hidden" name="start" value="{{.Data.Start}}">
<input type="hidden" name="end" value="{{.Data.End}}">
<section class="card">
<div class="card-head">
<div><span class="eyebrow">Texte</span><h3>Anschreiben</h3></div>
<span class="count-pill">Platzhalter {start} und {end}</span>
</div>
<div class="settings-grid">
<div class="settings-copy">
<h4>Ein Text für alle</h4>
<p>Der Einleitungstext erscheint in jeder E-Mail und als Vorblatt im Ausdruck. Zwischen Einleitung und Abschluss wird automatisch die Einsatzübersicht der jeweiligen Person eingefügt. Die Platzhalter <code>{start}</code> und <code>{end}</code> werden beim Versand durch den Planungszeitraum ersetzt.</p>
<p class="muted">Ein leer gelassenes Einleitungsfeld stellt den Standardtext wieder her.</p>
</div>
<div class="settings-fields">
<label class="field"><span class="field-label">Einleitungstext</span>
<textarea name="intro" rows="6" maxlength="6000">{{.Data.Intro}}</textarea>
</label>
<label class="field"><span class="field-label">Abschlussgrußformel</span>
<textarea name="greeting" rows="3" maxlength="2000">{{.Data.Greeting}}</textarea>
</label>
</div>
</div>
</section>
<section class="card">
<div class="card-head">
<div><span class="eyebrow">Empfänger</span><h3>Versandweg je Person</h3></div>
<div class="dispatch-bulk">
<button class="btn btn-ghost btn-small" type="button" data-dispatch-all="email">Alle E-Mail</button>
<button class="btn btn-ghost btn-small" type="button" data-dispatch-all="print">Alle Ausdruck</button>
<button class="btn btn-ghost btn-small" type="button" data-dispatch-all="reset">Zurücksetzen</button>
</div>
</div>
<div class="table-scroll">
<table class="data-table dispatch-table">
<thead>
<tr>
<th>Person</th>
<th>Einsätze</th>
<th>Versandweg</th>
<th>Liste</th>
<th>Vorblatt</th>
</tr>
</thead>
<tbody>
{{range .Data.People}}
{{$person := .Person}}
{{$effective := .Effective}}
<tr>
<td>
<div class="dispatch-person">
<strong>{{$person.FullName}}</strong>
<small>{{$person.RoleLabel}}</small>
{{if $person.Email}}
<a href="mailto:{{$person.Email}}">{{$person.Email}}</a>
{{else}}
<span class="dispatch-no-mail">keine E-Mail-Adresse hinterlegt</span>
{{end}}
</div>
</td>
<td>
{{if .Assignments}}
<details class="dispatch-details">
<summary>{{.AssignmentCount}} {{if eq .AssignmentCount 1}}Einsatz{{else}}Einsätze{{end}}</summary>
<ul>
{{range .Assignments}}
<li><span>{{.DateLabel}}</span><span>{{.TimeLabel}}</span><span>{{.Church}}</span><span>{{.RoleLabel}}</span></li>
{{end}}
</ul>
</details>
{{else}}
<span class="muted">keine Einsätze</span>
{{end}}
</td>
<td>
<select name="channel_{{$person.ID}}" data-dispatch-channel aria-label="Versandweg für {{$person.FullName}}">
{{if $person.Email}}<option value="email" {{if eq .Channel "email"}}selected{{end}}>E-Mail</option>{{end}}
<option value="print" {{if eq .Channel "print"}}selected{{end}}>Ausdruck</option>
<option value="none" {{if eq .Channel "none"}}selected{{end}}>Nicht versenden</option>
</select>
{{if and (eq .Channel "email") (not $person.Email)}}<small class="dispatch-warn">ohne Adresse → Ausdruck</small>{{end}}
</td>
<td>
<select name="variant_{{$person.ID}}" aria-label="Liste für {{$person.FullName}}">
<option value="compact" {{if eq .Variant "compact"}}selected{{end}}>Kompaktansicht</option>
<option value="full" {{if eq .Variant "full"}}selected{{end}}>Ausführlicher Plan</option>
</select>
</td>
<td class="dispatch-cover">
<label class="check">
<input type="checkbox" name="cover_{{$person.ID}}" value="1" {{if .Cover}}checked{{end}}>
<span>{{if eq $effective "email"}}E-Mail-Text{{else}}Anschreiben{{end}}</span>
</label>
</td>
</tr>
{{else}}
<tr><td colspan="5"><p class="empty-note">Im aktiven Mandanten sind noch keine aktiven Personen hinterlegt.</p></td></tr>
{{end}}
</tbody>
</table>
</div>
<p class="table-note">E-Mail-Empfänger erhalten den Plan als PDF-Anhang. Personen ohne Adresse oder mit der Auswahl „Ausdruck“ werden in einem sammelbaren PDF zusammengefasst – nacheinander mit Vorblatt und gewählter Liste.</p>
<div class="card-foot dispatch-actions">
<button class="btn btn-secondary" type="submit">{{icon "check"}} Auswahl speichern</button>
<button class="btn btn-primary" type="submit" formaction="/dispatch/send" data-confirm="Die E-Mails jetzt an alle ausgewählten Empfänger senden?">{{icon "send"}} E-Mails senden</button>
<button class="btn btn-secondary" type="submit" formaction="/dispatch/print" formtarget="_blank">{{icon "printer"}} Druck-PDF erzeugen</button>
</div>
</section>
</form>
{{with .Data.LastEntry}}
<section class="card dispatch-last">
<div class="card-head">
<div><span class="eyebrow">Letzte Versendung</span><h3>{{rangeShort $.Data.Range}} · {{.CreatedAt.Format "02.01.2006, 15:04"}} Uhr</h3></div>
<span class="count-pill">{{len $.Data.LastBatch}} {{if eq (len $.Data.LastBatch) 1}}Eintrag{{else}}Einträge{{end}}</span>
</div>
<div class="dispatch-last-grid">
<div><span class="field-caption">Zeitraum</span><strong>{{shortDate .RangeStart}} – {{shortDate .RangeEnd}}</strong></div>
<div><span class="field-caption">Ausgelöst von</span><strong>{{if .CreatedBy}}{{.CreatedBy}}{{else}}unbekannt{{end}}</strong></div>
<div><span class="field-caption">Aktion</span><strong>{{statusLabel .Status}}</strong></div>
</div>
<ul class="dispatch-log-list">
{{range $.Data.LastBatch}}
<li>
<strong>{{.PersonName}}</strong>
<span>{{channelLabel .Channel}} · {{variantLabel .Variant}}{{if .Cover}} · mit Vorblatt{{end}}</span>
<span class="dispatch-log-status status-{{.Status}}">{{statusLabel .Status}}</span>
{{if .Detail}}<small>{{.Detail}}</small>{{end}}
</li>
{{end}}
</ul>
</section>
{{end}}
{{if .Data.History}}
<section class="card">
<div class="card-head"><div><span class="eyebrow">Protokoll</span><h3>Versendungen im Überblick</h3></div><span class="count-pill">{{len .Data.History}}</span></div>
<div class="table-scroll">
<table class="data-table compact-table">
<thead>
<tr><th>Zeitpunkt</th><th>Zeitraum</th><th>Person</th><th>Kanal</th><th>Liste</th><th>Status</th><th>Von</th></tr>
</thead>
<tbody>
{{range .Data.History}}
<tr>
<td>{{.CreatedAt.Format "02.01.2006, 15:04"}}</td>
<td>{{shortDate .RangeStart}} – {{shortDate .RangeEnd}}</td>
<td>{{.PersonName}}{{if .Email}}<br><small>{{.Email}}</small>{{end}}</td>
<td>{{channelLabel .Channel}}{{if .Cover}}<br><small>mit Vorblatt</small>{{end}}</td>
<td>{{variantLabel .Variant}}</td>
<td><span class="dispatch-log-status status-{{.Status}}">{{statusLabel .Status}}</span></td>
<td>{{.CreatedBy}}</td>
</tr>
{{end}}
</tbody>
</table>
</div>
</section>
{{end}}
</div>
{{end}}
+220
View File
@@ -0,0 +1,220 @@
{{define "content"}}
<div class="page-stack guest-stack">
<section class="page-intro">
<div>
<span class="eyebrow">Öffentlicher Plan · {{.Data.TenantName}}</span>
<h2>{{rangeLong .Data.Range}}</h2>
<p>Alle Gottesdienste mit liturgischen Angaben und Lesungsverweisen – ohne Namen der eingesetzten Personen, ohne Einstellungen und ohne Schreibzugriffe.</p>
</div>
<div class="intro-actions">
{{if gt (len .Data.Tenants) 1}}
<form class="tenant-form" method="get" action="/guest">
<label class="field field-inline"><span>Pfarrei</span>
<select name="tid" onchange="this.form.submit()" aria-label="Pfarrei wählen">
{{range .Data.Tenants}}<option value="{{.ID}}" {{if eq .ID $.Data.TenantID}}selected{{end}}>{{.Name}}</option>{{end}}
</select>
</label>
<noscript><button class="btn btn-secondary btn-small" type="submit">Anzeigen</button></noscript>
</form>
{{end}}
<span class="badge badge-green">Nur Lesen</span>
</div>
</section>
<section class="toolbar card">
<div class="toolbar-group range-nav">
<a class="icon-button" href="/guest?tid={{.Data.TenantID}}&amp;start={{.Data.PrevStart}}&amp;end={{.Data.PrevEnd}}" title="Vorheriger Monat">{{icon "left"}}</a>
<form class="range-form" method="get" action="/guest">
<input type="hidden" name="tid" value="{{.Data.TenantID}}">
<label class="field field-inline"><span>Von</span><input type="date" name="start" value="{{.Data.Start}}"></label>
<label class="field field-inline"><span>Bis</span><input type="date" name="end" value="{{.Data.End}}"></label>
<button class="btn btn-secondary btn-small" type="submit">Anzeigen</button>
</form>
<a class="icon-button" href="/guest?tid={{.Data.TenantID}}&amp;start={{.Data.NextStart}}&amp;end={{.Data.NextEnd}}" title="Nächster Monat">{{icon "right"}}</a>
</div>
<div class="toolbar-group">
<a class="chip" href="/guest?tid={{.Data.TenantID}}">{{icon "calendar"}} Dieser Monat</a>
</div>
</section>
<section class="stat-strip three">
<article class="mini-stat"><span class="mini-stat-label">Gottesdienste</span><strong>{{.Data.ServiceCount}}</strong><small>im gewählten Zeitraum</small></article>
<article class="mini-stat {{if gt .Data.OpenSlots 0}}warn{{end}}"><span class="mini-stat-label">Offene Dienste</span><strong>{{.Data.OpenSlots}}</strong><small>{{plural .Data.OpenSlots "Dienst" "Dienste"}}</small></article>
<article class="mini-stat"><span class="mini-stat-label">Kirchen</span><strong>{{len .Data.Churches}}</strong><small>im öffentlichen Plan</small></article>
</section>
<div class="plan-legend">
<div class="filter-chips" role="group" aria-label="Tage filtern">
<button class="chip active" type="button" data-plan-filter="all">Alle Tage</button>
<button class="chip" type="button" data-plan-filter="services">Mit Gottesdiensten</button>
<button class="chip" type="button" data-plan-filter="open">Nur offene</button>
<button class="chip" type="button" data-plan-filter="feasts">Sonn- &amp; Feiertage</button>
</div>
<div class="legend-items">
<span><i class="swatch sunday"></i>Sonntag</span>
<span><i class="swatch feast"></i>Hochfest</span>
<span><i class="swatch open"></i>Offener Dienst</span>
</div>
</div>
<section class="calendar-card" data-plan-table>
<div class="table-scroll plan-table-desktop">
<table class="calendar-table">
<thead>
<tr>
<th class="col-date">Tag</th>
<th class="col-liturgy">Liturgie &amp; Lesungen</th>
{{range .Data.Churches}}
<th class="col-church">
<span class="church-head" title="{{.Name}} · {{.Address}}">
{{churchGlyph .Symbol .ColorHex}}
<span class="church-head-text"><strong>{{.ShortName}}</strong><small>{{.Name}}</small></span>
</span>
</th>
{{end}}
</tr>
</thead>
<tbody>
{{range $row := .Data.Rows}}
<tr class="plan-row {{if .IsHighFeast}}is-highfeast{{else if .IsSunday}}is-sunday{{else if .IsObligation}}is-obligation{{else if .IsFeast}}is-feast{{end}}"
data-plan-row
data-has-services="{{if .HasServices}}true{{else}}false{{end}}"
data-open="{{.OpenSlots}}"
data-special="{{if .IsSpecialDay}}true{{else}}false{{end}}">
<td class="date-cell">
<div class="date-number">{{dayNumber .Date}}</div>
<div class="date-meta"><span>{{shortWeekday .Date}}</span><span>{{shortMonth .Date}}</span></div>
{{if .LiturgicalDay}}<span class="liturgical-bar" style="background:{{liturgicalColor .LiturgicalDay}}"></span>{{end}}
</td>
<td class="liturgy-cell">
{{if .LiturgicalDay}}
<div class="liturgy-title">
{{feastGlyph .LiturgicalDay.Symbol}}
<strong>{{.LiturgicalDay.DisplayTitle}}</strong>
</div>
<div class="liturgy-meta">
{{if .LiturgicalDay.BadgeText}}<span class="badge badge-rank rank-{{.LiturgicalDay.Rank.ShortLabel}}">{{.LiturgicalDay.BadgeText}}</span>{{end}}
<span class="badge badge-color" style="--badge-color:{{liturgicalColor .LiturgicalDay}}">{{.LiturgicalDay.Color.Label}}</span>
{{if .LiturgicalDay.IsObligation}}<span class="badge badge-burgundy">geboten</span>{{end}}
</div>
{{if not .LiturgicalDay.Readings.IsEmpty}}
<a class="readings" href="https://schott.erzabtei-beuron.de/?datum={{isoDate .Date}}" target="_blank" rel="noopener" title="{{.LiturgicalDay.Readings.FullLabel}} · Tageslesungen bei Schott öffnen">{{.LiturgicalDay.Readings.ShortLabel}}{{icon "external"}}</a>
{{end}}
{{if .LiturgicalDay.Remark}}<div class="liturgy-remark">{{.LiturgicalDay.Remark}}</div>{{end}}
{{else}}
<span class="muted">—</span>
{{end}}
</td>
{{range $.Data.Churches}}
{{$church := .}}
<td class="church-cell">
{{$services := $row.ServicesForChurch $church.ID}}
{{if $services}}
<div class="service-stack">
{{range $services}}
<article class="service-card guest-service {{if .IsFullyStaffed}}staffed{{else}}open{{end}}">
<span class="service-time">{{timeLabel .Service.TimeMinutes}}</span>
<span class="service-title">{{.Service.Title}}{{if eq (printf "%s" .Service.Kind) "special"}}<span class="service-kind">Sonder</span>{{end}}</span>
{{if .Service.Location}}<span class="service-location">{{deref .Service.Location}}</span>{{end}}
<span class="service-people">
{{range .Assignments}}
<span class="person-chip role-{{roleShort .Role}}" title="{{roleTitle .Role}}">{{roleTitle .Role}}</span>
{{end}}
</span>
{{if not .IsFullyStaffed}}<span class="open-badge">{{plural .OpenSlots "Platz offen" "Plätze offen"}}</span>{{end}}
</article>
{{end}}
</div>
{{else}}
<span class="empty-cell">—</span>
{{end}}
</td>
{{end}}
</tr>
{{end}}
</tbody>
</table>
</div>
<div class="plan-mobile-list">
<p class="plan-mobile-hint">Tippen Sie auf einen Tag, um die Gottesdienste zu sehen.</p>
{{range $row := .Data.Rows}}
<details class="plan-day-card {{if .IsHighFeast}}is-highfeast{{else if .IsSunday}}is-sunday{{else if .IsObligation}}is-obligation{{else if .IsFeast}}is-feast{{end}}"
data-plan-row
data-has-services="{{if .HasServices}}true{{else}}false{{end}}"
data-open="{{.OpenSlots}}"
data-special="{{if .IsSpecialDay}}true{{else}}false{{end}}">
<summary class="plan-day-summary">
<span class="day-date">
<span class="date-number">{{dayNumber $row.Date}}</span>
<span class="date-meta"><span>{{shortWeekday $row.Date}}</span><span>{{shortMonth $row.Date}}</span></span>
{{if $row.LiturgicalDay}}<span class="liturgical-bar" style="background:{{liturgicalColor $row.LiturgicalDay}}"></span>{{end}}
</span>
<span class="day-main">
<span class="day-title">
{{if $row.LiturgicalDay}}
{{feastGlyph $row.LiturgicalDay.Symbol}}
<strong>{{$row.LiturgicalDay.DisplayTitle}}</strong>
{{else}}
<strong>Keine Liturgie hinterlegt</strong>
{{end}}
</span>
<span class="day-status">
{{if $row.HasServices}}
<span>{{len $row.Services}} {{plural (len $row.Services) "Gottesdienst" "Gottesdienste"}}</span>
{{if gt $row.OpenSlots 0}}
<span class="day-status-open">{{$row.OpenSlots}} {{plural $row.OpenSlots "Dienst offen" "Dienste offen"}}</span>
{{else}}
<span class="day-status-ok">vollständig besetzt</span>
{{end}}
{{else}}
<span class="day-status-empty">Keine Gottesdienste</span>
{{end}}
</span>
</span>
<span class="day-chevron" aria-hidden="true">{{icon "right"}}</span>
</summary>
<div class="day-details">
{{if $row.LiturgicalDay}}
{{if not $row.LiturgicalDay.Readings.IsEmpty}}
<a class="readings day-readings" href="https://schott.erzabtei-beuron.de/?datum={{isoDate $row.Date}}" target="_blank" rel="noopener" title="{{$row.LiturgicalDay.Readings.FullLabel}} · Tageslesungen bei Schott öffnen">{{$row.LiturgicalDay.Readings.ShortLabel}}{{icon "external"}}</a>
{{end}}
{{if $row.LiturgicalDay.Remark}}<div class="liturgy-remark">{{$row.LiturgicalDay.Remark}}</div>{{end}}
{{end}}
{{range $.Data.Churches}}
{{$church := .}}
{{$services := $row.ServicesForChurch $church.ID}}
{{if $services}}
<div class="day-church">
<div class="day-church-head">
{{churchGlyph .Symbol .ColorHex}}
<span><strong>{{.ShortName}}</strong><small>{{.Name}}</small></span>
</div>
<div class="service-stack">
{{range $services}}
<article class="service-card day-service-card guest-service {{if .IsFullyStaffed}}staffed{{else}}open{{end}}">
<span class="service-time">{{timeLabel .Service.TimeMinutes}}</span>
<span class="service-title">{{.Service.Title}}{{if eq (printf "%s" .Service.Kind) "special"}}<span class="service-kind">Sonder</span>{{end}}</span>
{{if .Service.Location}}<span class="service-location">{{deref .Service.Location}}</span>{{end}}
<span class="service-people">
{{range .Assignments}}
<span class="person-chip role-{{roleShort .Role}}" title="{{roleTitle .Role}}">{{roleTitle .Role}}</span>
{{end}}
</span>
{{if not .IsFullyStaffed}}<span class="open-badge">{{plural .OpenSlots "Platz offen" "Plätze offen"}}</span>{{end}}
</article>
{{end}}
</div>
</div>
{{end}}
{{end}}
{{if not $row.HasServices}}<p class="empty-note">Für diesen Tag sind keine Gottesdienste eingetragen.</p>{{end}}
</div>
</details>
{{end}}
<p class="plan-mobile-empty empty-note" data-plan-mobile-empty hidden>Keine Tage passen zu diesem Filter.</p>
</div>
</section>
<p class="table-note">Gastansicht: Die Einsätze werden nur mit ihrer Rolle angezeigt. Liturgische Daten von www.eucharistiefeier.de, Lesungen verlinkt zu Schott.</p>
</div>
{{end}}
+34 -4
View File
@@ -3,13 +3,40 @@
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{{.Title}} · LektorenPlan</title>
<title>{{.Title}} · Ordo Voluntariorum</title>
<meta name="theme-color" content="#f4efe4">
<link rel="stylesheet" href="/static/style.css">
<script defer src="/static/app.js"></script>
</head>
<body class="{{if not .User}}auth-page{{else}}app-page{{end}}">
{{if .User}}
<body class="{{if .Guest}}guest-page{{else if not .User}}auth-page{{else}}app-page{{end}}">
{{if .Guest}}
<div class="guest-shell">
<header class="guest-bar">
<a class="brand" href="/guest" aria-label="Gastzugang Startseite">
<span class="brand-mark" aria-hidden="true">
<svg viewBox="0 0 48 48" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
<path d="M8 40h32M12 40V22l12-8 12 8v18"/>
<path d="M24 8v14M20 12h8"/>
<path d="M19 40V31a5 5 0 0 1 10 0v9"/>
<path d="M6 40h36" stroke-dasharray="2 3" stroke-opacity=".45"/>
</svg>
</span>
<span class="brand-text"><strong>Ordo Voluntariorum</strong><small>Gastzugang · nur Lesen</small></span>
</a>
<div class="guest-actions">
<span class="badge badge-gold">Gastzugang</span>
<a class="btn btn-secondary btn-small" href="/login">{{icon "logout"}} Anmelden</a>
</div>
</header>
<main class="content guest-content">
{{template "content" .}}
</main>
<footer class="app-footer guest-foot">
<span>Gastansicht · keine Einstellungen, keine Schreibzugriffe, keine Personennamen</span>
<span>Liturgische Daten: www.eucharistiefeier.de</span>
</footer>
</div>
{{else if .User}}
<div class="app-shell">
<aside class="sidebar">
<a class="brand" href="/plan" aria-label="LektorenPlan Startseite">
@@ -21,7 +48,7 @@
<path d="M6 40h36" stroke-dasharray="2 3" stroke-opacity=".45"/>
</svg>
</span>
<span class="brand-text"><strong>LektorenPlan</strong><small>Pfarreiplanung im Netz</small></span>
<span class="brand-text"><strong>Ordo Voluntariorum</strong><small>Homo proponit, Deus disponit.</small></span>
</a>
<button class="sidebar-close icon-button" type="button" data-nav-close aria-label="Navigation schließen">{{icon "close"}}</button>
@@ -54,6 +81,9 @@
<a class="nav-link {{if eq .Active "services"}}active{{end}}" href="/services">{{icon "list"}}<span>Gottesdienstordnung</span></a>
<a class="nav-link {{if eq .Active "team"}}active{{end}}" href="/team">{{icon "users"}}<span>Team &amp; Abwesenheiten</span></a>
<a class="nav-link {{if eq .Active "statistics"}}active{{end}}" href="/statistics">{{icon "chart"}}<span>Statistik</span></a>
{{if .IsEditor}}
<a class="nav-link {{if eq .Active "dispatch"}}active{{end}}" href="/dispatch">{{icon "send"}}<span>Versendung</span></a>
{{end}}
<span class="nav-heading">Organisation</span>
<a class="nav-link {{if eq .Active "exchange"}}active{{end}}" href="/exchange">{{icon "exchange"}}<span>Austausch</span></a>
+5 -1
View File
@@ -11,7 +11,7 @@
</svg>
</span>
<div>
<h1>LektorenPlan</h1>
<h1>Ordo Voluntariorum</h1>
<p>Gottesdienste, Dienste und Menschen klug zusammenbringen.</p>
</div>
</div>
@@ -48,6 +48,10 @@
</label>
<button class="btn btn-primary btn-block" type="submit">Anmelden</button>
</form>
<div class="auth-guest">
<a class="btn btn-secondary btn-block" href="/guest">{{icon "users"}} Gastzugang ohne Anmeldung</a>
<p class="auth-guest-note">Öffentlicher Gottesdienstplan mit liturgischen Angaben – ohne Namen der eingesetzten Personen und ohne Schreibzugriffe.</p>
</div>
{{if .DemoMode}}
<div class="demo-accounts">
<span class="demo-accounts-title">Demo-Zugänge</span>
+38
View File
@@ -50,6 +50,44 @@
</section>
{{end}}
{{if .Data.CanEdit}}
<section class="card">
<div class="card-head"><div><span class="eyebrow">Versendung</span><h3>E-Mail-Versand (SMTP)</h3></div>{{if .Data.SMTPConfigured}}<span class="badge badge-green">{{icon "check"}} konfiguriert</span>{{else}}<span class="badge badge-gold">noch nicht konfiguriert</span>{{end}}</div>
<div class="settings-grid">
<div class="settings-copy">
<h4>Zugangsdaten des Postfachs</h4>
<p>Diese Angaben gelten für den aktiven Mandanten und werden für den Versand der Pläne über die Versendungsansicht benötigt. Üblich sind Port 587 mit STARTTLS oder Port 465 mit SSL/TLS.</p>
<p class="muted">Das Passwort wird gespeichert, aber nie wieder angezeigt. Leer lassen, um das bisherige Passwort beizubehalten.</p>
</div>
<div class="settings-fields">
<div class="form-row">
<label class="field"><span class="field-label">SMTP-Server</span><input type="text" name="smtp_host" value="{{.Data.SMTPHost}}" placeholder="smtp.example.org" {{if not .Data.CanEdit}}disabled{{end}}></label>
<label class="field narrow"><span class="field-label">Port</span><input type="number" name="smtp_port" min="0" max="65535" value="{{.Data.SMTPPort}}" placeholder="587" {{if not .Data.CanEdit}}disabled{{end}}></label>
</div>
<label class="field"><span class="field-label">Verschlüsselung</span>
<select name="smtp_encryption" {{if not .Data.CanEdit}}disabled{{end}}>
<option value="starttls" {{if eq .Data.SMTPEncryption "starttls"}}selected{{end}}>STARTTLS (Port 587)</option>
<option value="ssl" {{if eq .Data.SMTPEncryption "ssl"}}selected{{end}}>SSL/TLS (Port 465)</option>
<option value="none" {{if eq .Data.SMTPEncryption "none"}}selected{{end}}>Ohne Verschlüsselung</option>
</select>
</label>
<div class="form-row">
<label class="field"><span class="field-label">Benutzername</span><input type="text" name="smtp_username" value="{{.Data.SMTPUsername}}" autocomplete="off" {{if not .Data.CanEdit}}disabled{{end}}></label>
<label class="field"><span class="field-label">Passwort {{if .Data.SMTPPasswordSet}}<small>gespeichert</small>{{end}}</span><input type="password" name="smtp_password" value="" autocomplete="new-password" placeholder="{{if .Data.SMTPPasswordSet}}•••••••• (unverändert){{end}}" {{if not .Data.CanEdit}}disabled{{end}}></label>
</div>
<div class="form-row">
<label class="field"><span class="field-label">Absenderadresse</span><input type="email" name="smtp_from_address" value="{{.Data.SMTPFromAddress}}" placeholder="pfarramt@example.org" {{if not .Data.CanEdit}}disabled{{end}}></label>
<label class="field"><span class="field-label">Absendername</span><input type="text" name="smtp_from_name" value="{{.Data.SMTPFromName}}" placeholder="Pfarreiengemeinschaft" {{if not .Data.CanEdit}}disabled{{end}}></label>
</div>
{{if .Data.SMTPPasswordSet}}
<label class="check"><input type="checkbox" name="smtp_clear_password" value="1" {{if not .Data.CanEdit}}disabled{{end}}><span>Gespeichertes Passwort entfernen</span></label>
{{end}}
<p class="source-note">{{icon "send"}} Der Versand erfolgt direkt über diesen Server; das Protokoll finden Sie unter „Versendung“.</p>
</div>
</div>
</section>
{{end}}
<section class="card">
<div class="card-head"><div><span class="eyebrow">Planung</span><h3>Regeln und Gewichtung</h3></div></div>
<div class="settings-grid">