1. Version Versendung

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

No files matched your search

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