Files
LektorenPlan/web/web/admin_handlers.go
T

469 lines
16 KiB
Go

package web
import (
"crypto/rand"
"encoding/hex"
"net/http"
"strings"
"lektorenplan/domain"
"lektorenplan/store"
)
type adminTenantRow struct {
Tenant store.Tenant
Counts map[string]int
UserCount int
}
type adminTenantsPageData struct {
Tenants []adminTenantRow
Edit *store.Tenant
}
type adminPersonOption struct {
TenantID string
TenantName string
ID string
Label string
}
type adminUsersPageData struct {
Users []store.User
Tenants []store.Tenant
TenantsByID map[string]store.Tenant
Roles []store.UserRole
Edit *store.User
SelfID string
PersonOptions []adminPersonOption
}
type adminChurchesPageData struct {
Churches []domain.Church
Symbols []domain.ChurchSymbol
Edit *domain.Church
Tenant *store.Tenant
}
func (s *Server) handleAdminRoot(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
s.redirect(w, r, "/admin/tenants")
}
func (s *Server) handleAdminTenants(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
tenants, err := s.store.Tenants(r.Context())
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Mandanten", err.Error())
return
}
users, err := s.store.Users(r.Context())
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Konten", err.Error())
return
}
rows := make([]adminTenantRow, 0, len(tenants))
for _, item := range tenants {
counts, err := s.store.CountTenantData(r.Context(), item.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Mandanten", err.Error())
return
}
userCount := 0
for _, account := range users {
for _, tenantID := range account.TenantIDs {
if tenantID == item.ID {
userCount++
break
}
}
}
rows = append(rows, adminTenantRow{Tenant: item, Counts: counts, UserCount: userCount})
}
var edit *store.Tenant
if id := strings.TrimSpace(r.URL.Query().Get("edit")); id != "" {
for i := range tenants {
if tenants[i].ID == id {
copy := tenants[i]
edit = &copy
break
}
}
}
page := adminTenantsPageData{Tenants: rows, Edit: edit}
data := s.baseView(w, r, "Mandanten", "admin_tenants")
data.Data = page
s.renderPage(w, r, "admin_tenants", data)
}
func (s *Server) handleAdminTenantSave(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
id := strings.TrimSpace(r.FormValue("id"))
name := strings.TrimSpace(r.FormValue("name"))
slug := strings.TrimSpace(r.FormValue("slug"))
notes := strings.TrimSpace(r.FormValue("notes"))
if name == "" {
s.setFlash(w, "Der Name des Mandanten ist erforderlich.", "error")
s.redirect(w, r, "/admin/tenants")
return
}
if id == "" {
created, err := s.store.CreateTenant(r.Context(), name, slug, notes)
if err != nil {
s.setFlash(w, "Der Mandant konnte nicht angelegt werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/tenants")
return
}
s.setFlash(w, "Mandant „"+created.Name+"“ angelegt.", "success")
s.redirect(w, r, "/admin/tenants?edit="+created.ID)
return
}
existing, err := s.store.Tenant(r.Context(), id)
if err != nil {
s.setFlash(w, "Der Mandant wurde nicht gefunden.", "error")
s.redirect(w, r, "/admin/tenants")
return
}
existing.Name = name
existing.Slug = slug
existing.Notes = notes
if err := s.store.UpdateTenant(r.Context(), existing); err != nil {
s.setFlash(w, "Der Mandant konnte nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/tenants?edit="+id)
return
}
s.setFlash(w, "Mandant gespeichert.", "success")
s.redirect(w, r, "/admin/tenants?edit="+id)
}
func (s *Server) handleAdminTenantDelete(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
id := strings.TrimSpace(r.FormValue("id"))
if id == "" {
s.redirect(w, r, "/admin/tenants")
return
}
if tenant != nil && tenant.ID == id {
s.setFlash(w, "Der gerade aktive Mandant kann nicht gelöscht werden. Bitte zuerst wechseln.", "error")
s.redirect(w, r, "/admin/tenants")
return
}
if err := s.store.DeleteTenant(r.Context(), id); err != nil {
s.setFlash(w, "Der Mandant konnte nicht gelöscht werden: "+err.Error(), "error")
} else {
s.setFlash(w, "Mandant und alle zugehörigen Daten gelöscht.", "success")
}
s.redirect(w, r, "/admin/tenants")
}
func (s *Server) handleAdminUsers(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
users, err := s.store.Users(r.Context())
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Konten", err.Error())
return
}
tenants, err := s.store.Tenants(r.Context())
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Mandanten", err.Error())
return
}
var edit *store.User
if id := strings.TrimSpace(r.URL.Query().Get("edit")); id != "" {
for i := range users {
if users[i].ID == id {
copy := users[i]
edit = &copy
break
}
}
}
tenantsByID := map[string]store.Tenant{}
for _, item := range tenants {
tenantsByID[item.ID] = item
}
var personOptions []adminPersonOption
for _, item := range tenants {
people, err := s.store.People(r.Context(), item.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Team", err.Error())
return
}
for _, person := range people {
personOptions = append(personOptions, adminPersonOption{
TenantID: item.ID, TenantName: item.Name, ID: person.ID, Label: person.FullName(),
})
}
}
page := adminUsersPageData{
Users: users, Tenants: tenants, TenantsByID: tenantsByID, Edit: edit, SelfID: user.ID,
Roles: []store.UserRole{store.RoleAdmin, store.RoleEditor, store.RoleReader},
PersonOptions: personOptions,
}
data := s.baseView(w, r, "Konten", "admin_users")
data.Data = page
s.renderPage(w, r, "admin_users", data)
}
func (s *Server) handleAdminUserSave(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
id := strings.TrimSpace(r.FormValue("id"))
username := strings.TrimSpace(r.FormValue("username"))
displayName := strings.TrimSpace(r.FormValue("display_name"))
password := r.FormValue("password")
role := store.UserRole(strings.TrimSpace(r.FormValue("role")))
active := r.FormValue("active") == "1" || r.FormValue("active") == "on"
tenantIDs := r.Form["tenant_ids"]
forcePasswordChange := r.FormValue("force_password_change") == "1"
linkedTenantID, linkedPersonID := parseLinkedPerson(r.FormValue("linked_person"))
if role != store.RoleReader {
linkedTenantID, linkedPersonID = "", ""
}
if linkedPersonID != "" {
if !containsStringValue(tenantIDs, linkedTenantID) {
s.setFlash(w, "Die verknüpfte Person gehört zu einem Mandanten, der dem Konto nicht freigegeben ist.", "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
if _, err := s.store.Person(r.Context(), linkedTenantID, linkedPersonID); err != nil {
s.setFlash(w, "Die ausgewählte Person wurde nicht gefunden.", "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
}
if !role.IsValid() {
s.setFlash(w, "Bitte eine gültige Rolle auswählen.", "error")
s.redirect(w, r, "/admin/users")
return
}
if id == user.ID && (role != store.RoleAdmin || !active) {
s.setFlash(w, "Das eigene Administratorkonto kann nicht herabgestuft oder deaktiviert werden.", "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
if id == "" {
if strings.TrimSpace(password) == "" {
s.setFlash(w, "Für ein neues Konto ist ein Passwort erforderlich.", "error")
s.redirect(w, r, "/admin/users")
return
}
created, err := s.store.CreateUser(r.Context(), username, displayName, password, role, active, tenantIDs)
if err != nil {
s.setFlash(w, "Das Konto konnte nicht angelegt werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/users")
return
}
if linkedPersonID != "" {
if err := s.store.SetUserPersonLink(r.Context(), created.ID, linkedTenantID, linkedPersonID); err != nil {
s.setFlash(w, "Das Konto wurde angelegt, die Person konnte aber nicht verknüpft werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/users?edit="+created.ID)
return
}
}
s.grantAccountScopes(r.Context(), s.activeEditorKeyring(r.Context()), tenantIDs)
s.setFlash(w, "Konto „"+created.Username+"“ angelegt. Beim ersten Anmelden muss ein eigenes Passwort gesetzt werden.", "success")
s.redirect(w, r, "/admin/users?edit="+created.ID)
return
}
if err := s.store.UpdateUser(r.Context(), id, username, displayName, password, role, active, tenantIDs,
forcePasswordChange, linkedTenantID, linkedPersonID); err != nil {
s.setFlash(w, "Das Konto konnte nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
if err := s.store.PruneUserWrappers(r.Context(), id); err != nil {
s.setFlash(w, "Das Konto wurde gespeichert, alte Schlüsselfreigaben konnten aber nicht entfernt werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
if password != "" {
// A new password would no longer decrypt the existing keypair.
// Editors and readers get a fresh keypair; administrators have none.
if role == store.RoleEditor || role == store.RoleReader {
_, scopes, err := s.store.ResetUserKeys(r.Context(), id, password)
if err != nil {
s.setFlash(w, "Das Passwort wurde gespeichert, die Schlüssel konnten aber nicht neu erzeugt werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
s.dropUserKeyrings(id)
if actor := s.activeEditorKeyring(r.Context()); actor != nil {
if _, err := s.store.RewrapScopes(r.Context(), actor, id, scopes); err != nil {
s.setFlash(w, "Das Konto wurde gespeichert, einige verschlüsselte Daten bleiben aber vorerst gesperrt: "+err.Error(), "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
}
} else {
_ = s.store.DeleteUserKeys(r.Context(), id)
}
}
s.grantAccountScopes(r.Context(), s.activeEditorKeyring(r.Context()), tenantIDs)
s.setFlash(w, "Konto gespeichert.", "success")
s.redirect(w, r, "/admin/users?edit="+id)
}
func (s *Server) handleAdminUserDelete(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
id := strings.TrimSpace(r.FormValue("id"))
if id == user.ID {
s.setFlash(w, "Das eigene Konto kann nicht gelöscht werden.", "error")
s.redirect(w, r, "/admin/users")
return
}
if err := s.store.DeleteUser(r.Context(), id); err != nil {
s.setFlash(w, "Das Konto konnte nicht gelöscht werden: "+err.Error(), "error")
} else {
s.dropUserKeyrings(id)
s.setFlash(w, "Konto gelöscht.", "success")
}
s.redirect(w, r, "/admin/users")
}
func (s *Server) handleAdminUserResetPassword(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
id := strings.TrimSpace(r.FormValue("id"))
if id == "" {
s.redirect(w, r, "/admin/users")
return
}
account, err := s.store.User(r.Context(), id)
if err != nil {
s.setFlash(w, "Das Konto wurde nicht gefunden.", "error")
s.redirect(w, r, "/admin/users")
return
}
buf := make([]byte, 6)
if _, err := rand.Read(buf); err != nil {
s.setFlash(w, "Es konnte kein temporäres Passwort erzeugt werden.", "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
temporary := "lp-" + hex.EncodeToString(buf)
if err := s.store.SetUserPassword(r.Context(), id, temporary, true); err != nil {
s.setFlash(w, "Das Passwort konnte nicht zurückgesetzt werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
// The old keypair was protected by the unknown old password. Editors and
// readers hold keys for encrypted data; administrators never do.
if account.Role != store.RoleEditor && account.Role != store.RoleReader {
_ = s.store.DeleteUserKeys(r.Context(), id)
s.dropUserKeyrings(id)
s.setFlash(w, "Temporäres Passwort für „"+account.Username+"“: "+temporary+
" · Beim nächsten Anmelden muss es geändert werden.", "success")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
_, scopes, err := s.store.ResetUserKeys(r.Context(), id, temporary)
if err != nil {
s.setFlash(w, "Das Passwort wurde zurückgesetzt, die Schlüssel konnten aber nicht neu erzeugt werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/users?edit="+id)
return
}
s.dropUserKeyrings(id)
granted := 0
if actor := s.activeEditorKeyring(r.Context()); actor != nil {
granted, _ = s.store.RewrapScopes(r.Context(), actor, id, scopes)
}
note := ""
if granted < len(scopes) {
note = " Einige Daten bleiben vorerst gesperrt, bis ein entsperrter Redakteur sie erneut freigibt."
}
s.setFlash(w, "Temporäres Passwort für „"+account.Username+"“: "+temporary+
" · Beim nächsten Anmelden muss es geändert werden."+note, "success")
s.redirect(w, r, "/admin/users?edit="+id)
}
func parseLinkedPerson(value string) (string, string) {
parts := strings.SplitN(strings.TrimSpace(value), "::", 2)
if len(parts) != 2 {
return "", ""
}
return strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1])
}
func containsStringValue(values []string, needle string) bool {
for _, value := range values {
if value == needle {
return true
}
}
return false
}
func (s *Server) handleAdminChurches(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
churches, err := s.store.Churches(r.Context(), tenant.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Kirchen", err.Error())
return
}
var edit *domain.Church
if id := strings.TrimSpace(r.URL.Query().Get("edit")); id != "" {
for i := range churches {
if churches[i].ID == id {
copy := churches[i]
edit = &copy
break
}
}
}
page := adminChurchesPageData{
Churches: churches, Symbols: domain.AllChurchSymbols, Edit: edit, Tenant: tenant,
}
data := s.baseView(w, r, "Kirchen", "admin_churches")
data.Data = page
s.renderPage(w, r, "admin_churches", data)
}
func (s *Server) handleAdminChurchSave(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/admin/churches")
return
}
id := strings.TrimSpace(r.FormValue("id"))
if id == "" {
id = domain.NewID()
}
symbol := domain.ChurchSymbol(strings.TrimSpace(r.FormValue("symbol")))
validSymbol := false
for _, candidate := range domain.AllChurchSymbols {
if candidate == symbol {
validSymbol = true
break
}
}
if !validSymbol {
symbol = domain.SymbolChapel
}
church := domain.Church{
ID: id, Name: strings.TrimSpace(r.FormValue("name")),
ShortName: strings.TrimSpace(r.FormValue("short_name")),
Symbol: symbol, ColorHex: strings.TrimSpace(r.FormValue("color_hex")),
Address: strings.TrimSpace(r.FormValue("address")),
SortIndex: parseInt(r.FormValue("sort_index"), 0),
Notes: strings.TrimSpace(r.FormValue("notes")),
}
if church.ColorHex == "" {
church.ColorHex = "#4E6E5D"
}
if err := s.store.UpsertChurch(r.Context(), tenant.ID, church); err != nil {
s.setFlash(w, "Die Kirche konnte nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, "/admin/churches?edit="+id)
return
}
s.setFlash(w, "Kirche gespeichert.", "success")
s.redirect(w, r, "/admin/churches?edit="+id)
}
func (s *Server) handleAdminChurchDelete(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/admin/churches")
return
}
id := strings.TrimSpace(r.FormValue("id"))
if err := s.store.DeleteChurch(r.Context(), tenant.ID, id); err != nil {
s.setFlash(w, "Die Kirche konnte nicht gelöscht werden: "+err.Error(), "error")
} else {
s.setFlash(w, "Kirche sowie zugehörige Vorlagen und Gottesdienste gelöscht.", "success")
}
s.redirect(w, r, "/admin/churches")
}