414 lines
13 KiB
Go
414 lines
13 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 = ©
|
|
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 = ©
|
|
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.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
|
|
}
|
|
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.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
|
|
}
|
|
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)
|
|
}
|
|
|
|
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 = ©
|
|
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")
|
|
}
|