Files
LektorenPlan/web/web/settings_handlers.go
T

299 lines
9.9 KiB
Go

package web
import (
"fmt"
"net/http"
"strings"
"lektorenplan/store"
)
type settingsPageData struct {
Settings map[string]string
AutoSync bool
Diocese string
LastSync string
Counts map[string]int
ChurchCount int
CanEdit bool
CanManageSecrets bool
IsAdmin bool
Database string
DemoReset bool
LoginQuote string
LoginQuoteSource string
SMTPHost string
SMTPPort string
SMTPUsername string
SMTPPasswordSet bool
SMTPFromAddress string
SMTPFromName string
SMTPEncryption string
SMTPConfigured bool
}
const (
defaultLoginQuote = "Jeder Sonntag braucht Menschen, die das Wort tragen und die Gemeinschaft begleiten."
defaultLoginQuoteSource = "Pfarreiengemeinschaft Bad Godesberg"
)
func (s *Server) loginQuote(r *http.Request) string {
if value := strings.TrimSpace(s.store.Setting(r.Context(), "loginQuoteText")); value != "" {
return value
}
return defaultLoginQuote
}
func (s *Server) loginQuoteSource(r *http.Request) string {
if value := strings.TrimSpace(s.store.Setting(r.Context(), "loginQuoteSource")); value != "" {
return value
}
return defaultLoginQuoteSource
}
var dioceseOptions = []struct {
Key string
Label string
}{
{"koeln", "Erzbistum Köln"},
{"aachen", "Bistum Aachen"},
{"muenster", "Bistum Münster"},
{"paderborn", "Erzbistum Paderborn"},
{"trier", "Bistum Trier"},
{"limburg", "Bistum Limburg"},
{"freiburg", "Erzbistum Freiburg"},
{"mainz", "Bistum Mainz"},
{"speyer", "Bistum Speyer"},
{"wuerzburg", "Bistum Würzburg"},
}
func (s *Server) handleSettings(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
settings, err := s.store.AllTenantSettings(r.Context(), tenant.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Einstellungen", err.Error())
return
}
defaults := map[string]string{
"planner.replaceExisting": "0",
"planner.respectPreferredWeekdays": "1",
"planner.allowDoubleRoles": "0",
"planner.weightChurch": "8.0",
"planner.weightService": "4.0",
"planner.weightFairness": "2.2",
"planner.weightDualRole": "14.0",
"planner.maxPerDay": "1",
}
for key, value := range defaults {
if _, ok := settings[key]; !ok {
settings[key] = value
}
}
counts, err := s.store.CountTenantData(r.Context(), tenant.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Einstellungen", err.Error())
return
}
page := settingsPageData{
Settings: settings,
AutoSync: s.store.Setting(r.Context(), "autoSyncLiturgy") != "0",
Diocese: s.store.Setting(r.Context(), "diocese"),
LastSync: s.store.Setting(r.Context(), "lastLiturgicalSync"),
Counts: counts,
CanEdit: s.store.CanEditTenant(r.Context(), user, tenant.ID),
CanManageSecrets: s.store.CanManageSecrets(r.Context(), user, tenant.ID),
IsAdmin: user.Role.IsAdmin(),
Database: s.store.Path(),
DemoReset: tenant.Slug == "bad-godesberg" || tenant.Slug == "rheinaue",
LoginQuote: s.loginQuote(r),
LoginQuoteSource: s.loginQuoteSource(r),
}
if page.CanManageSecrets {
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"
}
data := s.baseView(w, r, "Einstellungen", "settings")
data.Data = page
s.renderPage(w, r, "settings", data)
}
func (s *Server) handleSettingsSave(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/plan")
return
}
if user.Role.IsAdmin() {
_ = s.store.SetSetting(r.Context(), "autoSyncLiturgy", boolSetting(r.FormValue("auto_sync")))
diocese := strings.TrimSpace(r.FormValue("diocese"))
if diocese == "" {
diocese = "koeln"
}
_ = s.store.SetSetting(r.Context(), "diocese", diocese)
quote := strings.TrimSpace(r.FormValue("login_quote"))
if len([]rune(quote)) > 240 {
quote = string([]rune(quote)[:240])
}
if quote == "" {
_ = s.store.RemoveSetting(r.Context(), "loginQuoteText")
} else {
_ = s.store.SetSetting(r.Context(), "loginQuoteText", quote)
}
source := strings.TrimSpace(r.FormValue("login_quote_source"))
if len([]rune(source)) > 120 {
source = string([]rune(source)[:120])
}
if source == "" {
_ = s.store.RemoveSetting(r.Context(), "loginQuoteSource")
} else {
_ = s.store.SetSetting(r.Context(), "loginQuoteSource", source)
}
}
// 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.CanManageSecrets(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.SetSecret(r.Context(), tenant.ID, store.ScopeTenant, 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.SetSecret(r.Context(), tenant.ID, store.ScopeTenant, tenant.ID, "smtp.password", "")
case strings.TrimSpace(r.FormValue("smtp_password")) != "":
_ = s.store.SetSecret(r.Context(), tenant.ID, store.ScopeTenant, 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")),
"planner.allowDoubleRoles": boolSetting(r.FormValue("allow_double_roles")),
"planner.weightChurch": floatSetting(r.FormValue("weight_church"), "8"),
"planner.weightService": floatSetting(r.FormValue("weight_service"), "4"),
"planner.weightFairness": floatSetting(r.FormValue("weight_fairness"), "2.2"),
"planner.weightDualRole": floatSetting(r.FormValue("weight_dual"), "14"),
"planner.maxPerDay": intSetting(r.FormValue("max_per_day"), "1", 1, 4),
}
for key, value := range tenantValues {
if err := s.store.SetTenantSetting(r.Context(), tenant.ID, key, value); err != nil {
s.setFlash(w, "Die Einstellungen konnten nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, "/settings")
return
}
}
s.setFlash(w, "Einstellungen gespeichert.", "success")
s.redirect(w, r, "/settings")
}
func (s *Server) handleResetDemo(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/plan")
return
}
if tenant.Slug != "bad-godesberg" && tenant.Slug != "rheinaue" {
s.setFlash(w, "Demo-Daten können nur für die mitgelieferten Demo-Mandanten wiederhergestellt werden.", "info")
s.redirect(w, r, "/settings")
return
}
if err := s.store.DeleteAllTenantData(r.Context(), tenant.ID); err != nil {
s.setFlash(w, "Die Daten konnten nicht zurückgesetzt werden: "+err.Error(), "error")
s.redirect(w, r, "/settings")
return
}
if err := s.store.SeedDemo(r.Context()); err != nil {
s.setFlash(w, "Die Demo-Daten konnten nicht neu angelegt werden: "+err.Error(), "error")
s.redirect(w, r, "/settings")
return
}
s.setFlash(w, "Demo-Daten wurden neu aufgebaut.", "success")
s.redirect(w, r, "/plan")
}
func (s *Server) handleDeleteTenantData(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/plan")
return
}
if strings.TrimSpace(r.FormValue("confirm")) != "loeschen" {
s.setFlash(w, "Bitte die Bestätigung „loeschen“ eingeben.", "error")
s.redirect(w, r, "/settings")
return
}
if err := s.store.DeleteAllTenantData(r.Context(), tenant.ID); err != nil {
s.setFlash(w, "Die Daten konnten nicht gelöscht werden: "+err.Error(), "error")
s.redirect(w, r, "/settings")
return
}
s.setFlash(w, "Alle Planungsdaten dieses Mandanten wurden gelöscht.", "success")
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"
}
return "0"
}
func floatSetting(value, fallback string) string {
value = strings.TrimSpace(strings.ReplaceAll(value, ",", "."))
var parsed float64
if _, err := fmt.Sscanf(value, "%f", &parsed); err != nil || parsed < 0 || parsed > 100 {
return fallback
}
return fmt.Sprintf("%.1f", parsed)
}
func intSetting(value, fallback string, min, max int) string {
parsed := parseInt(value, -1)
if parsed < min {
parsed = parseInt(fallback, min)
}
if parsed > max {
parsed = max
}
return fmt.Sprintf("%d", parsed)
}