1. Version Versendung
This commit is contained in:
1 parent
d7113afa5f
commit
781aa20253
31 files changed
+4023
-10
No files matched your search
@@ -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
|
||||
|
||||
@@ -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=
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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
|
||||
})
|
||||
}
|
||||
@@ -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 {
|
||||
|
||||
@@ -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")),
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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))
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
})();
|
||||
@@ -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 {
|
||||
|
||||
@@ -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}}&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}}&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}}
|
||||
@@ -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}}&start={{.Data.PrevStart}}&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}}&start={{.Data.NextStart}}&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- & 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 & 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}}
|
||||
@@ -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 & 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>
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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">
|
||||
|
||||
Reference in new issue
Block a user