299 lines
9.9 KiB
Go
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)
|
|
}
|