SMTP-Credentials und E_Mail-Adressen verschlüsselt abgelegt

This commit is contained in:
concierge committed 2026-11-16 15:43:51 +01:00
1 parent 781aa20253
commit 66659d9a23
32 files changed
+3276 -132

No files matched your search

+56 -1
View File
@@ -254,6 +254,7 @@ func (s *Server) handleAdminUserSave(w http.ResponseWriter, r *http.Request, use
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
@@ -264,6 +265,34 @@ func (s *Server) handleAdminUserSave(w http.ResponseWriter, r *http.Request, use
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)
}
@@ -278,6 +307,7 @@ func (s *Server) handleAdminUserDelete(w http.ResponseWriter, r *http.Request, u
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")
@@ -307,8 +337,33 @@ func (s *Server) handleAdminUserResetPassword(w http.ResponseWriter, r *http.Req
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.", "success")
" · Beim nächsten Anmelden muss es geändert werden."+note, "success")
s.redirect(w, r, "/admin/users?edit="+id)
}
+18
View File
@@ -1,6 +1,7 @@
package web
import (
"log"
"net/http"
"net/url"
"strings"
@@ -34,12 +35,28 @@ func (s *Server) handleLoginPost(w http.ResponseWriter, r *http.Request) {
s.redirect(w, r, "/login")
return
}
if err := s.store.PruneUserWrappers(r.Context(), user.ID); err != nil {
log.Printf("login: enforce key policy for %s: %v", user.Username, err)
}
var keyring *store.Keyring
if user.Role == store.RoleEditor || user.Role == store.RoleReader {
keyring, err = s.activateKeyring(r.Context(), user, password)
if err != nil {
log.Printf("login: unlock keys for %s: %v", user.Username, err)
s.setFlash(w, "Die verschlüsselten Daten konnten nicht entsperrt werden. Bitte wenden Sie sich an einen Redakteur.", "error")
s.redirect(w, r, "/login")
return
}
}
session, token, err := s.store.CreateSession(r.Context(), user.ID, s.sessionTTL)
if err != nil {
s.setFlash(w, "Die Sitzung konnte nicht erstellt werden.", "error")
s.redirect(w, r, "/login")
return
}
if keyring != nil {
s.cacheKeyring(session.ID, keyring)
}
http.SetCookie(w, &http.Cookie{
Name: sessionCookie, Value: token, Path: "/", HttpOnly: true,
SameSite: http.SameSiteLaxMode, Secure: s.opts.SecureCookies,
@@ -57,6 +74,7 @@ func (s *Server) handleLoginPost(w http.ResponseWriter, r *http.Request) {
}
func (s *Server) handleLogout(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
s.dropSessionKeyring(session.ID)
if cookie, err := r.Cookie(sessionCookie); err == nil {
_ = s.store.DeleteSessionByToken(r.Context(), cookie.Value)
}
+538
View File
@@ -0,0 +1,538 @@
package web
import (
"context"
"encoding/base64"
"net/http"
"net/http/httptest"
"net/url"
"regexp"
"strings"
"testing"
"lektorenplan/store"
)
func TestUnlockRequiredAfterServerRestart(t *testing.T) {
ts, st := newTestServer(t)
client := newClient(t)
login(t, client, ts.URL, "editor", "editor123")
// A fresh server process has an empty keyring cache but the browser still
// holds its session cookie.
restarted, err := New(st, Options{Version: "test", DemoMode: true})
if err != nil {
t.Fatalf("new server: %v", err)
}
ts2 := httptest.NewServer(restarted.Handler())
defer ts2.Close()
req, err := http.NewRequest(http.MethodGet, ts2.URL+"/plan", nil)
if err != nil {
t.Fatalf("request: %v", err)
}
resp, err := client.Do(req)
if err != nil {
t.Fatalf("get plan: %v", err)
}
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther || !strings.HasPrefix(resp.Header.Get("Location"), "/unlock") {
t.Fatalf("locked request = %d %q, want redirect to /unlock", resp.StatusCode, resp.Header.Get("Location"))
}
body := get(t, client, ts2.URL+"/unlock", http.StatusOK)
csrf := extractCSRF(t, body)
unlock, err := client.PostForm(ts2.URL+"/unlock", url.Values{
"csrf": {csrf},
"password": {"editor1231"},
})
if err != nil {
t.Fatalf("unlock: %v", err)
}
unlock.Body.Close()
if unlock.StatusCode != http.StatusSeeOther || unlock.Header.Get("Location") != "/plan" {
t.Fatalf("unlock = %d %q", unlock.StatusCode, unlock.Header.Get("Location"))
}
get(t, client, ts2.URL+"/plan", http.StatusOK)
}
func TestLinkedReaderUnlocksOwnContactAfterRestart(t *testing.T) {
ts, st := newTestServer(t)
ctx := context.Background()
tenantID, personID, personEmail := demoContact(t, st)
reader, err := st.UserByUsername(ctx, "reader")
if err != nil {
t.Fatalf("reader: %v", err)
}
if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
t.Fatalf("link reader: %v", err)
}
editorClient := newClient(t)
login(t, editorClient, ts.URL, "editor", "editor123")
readerClient := newClient(t)
login(t, readerClient, ts.URL, "reader", "reader123")
restarted, err := New(st, Options{Version: "test", DemoMode: true})
if err != nil {
t.Fatalf("new server: %v", err)
}
ts2 := httptest.NewServer(restarted.Handler())
defer ts2.Close()
req, err := http.NewRequest(http.MethodGet, ts2.URL+"/team", nil)
if err != nil {
t.Fatalf("request: %v", err)
}
resp, err := readerClient.Do(req)
if err != nil {
t.Fatalf("get team: %v", err)
}
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther || !strings.HasPrefix(resp.Header.Get("Location"), "/unlock") {
t.Fatalf("locked reader request = %d %q, want /unlock", resp.StatusCode, resp.Header.Get("Location"))
}
body := get(t, readerClient, ts2.URL+"/unlock", http.StatusOK)
csrf := extractCSRF(t, body)
unlock, err := readerClient.PostForm(ts2.URL+"/unlock", url.Values{
"csrf": {csrf},
"password": {"reader1231"},
})
if err != nil {
t.Fatalf("unlock: %v", err)
}
unlock.Body.Close()
if unlock.StatusCode != http.StatusSeeOther {
t.Fatalf("reader unlock = %d, want 303", unlock.StatusCode)
}
page := get(t, readerClient, ts2.URL+"/team/person/"+personID, http.StatusOK)
if !strings.Contains(page, personEmail) {
t.Fatalf("reader cannot decrypt own e-mail after unlock %q", personEmail)
}
}
func TestAdminCannotDecryptSensitiveData(t *testing.T) {
ts, st := newTestServer(t)
ctx := context.Background()
editorClient := newClient(t)
login(t, editorClient, ts.URL, "editor", "editor123")
editorPage := get(t, editorClient, ts.URL+"/team", http.StatusOK)
if !strings.Contains(editorPage, "anna.berg@example.org") {
t.Fatal("editor cannot decrypt the seeded e-mail address")
}
adminClient := newClient(t)
login(t, adminClient, ts.URL, "admin", "admin123")
teamPage := get(t, adminClient, ts.URL+"/team", http.StatusOK)
if strings.Contains(teamPage, "@example.org") {
t.Fatal("administrator page exposes e-mail addresses")
}
if !strings.Contains(teamPage, "Kontaktdaten gesperrt") {
t.Fatal("administrator page does not mark the contacts as locked")
}
settingsPage := get(t, adminClient, ts.URL+"/settings", http.StatusOK)
if strings.Contains(settingsPage, "E-Mail-Versand (SMTP)") {
t.Fatal("administrator settings expose SMTP credentials")
}
dispatchPage := get(t, adminClient, ts.URL+"/dispatch?"+dispatchRange, http.StatusOK)
if strings.Contains(dispatchPage, "@example.org") || strings.Contains(dispatchPage, "data-mailto-link") {
t.Fatal("administrator dispatch page exposes recipient addresses")
}
if !strings.Contains(dispatchPage, "SMTP wird von Redakteuren verwaltet") ||
!strings.Contains(dispatchPage, "Direkter E-Mail-Versand ist für dieses Konto nicht verfügbar") {
t.Fatal("administrator dispatch page does not explain the restricted SMTP access")
}
if strings.Contains(dispatchPage, `formaction="/dispatch/send"`) {
t.Fatal("administrator dispatch page offers direct sending")
}
admin, err := st.UserByUsername(ctx, "admin")
if err != nil {
t.Fatalf("admin: %v", err)
}
if st.HasUserKeys(ctx, admin.ID) {
t.Fatal("administrator still holds key material")
}
scopes, err := st.ScopesForUser(ctx, admin.ID)
if err != nil {
t.Fatalf("admin scopes: %v", err)
}
if len(scopes) != 0 {
t.Fatalf("administrator holds %d encrypted scopes", len(scopes))
}
}
func TestLinkedReaderManagesOwnContact(t *testing.T) {
ts, st := newTestServer(t)
ctx := context.Background()
tenantID, personID, personEmail := demoContact(t, st)
var otherEmail string
if err := st.DB().QueryRowContext(ctx,
"SELECT email FROM people WHERE tenant_id=? AND id<>? AND email<>'' LIMIT 1",
tenantID, personID).Scan(&otherEmail); err != nil {
t.Fatalf("other contact: %v", err)
}
reader, err := st.UserByUsername(ctx, "reader")
if err != nil {
t.Fatalf("reader: %v", err)
}
if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
t.Fatalf("link reader: %v", err)
}
editorClient := newClient(t)
login(t, editorClient, ts.URL, "editor", "editor123")
readerClient := newClient(t)
login(t, readerClient, ts.URL, "reader", "reader123")
teamPage := get(t, readerClient, ts.URL+"/team", http.StatusOK)
if !strings.Contains(teamPage, personEmail) {
t.Fatalf("linked reader does not see own e-mail %q", personEmail)
}
if otherEmail != "" && strings.Contains(teamPage, otherEmail) {
t.Fatalf("linked reader sees another person's e-mail %q", otherEmail)
}
personPage := get(t, readerClient, ts.URL+"/team/person/"+personID, http.StatusOK)
csrf := extractCSRF(t, personPage)
updatedEmail := "reader.self@example.org"
resp := postForm(t, readerClient, ts.URL+"/team/person/"+personID+"/save", url.Values{
"csrf": {csrf},
"first_name": {"Anna"},
"last_name": {"Berg"},
"email": {updatedEmail},
})
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther {
t.Fatalf("reader save = %d, want 303", resp.StatusCode)
}
var plain string
if err := st.DB().QueryRowContext(ctx,
"SELECT email FROM people WHERE tenant_id=? AND id=?", tenantID, personID).Scan(&plain); err != nil {
t.Fatalf("read person row: %v", err)
}
if plain != "" {
t.Fatalf("reader e-mail stored in plaintext: %q", plain)
}
if !st.SecretExists(ctx, tenantID, store.ScopePerson, personID, "email") {
t.Fatal("reader e-mail was not stored as a secret")
}
editorPage := get(t, editorClient, ts.URL+"/team/person/"+personID, http.StatusOK)
if !strings.Contains(editorPage, updatedEmail) {
t.Fatalf("editor does not see the reader-updated e-mail %q", updatedEmail)
}
if strings.Contains(editorPage, personEmail) {
t.Fatalf("editor still sees the old e-mail %q", personEmail)
}
}
func TestNewEditorReceivesReaderAddressAfterReaderLogin(t *testing.T) {
ts, st := newTestServer(t)
ctx := context.Background()
tenantID, personID, _ := demoContact(t, st)
reader, err := st.UserByUsername(ctx, "reader")
if err != nil {
t.Fatalf("reader: %v", err)
}
if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
t.Fatalf("link reader: %v", err)
}
editorClient := newClient(t)
login(t, editorClient, ts.URL, "editor", "editor123")
readerClient := newClient(t)
login(t, readerClient, ts.URL, "reader", "reader123")
personPage := get(t, readerClient, ts.URL+"/team/person/"+personID, http.StatusOK)
csrf := extractCSRF(t, personPage)
updatedEmail := "backfill.self@example.org"
resp := postForm(t, readerClient, ts.URL+"/team/person/"+personID+"/save", url.Values{
"csrf": {csrf},
"first_name": {"Anna"},
"last_name": {"Berg"},
"email": {updatedEmail},
})
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther {
t.Fatalf("reader save = %d, want 303", resp.StatusCode)
}
// A new editor is created after the address exists. The reader's next
// login must wrap the address for that editor.
if _, err := st.CreateUser(ctx, "neueditor", "Neue Redaktion", "neueditor123",
store.RoleEditor, true, []string{tenantID}); err != nil {
t.Fatalf("create editor: %v", err)
}
readerAgain := newClient(t)
login(t, readerAgain, ts.URL, "reader", "reader1231")
newEditorClient := newClient(t)
login(t, newEditorClient, ts.URL, "neueditor", "neueditor123")
page := get(t, newEditorClient, ts.URL+"/team/person/"+personID, http.StatusOK)
if !strings.Contains(page, updatedEmail) {
t.Fatalf("new editor cannot decrypt the reader e-mail %q", updatedEmail)
}
}
func TestReaderWithoutScopeCanSaveProfile(t *testing.T) {
ts, st := newTestServer(t)
ctx := context.Background()
tenantID, personID, _ := demoContact(t, st)
reader, err := st.UserByUsername(ctx, "reader")
if err != nil {
t.Fatalf("reader: %v", err)
}
if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
t.Fatalf("link reader: %v", err)
}
// The editor encrypts the tenant and grants the reader access.
editorClient := newClient(t)
login(t, editorClient, ts.URL, "editor", "editor123")
// Lose the reader's keypair and all wrappers, e.g. after restoring an
// older database. The encrypted address remains readable for editors.
if err := st.DeleteUserKeys(ctx, reader.ID); err != nil {
t.Fatalf("delete reader keys: %v", err)
}
// A fresh process has no unlocked editor keyring, so the reader cannot
// receive the person scope on login either.
restarted, err := New(st, Options{Version: "test", DemoMode: true})
if err != nil {
t.Fatalf("new server: %v", err)
}
ts2 := httptest.NewServer(restarted.Handler())
defer ts2.Close()
readerClient := newClient(t)
login(t, readerClient, ts2.URL, "reader", "reader123")
if scopes, _ := st.ScopesForUser(ctx, reader.ID); len(scopes) != 0 {
t.Fatalf("reader unexpectedly holds %d scopes", len(scopes))
}
page := get(t, readerClient, ts2.URL+"/team/person/"+personID, http.StatusOK)
if !strings.Contains(page, "noch nicht freigegeben") {
t.Fatal("reader page does not mark the e-mail as not yet released")
}
csrf := extractCSRF(t, page)
resp := postForm(t, readerClient, ts2.URL+"/team/person/"+personID+"/save", url.Values{
"csrf": {csrf},
"first_name": {"Anna"},
"last_name": {"Berg"},
"email": {"should.not.be.saved@example.org"},
})
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther {
t.Fatalf("reader profile save = %d, want 303", resp.StatusCode)
}
person, err := st.Person(ctx, tenantID, personID)
if err != nil {
t.Fatalf("person: %v", err)
}
if person.LastName != "Berg" {
t.Fatalf("reader profile was not saved: last name %q", person.LastName)
}
var stored string
if err := st.DB().QueryRowContext(ctx,
"SELECT email FROM people WHERE tenant_id=? AND id=?", tenantID, personID).Scan(&stored); err != nil {
t.Fatalf("read person row: %v", err)
}
if stored != "" {
t.Fatalf("reader without scope stored plaintext e-mail %q", stored)
}
}
func TestEditorSetsAddressAndReaderReadsIt(t *testing.T) {
ts, st := newTestServer(t)
ctx := context.Background()
tenantID, personID, _ := demoContact(t, st)
reader, err := st.UserByUsername(ctx, "reader")
if err != nil {
t.Fatalf("reader: %v", err)
}
if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
t.Fatalf("link reader: %v", err)
}
editorClient := newClient(t)
login(t, editorClient, ts.URL, "editor", "editor123")
readerClient := newClient(t)
login(t, readerClient, ts.URL, "reader", "reader123")
editorPage := get(t, editorClient, ts.URL+"/team/person/"+personID, http.StatusOK)
csrf := extractCSRF(t, editorPage)
updatedEmail := "editor.set@example.org"
resp := postForm(t, editorClient, ts.URL+"/team/person/"+personID+"/save", url.Values{
"csrf": {csrf},
"first_name": {"Anna"},
"last_name": {"Berg"},
"role_lector": {"1"},
"email": {updatedEmail},
})
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther {
t.Fatalf("editor save = %d, want 303", resp.StatusCode)
}
var plain string
if err := st.DB().QueryRowContext(ctx,
"SELECT email FROM people WHERE tenant_id=? AND id=?", tenantID, personID).Scan(&plain); err != nil {
t.Fatalf("read person row: %v", err)
}
if plain != "" {
t.Fatalf("editor e-mail stored in plaintext: %q", plain)
}
readerPage := get(t, readerClient, ts.URL+"/team/person/"+personID, http.StatusOK)
if !strings.Contains(readerPage, updatedEmail) {
t.Fatalf("reader cannot read the editor-set e-mail %q", updatedEmail)
}
}
func TestNewEditorReceivesAllContactsFromUnlockedEditor(t *testing.T) {
ts, st := newTestServer(t)
ctx := context.Background()
tenants, err := st.Tenants(ctx)
if err != nil {
t.Fatalf("tenants: %v", err)
}
if len(tenants) == 0 {
t.Fatal("demo tenant missing")
}
tenantID := tenants[0].ID
var otherEmail string
if err := st.DB().QueryRowContext(ctx,
"SELECT email FROM people WHERE tenant_id=? AND email<>'' ORDER BY id LIMIT 1",
tenantID).Scan(&otherEmail); err != nil {
t.Fatalf("contact: %v", err)
}
editorClient := newClient(t)
login(t, editorClient, ts.URL, "editor", "editor123")
newEditor, err := st.CreateUser(ctx, "neueredakteur", "Neue Redaktion", "neueredakteur123",
store.RoleEditor, true, []string{tenantID})
if err != nil {
t.Fatalf("create editor: %v", err)
}
if scopes, _ := st.ScopesForUser(ctx, newEditor.ID); len(scopes) != 0 {
t.Fatalf("new editor already holds %d scopes", len(scopes))
}
newClientSession := newClient(t)
login(t, newClientSession, ts.URL, "neueredakteur", "neueredakteur123")
teamPage := get(t, newClientSession, ts.URL+"/team", http.StatusOK)
if !strings.Contains(teamPage, otherEmail) {
t.Fatalf("new editor cannot decrypt team contact %q", otherEmail)
}
if scopes, _ := st.ScopesForUser(ctx, newEditor.ID); len(scopes) == 0 {
t.Fatal("new editor did not receive any scopes")
}
}
func TestAdminResetReaderKeepsAddressForEditor(t *testing.T) {
ts, st := newTestServer(t)
ctx := context.Background()
tenantID, personID, _ := demoContact(t, st)
reader, err := st.UserByUsername(ctx, "reader")
if err != nil {
t.Fatalf("reader: %v", err)
}
if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
t.Fatalf("link reader: %v", err)
}
editorClient := newClient(t)
login(t, editorClient, ts.URL, "editor", "editor123")
readerClient := newClient(t)
login(t, readerClient, ts.URL, "reader", "reader123")
personPage := get(t, readerClient, ts.URL+"/team/person/"+personID, http.StatusOK)
csrf := extractCSRF(t, personPage)
updatedEmail := "reset.self@example.org"
resp := postForm(t, readerClient, ts.URL+"/team/person/"+personID+"/save", url.Values{
"csrf": {csrf},
"first_name": {"Anna"},
"last_name": {"Berg"},
"email": {updatedEmail},
})
resp.Body.Close()
if resp.StatusCode != http.StatusSeeOther {
t.Fatalf("reader save = %d, want 303", resp.StatusCode)
}
adminClient := newClient(t)
login(t, adminClient, ts.URL, "admin", "admin123")
adminPage := get(t, adminClient, ts.URL+"/admin/users", http.StatusOK)
adminCSRF := extractCSRF(t, adminPage)
reset, err := adminClient.PostForm(ts.URL+"/admin/users/reset-password", url.Values{
"csrf": {adminCSRF},
"id": {reader.ID},
})
if err != nil {
t.Fatalf("reset reader: %v", err)
}
reset.Body.Close()
temporary := flashPassword(t, reset)
if temporary == "" {
t.Fatal("no temporary password in reset flash")
}
// The reader signs in with the temporary password, changes it and must
// still be able to decrypt the own address.
readerAgain := newClient(t)
login(t, readerAgain, ts.URL, "reader", temporary)
page := get(t, readerAgain, ts.URL+"/team/person/"+personID, http.StatusOK)
if !strings.Contains(page, updatedEmail) {
t.Fatalf("reader cannot decrypt own e-mail after reset %q", updatedEmail)
}
editorPage := get(t, editorClient, ts.URL+"/team/person/"+personID, http.StatusOK)
if !strings.Contains(editorPage, updatedEmail) {
t.Fatalf("editor lost the reader e-mail after reset %q", updatedEmail)
}
}
// demoContact returns a tenant, a person and that person's plaintext e-mail
// from the seeded demo data.
func demoContact(t *testing.T, st *store.Store) (tenantID, personID, email string) {
t.Helper()
ctx := context.Background()
tenants, err := st.Tenants(ctx)
if err != nil {
t.Fatalf("tenants: %v", err)
}
for _, tenant := range tenants {
if tenant.Slug == "bad-godesberg" {
tenantID = tenant.ID
}
}
if tenantID == "" {
t.Fatal("demo tenant not found")
}
if err := st.DB().QueryRowContext(ctx,
"SELECT id, email FROM people WHERE tenant_id=? AND email<>'' LIMIT 1",
tenantID).Scan(&personID, &email); err != nil {
t.Fatalf("contact person: %v", err)
}
return tenantID, personID, email
}
var temporaryPasswordPattern = regexp.MustCompile(`lp-[0-9a-f]+`)
func flashPassword(t *testing.T, resp *http.Response) string {
t.Helper()
for _, cookie := range resp.Cookies() {
if cookie.Name != flashCookie || cookie.Value == "" {
continue
}
data, err := base64.RawURLEncoding.DecodeString(cookie.Value)
if err != nil {
t.Fatalf("decode flash: %v", err)
}
return temporaryPasswordPattern.FindString(string(data))
}
return ""
}
+66 -20
View File
@@ -5,6 +5,7 @@ import (
"context"
"fmt"
"net/http"
"net/url"
"sort"
"strconv"
"strings"
@@ -52,6 +53,9 @@ type dispatchPersonView struct {
Effective string
Assignments []dispatchAssignmentView
AssignmentCount int
AssignmentText string
MailText string
Mailto string
}
type dispatchPageData struct {
@@ -67,14 +71,22 @@ type dispatchPageData struct {
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
// CanManageSecrets is false for administrators and readers. They can use
// the dispatch page, but recipient addresses and SMTP credentials stay
// locked because only editors hold the matching keys.
CanManageSecrets bool
EmailCount int
PrintCount int
NoneCount int
LastEntry *store.DispatchLogEntry
LastBatch []store.DispatchLogEntry
History []store.DispatchLogEntry
OpenSlots int
ServiceCount int
MailSubject string
StartLabel string
EndLabel string
DefaultIntro string
}
type dispatchSelection struct {
@@ -269,6 +281,14 @@ func (s *Server) handleDispatch(w http.ResponseWriter, r *http.Request, user *st
}
config := s.loadSMTPConfig(r.Context(), tenant.ID)
intro, greeting := s.dispatchTexts(r.Context(), tenant.ID)
subject := "Gottesdienstplan " + rng.ShortTitle() + " · " + tenant.Name
for index := range people {
people[index].AssignmentText = emailAssignmentTable(people[index].Assignments)
people[index].MailText = dispatchEmailBody(intro, greeting, rng, people[index].Assignments)
if email := strings.TrimSpace(people[index].Person.Email); email != "" {
people[index].Mailto = dispatchMailto(email, subject, people[index].MailText)
}
}
prev := domain.MonthRange(domain.AddingMonths(-1, rng.Start))
next := domain.MonthRange(domain.AddingMonths(1, rng.Start))
page := dispatchPageData{
@@ -276,8 +296,14 @@ func (s *Server) handleDispatch(w http.ResponseWriter, r *http.Request, user *st
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,
SMTPConfigured: config.configured(),
SMTPFrom: config.FromAddress,
CanManageSecrets: s.store.CanManageSecrets(r.Context(), user, tenant.ID),
History: history,
MailSubject: subject,
StartLabel: dispatchDateLabel(rng.Start),
EndLabel: dispatchDateLabel(rng.End),
DefaultIntro: defaultDispatchIntro,
}
for _, person := range people {
switch person.Effective {
@@ -435,6 +461,18 @@ func dispatchEmailBody(intro, greeting string, rng domain.DayRange, assignments
return strings.Join(parts, "\n\n")
}
// dispatchMailto builds a draft link for the local mail client. It is used
// when no SMTP account has been configured.
func dispatchMailto(email, subject, body string) string {
body = strings.ReplaceAll(body, "\n", "\r\n")
return "mailto:" + url.PathEscape(strings.TrimSpace(email)) +
"?subject=" + mailtoEscape(subject) + "&body=" + mailtoEscape(body)
}
func mailtoEscape(value string) string {
return strings.ReplaceAll(url.QueryEscape(value), "+", "%20")
}
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")
@@ -454,7 +492,11 @@ func (s *Server) handleDispatchSend(w http.ResponseWriter, r *http.Request, user
}
config := s.loadSMTPConfig(r.Context(), tenant.ID)
if !config.configured() {
s.setFlash(w, "Bitte zuerst die SMTP-Parameter in den Einstellungen hinterlegen.", "error")
message := "Bitte zuerst die SMTP-Parameter in den Einstellungen hinterlegen."
if !s.store.CanManageSecrets(r.Context(), user, tenant.ID) {
message = "SMTP-Zugangsdaten können nur Redakteure hinterlegen. Nutzen Sie das E-Mail-Programm oder das Druck-PDF."
}
s.setFlash(w, message, "error")
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
return
}
@@ -505,7 +547,7 @@ func (s *Server) handleDispatchSend(w http.ResponseWriter, r *http.Request, user
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,
CreatedAt: now, CreatedBy: user.DisplayName,
}
if err != nil {
failed++
@@ -634,7 +676,7 @@ func (s *Server) handleDispatchPrint(w http.ResponseWriter, r *http.Request, use
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,
Variant: recipient.Variant, Cover: recipient.Cover,
Status: "pdf", Detail: "Druck-PDF erzeugt", CreatedAt: now, CreatedBy: user.DisplayName,
})
}
@@ -665,14 +707,18 @@ func parseTimeLabel(label string) int {
}
func (s *Server) loadSMTPConfig(ctx context.Context, tenantID string) smtpConfig {
port, _ := strconv.Atoi(strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.port")))
value := func(key string) string {
raw, _ := s.store.SecretValue(ctx, tenantID, store.ScopeTenant, tenantID, key)
return raw
}
port, _ := strconv.Atoi(strings.TrimSpace(value("smtp.port")))
return smtpConfig{
Host: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.host")),
Host: strings.TrimSpace(value("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")),
Username: strings.TrimSpace(value("smtp.username")),
Password: value("smtp.password"),
FromAddress: strings.TrimSpace(value("smtp.fromAddress")),
FromName: strings.TrimSpace(value("smtp.fromName")),
Encryption: strings.TrimSpace(value("smtp.encryption")),
}
}
+78 -6
View File
@@ -7,6 +7,8 @@ import (
"net/url"
"strings"
"testing"
"lektorenplan/store"
)
// dispatchRange is a range with seeded demo services and liturgical days.
@@ -218,18 +220,39 @@ func TestEditorManagesTenantSMTP(t *testing.T) {
tenants, _ := st.Tenants(ctx)
found := false
for _, tenant := range tenants {
if st.TenantSetting(ctx, tenant.ID, "smtp.host") == "smtp.example.org" {
if got := st.TenantSetting(ctx, tenant.ID, "smtp.host"); got == "smtp.example.org" {
t.Fatalf("SMTP host was stored as plaintext tenant setting")
}
if st.SecretExists(ctx, tenant.ID, store.ScopeTenant, tenant.ID, "smtp.host") {
found = true
if got := st.TenantSetting(ctx, tenant.ID, "smtp.port"); got != "587" {
t.Fatalf("smtp port = %q", got)
if !st.SecretIsInitialized(ctx, tenant.ID) {
t.Fatal("tenant secrets are not marked as initialized")
}
if got := st.TenantSetting(ctx, tenant.ID, "smtp.password"); got != "secret" {
t.Fatalf("smtp password = %q", got)
editor, err := st.UserByUsername(ctx, "editor")
if err != nil {
t.Fatalf("editor account: %v", err)
}
keyring, err := st.EnsureUserKeys(ctx, editor.ID, "editor1231")
if err != nil {
t.Fatalf("unlock editor keys: %v", err)
}
if err := st.UnlockAccessibleKeys(ctx, keyring); err != nil {
t.Fatalf("unwrap data keys: %v", err)
}
secretCtx := store.WithKeyring(ctx, keyring)
if got, ok := st.SecretValue(secretCtx, tenant.ID, store.ScopeTenant, tenant.ID, "smtp.host"); !ok || got != "smtp.example.org" {
t.Fatalf("smtp host = %q, ok=%v", got, ok)
}
if got, ok := st.SecretValue(secretCtx, tenant.ID, store.ScopeTenant, tenant.ID, "smtp.port"); !ok || got != "587" {
t.Fatalf("smtp port = %q, ok=%v", got, ok)
}
if got, ok := st.SecretValue(secretCtx, tenant.ID, store.ScopeTenant, tenant.ID, "smtp.password"); !ok || got != "secret" {
t.Fatalf("smtp password = %q, ok=%v", got, ok)
}
}
}
if !found {
t.Fatal("SMTP host was not stored as a tenant setting")
t.Fatal("SMTP host was not stored as an encrypted secret")
}
// The dispatch page now reports a ready SMTP configuration.
@@ -237,6 +260,12 @@ func TestEditorManagesTenantSMTP(t *testing.T) {
if !strings.Contains(page, "SMTP bereit") {
t.Fatal("dispatch page does not reflect the SMTP configuration")
}
if !strings.Contains(page, `formaction="/dispatch/send"`) {
t.Fatal("dispatch page does not offer direct sending with SMTP configured")
}
if strings.Contains(page, "data-mailto-link") {
t.Fatal("dispatch page must not offer mailto drafts when SMTP is configured")
}
// Readers may not change these settings.
reader := newClient(t)
@@ -247,6 +276,49 @@ func TestEditorManagesTenantSMTP(t *testing.T) {
}
}
func TestDispatchMailtoEncodesDraft(t *testing.T) {
href := dispatchMailto("anna.berg@example.org", "Plan März", "Hallo & Grüße\nZeile 2")
if !strings.HasPrefix(href, "mailto:") {
t.Fatalf("mailto link = %q", href)
}
if !strings.Contains(href, "subject=Plan%20M%C3%A4rz") {
t.Fatalf("subject is not encoded: %q", href)
}
body := "body=Hallo%20%26%20Gr%C3%BC%C3%9Fe%0D%0AZeile%202"
if !strings.Contains(href, body) {
t.Fatalf("body is not encoded: %q", href)
}
if strings.Contains(href, "+") {
t.Fatalf("mailto link must not use plus signs for spaces: %q", href)
}
}
func TestDispatchOffersMailtoAndCopyWithoutSMTP(t *testing.T) {
ts, _ := 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, "Kein SMTP-Konto hinterlegt") {
t.Fatal("dispatch page is missing the mailto fallback notice")
}
if strings.Contains(body, `formaction="/dispatch/send"`) {
t.Fatal("dispatch page must not offer direct sending without SMTP")
}
if !strings.Contains(body, "data-copy-person") {
t.Fatal("dispatch page is missing per-person copy controls")
}
if !strings.Contains(body, "data-copy-shared") {
t.Fatal("dispatch page is missing the shared-text copy control")
}
if !strings.Contains(body, "data-mailto-link") || !strings.Contains(body, `data-mailto-email="anna.berg@example.org"`) {
t.Fatal("dispatch page is missing the mailto fallback for recipients")
}
if !strings.Contains(body, "mailto:anna.berg@example.org?subject=") {
t.Fatal("dispatch page is missing a prepared mailto link")
}
}
func TestGuestAccessIsReadOnlyAndAnonymous(t *testing.T) {
ts, st := newTestServer(t)
client := newClient(t)
+1
View File
@@ -112,6 +112,7 @@ func (s *Server) handleImport(w http.ResponseWriter, r *http.Request, user *stor
return
}
_ = s.store.SetTenantSetting(r.Context(), tenant.ID, "lastExchangeImport", time.Now().UTC().Format(time.RFC3339))
s.refreshCachedKeyrings(r.Context())
s.setFlash(w, importMessage(summary), "success")
s.redirect(w, r, "/exchange")
return
+268
View File
@@ -0,0 +1,268 @@
package web
import (
"context"
"log"
"net/http"
"net/url"
"lektorenplan/store"
)
// Keyrings are only kept in memory. A server restart therefore locks all
// encrypted data until every account unlocks its keys again.
func (s *Server) keyringForSession(sessionID string) *store.Keyring {
s.keyMu.Lock()
defer s.keyMu.Unlock()
return s.keyrings[sessionID]
}
func (s *Server) cacheKeyring(sessionID string, keyring *store.Keyring) {
if keyring == nil {
return
}
s.keyMu.Lock()
defer s.keyMu.Unlock()
s.keyrings[sessionID] = keyring
}
func (s *Server) dropSessionKeyring(sessionID string) {
s.keyMu.Lock()
defer s.keyMu.Unlock()
delete(s.keyrings, sessionID)
}
func (s *Server) dropUserKeyrings(userID string) {
s.keyMu.Lock()
defer s.keyMu.Unlock()
for sessionID, keyring := range s.keyrings {
if keyring.UserID == userID {
delete(s.keyrings, sessionID)
}
}
}
// refreshCachedKeyrings unwraps data keys that were granted while an account
// was already signed in. It keeps other open sessions usable without forcing
// them to sign out and in again.
func (s *Server) refreshCachedKeyrings(ctx context.Context) {
s.keyMu.Lock()
keyrings := make([]*store.Keyring, 0, len(s.keyrings))
for _, keyring := range s.keyrings {
if keyring != nil {
keyrings = append(keyrings, keyring)
}
}
s.keyMu.Unlock()
for _, keyring := range keyrings {
if err := s.store.UnlockAccessibleKeys(ctx, keyring); err != nil {
log.Printf("keyring: refresh session of %s: %v", keyring.UserID, err)
}
}
}
// activeEditorKeyring returns any unlocked editor keyring from the in-memory
// session cache. It lets an administrator trigger a re-grant after a password
// reset without ever decrypting the data themselves.
func (s *Server) activeEditorKeyring(ctx context.Context) *store.Keyring {
s.keyMu.Lock()
candidates := make([]*store.Keyring, 0, len(s.keyrings))
for _, keyring := range s.keyrings {
if keyring != nil {
candidates = append(candidates, keyring)
}
}
s.keyMu.Unlock()
for _, keyring := range candidates {
user, err := s.store.User(ctx, keyring.UserID)
if err != nil || !user.Active || user.Role != store.RoleEditor {
continue
}
return keyring
}
return nil
}
// canHoldKeys reports whether an account may have key material. Editors and
// readers decrypt data with a password-derived key; administrators never do.
func canHoldKeys(user *store.User) bool {
return user != nil && (user.Role == store.RoleEditor || user.Role == store.RoleReader)
}
// needsUnlock reports whether the session's account has key material but the
// keyring has not been unlocked since the server started. Editors hold keys
// for all contacts and SMTP, readers for their own e-mail address.
func (s *Server) needsUnlock(ctx context.Context, session *store.Session, user *store.User) bool {
if user.Role != store.RoleEditor && user.Role != store.RoleReader {
return false
}
if s.keyringForSession(session.ID) != nil {
return false
}
if !s.store.HasUserKeys(ctx, user.ID) {
return false
}
if user.Role == store.RoleReader {
// A reader without a granted scope has nothing to decrypt yet.
scopes, err := s.store.ScopesForUser(ctx, user.ID)
if err != nil || len(scopes) == 0 {
return false
}
}
return true
}
// activateKeyring derives the user's key encryption key from the login
// password and unwraps all granted data keys. Editors then refresh the tenant
// scopes; a reader refreshes editor access to their own e-mail address, which
// also grants addresses to editors created since the last reader login.
func (s *Server) activateKeyring(ctx context.Context, user *store.User, password string) (*store.Keyring, error) {
if user.Role != store.RoleEditor && user.Role != store.RoleReader {
return nil, nil
}
keyring, err := s.store.EnsureUserKeys(ctx, user.ID, password)
if err != nil {
return nil, err
}
if err := s.store.UnlockAccessibleKeys(ctx, keyring); err != nil {
return nil, err
}
if user.Role == store.RoleEditor {
s.syncTenantKeys(ctx, user, keyring)
} else {
s.syncReaderKeys(ctx, user, keyring)
}
return keyring, nil
}
func (s *Server) syncReaderKeys(ctx context.Context, user *store.User, keyring *store.Keyring) {
if user.Role != store.RoleReader || keyring == nil {
return
}
if user.LinkedTenantID == "" || user.LinkedPersonID == "" {
return
}
if !s.store.SecretIsInitialized(ctx, user.LinkedTenantID) {
return
}
// A reader can only refresh editor access while holding their own data
// key. Without it, an unlocked editor session grants the scope first and
// the reader can then unwrap it.
if err := s.store.EnsurePersonScope(ctx, keyring, user.LinkedTenantID, user.LinkedPersonID); err != nil {
log.Printf("keyring: refresh reader scope %s: %v", user.LinkedPersonID, err)
actor := s.activeEditorKeyring(ctx)
if actor == nil {
return
}
if err := s.store.EnsurePersonScope(ctx, actor, user.LinkedTenantID, user.LinkedPersonID); err != nil {
log.Printf("keyring: editor grant for reader %s: %v", user.LinkedPersonID, err)
return
}
if err := s.store.UnlockAccessibleKeys(ctx, keyring); err != nil {
log.Printf("keyring: unlock reader after grant %s: %v", user.LinkedPersonID, err)
}
}
s.refreshCachedKeyrings(ctx)
}
func (s *Server) syncTenantKeys(ctx context.Context, user *store.User, keyring *store.Keyring) {
if user.Role != store.RoleEditor || keyring == nil {
return
}
tenants, err := s.store.TenantsForUser(ctx, user)
if err != nil {
log.Printf("keyring: load tenants: %v", err)
return
}
for _, tenant := range tenants {
if !s.store.CanManageSecrets(ctx, user, tenant.ID) {
continue
}
// Reconcile first so a newly created editor receives access to every
// person scope before the migration needs to read those scopes.
if err := s.store.ReconcileTenant(ctx, keyring, tenant.ID); err != nil {
// A newly created editor cannot unwrap the existing data keys.
// Another unlocked editor grants them and the new session reloads
// the wrappers.
actor := s.activeEditorKeyring(ctx)
if actor == nil || actor.UserID == keyring.UserID {
log.Printf("keyring: reconcile tenant %s: %v", tenant.ID, err)
continue
}
if err := s.store.ReconcileTenant(ctx, actor, tenant.ID); err != nil {
log.Printf("keyring: grant tenant %s from editor %s: %v", tenant.ID, actor.UserID, err)
continue
}
if err := s.store.UnlockAccessibleKeys(ctx, keyring); err != nil {
log.Printf("keyring: unlock new editor %s: %v", user.ID, err)
continue
}
}
if err := s.store.BootstrapTenant(ctx, keyring, tenant.ID); err != nil {
log.Printf("keyring: bootstrap tenant %s: %v", tenant.ID, err)
}
}
// Other editors or readers who are already signed in may have received
// new wrappers from this reconcile.
s.refreshCachedKeyrings(ctx)
}
// grantAccountScopes grants existing data keys to an account after its role or
// memberships changed. ReconcileTenant includes the linked reader of every
// person, so a newly linked reader receives their own scope while other
// accounts stay excluded.
func (s *Server) grantAccountScopes(ctx context.Context, actor *store.Keyring, tenantIDs []string) {
if actor == nil {
return
}
seen := map[string]bool{}
for _, tenantID := range tenantIDs {
if tenantID == "" || seen[tenantID] || !s.store.SecretIsInitialized(ctx, tenantID) {
continue
}
seen[tenantID] = true
if err := s.store.ReconcileTenant(ctx, actor, tenantID); err != nil {
log.Printf("keyring: grant scopes for tenant %s: %v", tenantID, err)
}
}
s.refreshCachedKeyrings(ctx)
}
type unlockPageData struct {
Next string
}
func (s *Server) handleUnlockGet(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
next := safeNext(r.URL.Query().Get("next"))
if !canHoldKeys(user) || s.keyringForSession(session.ID) != nil {
s.redirect(w, r, next)
return
}
data := s.baseView(w, r, "Daten entsperren", "")
data.Data = unlockPageData{Next: next}
s.renderPage(w, r, "unlock", data)
}
func (s *Server) handleUnlockPost(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
next := safeNext(r.FormValue("next"))
if !canHoldKeys(user) {
s.redirect(w, r, next)
return
}
password := r.FormValue("password")
if _, err := s.store.Authenticate(r.Context(), user.Username, password); err != nil {
s.setFlash(w, "Das Passwort ist nicht korrekt.", "error")
s.redirect(w, r, "/unlock?next="+url.QueryEscape(next))
return
}
keyring, err := s.activateKeyring(r.Context(), user, password)
if err != nil {
s.setFlash(w, "Die gespeicherten Daten konnten nicht entsperrt werden: "+err.Error(), "error")
s.redirect(w, r, "/unlock?next="+url.QueryEscape(next))
return
}
s.cacheKeyring(session.ID, keyring)
s.setFlash(w, "Die verschlüsselten Daten sind entsperrt.", "success")
s.redirect(w, r, next)
}
+36 -32
View File
@@ -18,57 +18,61 @@ func (s *Server) handlePasswordGet(w http.ResponseWriter, r *http.Request, user
}
func (s *Server) handlePasswordChange(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
current := r.FormValue("current_password")
next := r.FormValue("new_password")
confirm := r.FormValue("confirm_password")
if _, err := s.store.Authenticate(r.Context(), user.Username, current); err != nil {
s.setFlash(w, "Das aktuelle Passwort ist nicht korrekt.", "error")
s.redirect(w, r, "/password")
return
}
if strings.TrimSpace(next) != next || len(next) < 6 {
s.setFlash(w, "Das neue Passwort muss mindestens 6 Zeichen lang sein.", "error")
s.redirect(w, r, "/password")
return
}
if next != confirm {
s.setFlash(w, "Die beiden neuen Passwörter stimmen nicht überein.", "error")
s.redirect(w, r, "/password")
return
}
if err := s.store.SetUserPassword(r.Context(), user.ID, next, false); err != nil {
s.setFlash(w, "Das Passwort konnte nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, "/password")
return
}
s.setFlash(w, "Ihr Passwort wurde geändert.", "success")
s.redirect(w, r, "/plan")
s.changePassword(w, r, user, session, "/password", "/plan")
}
func (s *Server) handleSettingsPassword(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
s.changePassword(w, r, user, session, "/settings", "/settings")
}
// changePassword verifies the current password, rewraps the key material for
// the new password and finally stores the new bcrypt hash.
func (s *Server) changePassword(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, back, success string) {
current := r.FormValue("current_password")
next := r.FormValue("new_password")
confirm := r.FormValue("confirm_password")
if _, err := s.store.Authenticate(r.Context(), user.Username, current); err != nil {
s.setFlash(w, "Das aktuelle Passwort ist nicht korrekt.", "error")
s.redirect(w, r, "/settings")
s.redirect(w, r, back)
return
}
if strings.TrimSpace(next) != next || len(next) < 6 {
s.setFlash(w, "Das neue Passwort muss mindestens 6 Zeichen lang sein.", "error")
s.redirect(w, r, "/settings")
if strings.TrimSpace(next) != next || len(next) < 6 || len(next) > 72 {
s.setFlash(w, "Das neue Passwort muss mindestens 6 und höchstens 72 Zeichen lang sein.", "error")
s.redirect(w, r, back)
return
}
if next != confirm {
s.setFlash(w, "Die beiden neuen Passwörter stimmen nicht überein.", "error")
s.redirect(w, r, "/settings")
s.redirect(w, r, back)
return
}
if user.Role != store.RoleEditor && user.Role != store.RoleReader {
_ = s.store.DeleteUserKeys(r.Context(), user.ID)
if err := s.store.SetUserPassword(r.Context(), user.ID, next, false); err != nil {
s.setFlash(w, "Das Passwort konnte nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, back)
return
}
s.dropSessionKeyring(session.ID)
s.setFlash(w, "Ihr Passwort wurde geändert.", "success")
s.redirect(w, r, success)
return
}
keyring, err := s.store.RekeyUserPassword(r.Context(), user.ID, current, next)
if err != nil {
s.setFlash(w, "Die Schlüssel konnten nicht auf das neue Passwort umgestellt werden: "+err.Error(), "error")
s.redirect(w, r, back)
return
}
if err := s.store.SetUserPassword(r.Context(), user.ID, next, false); err != nil {
// Keep the key material usable with the old password if the hash
// could not be updated.
_, _ = s.store.RekeyUserPassword(r.Context(), user.ID, next, current)
s.setFlash(w, "Das Passwort konnte nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, "/settings")
s.redirect(w, r, back)
return
}
s.cacheKeyring(session.ID, keyring)
s.setFlash(w, "Ihr Passwort wurde geändert.", "success")
s.redirect(w, r, "/settings")
s.redirect(w, r, success)
}
+1
View File
@@ -403,6 +403,7 @@ var iconPaths = map[string]string{
"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"/>`,
"copy": `<rect x="9" y="9" width="12" height="12" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>`,
"plus": `<path d="M12 5v14M5 12h14"/>`,
"left": `<path d="M15 18l-6-6 6-6"/>`,
"right": `<path d="M9 18l6-6-6-6"/>`,
+18 -2
View File
@@ -14,6 +14,7 @@ import (
"net/http"
"net/url"
"strings"
"sync"
"time"
"lektorenplan/domain"
@@ -39,6 +40,9 @@ type Server struct {
static http.Handler
opts Options
sessionTTL time.Duration
keyMu sync.Mutex
keyrings map[string]*store.Keyring
}
const (
@@ -63,7 +67,7 @@ func New(st *store.Store, opts Options) (*Server, error) {
names := []string{
"login", "plan", "service", "services", "team", "person", "statistics",
"exchange", "settings", "liturgy", "dispatch", "guest", "admin_tenants", "admin_users",
"admin_churches", "password", "error", "no_tenant",
"admin_churches", "password", "unlock", "error", "no_tenant",
}
views := make(map[string]*template.Template, len(names))
for _, name := range names {
@@ -80,7 +84,8 @@ func New(st *store.Store, opts Options) (*Server, error) {
}
return &Server{
store: st, views: views, opts: opts, sessionTTL: opts.SessionTTL,
static: http.StripPrefix("/static/", http.FileServer(http.FS(staticFS))),
static: http.StripPrefix("/static/", http.FileServer(http.FS(staticFS))),
keyrings: map[string]*store.Keyring{},
}, nil
}
@@ -124,6 +129,8 @@ func (s *Server) Handler() http.Handler {
mux.HandleFunc("POST /login", s.handleLoginPost)
mux.HandleFunc("GET /guest", s.handleGuest)
mux.HandleFunc("POST /logout", s.auth(s.handleLogout))
mux.HandleFunc("GET /unlock", s.auth(s.handleUnlockGet))
mux.HandleFunc("POST /unlock", s.auth(s.handleUnlockPost))
mux.HandleFunc("GET /password", s.auth(s.handlePasswordGet))
mux.HandleFunc("POST /password", s.auth(s.handlePasswordChange))
mux.HandleFunc("GET /switch", s.auth(s.handleSwitchTenant))
@@ -211,6 +218,10 @@ func (s *Server) withSession(next http.Handler) http.Handler {
if err == nil {
ctx := context.WithValue(r.Context(), userContext, user)
ctx = context.WithValue(ctx, sessionContext, session)
if keyring := s.keyringForSession(session.ID); keyring != nil &&
(user.Role == store.RoleEditor || user.Role == store.RoleReader) {
ctx = store.WithKeyring(ctx, keyring)
}
r = r.WithContext(ctx)
tenant, fromQuery := s.resolveTenant(w, r, user)
@@ -300,6 +311,11 @@ func (s *Server) auth(next authedHandler) http.HandlerFunc {
s.redirect(w, r, "/password")
return
}
if r.URL.Path != "/unlock" && r.URL.Path != "/password" && r.URL.Path != "/logout" &&
s.needsUnlock(r.Context(), session, user) {
s.redirect(w, r, "/unlock?next="+url.QueryEscape(r.URL.RequestURI()))
return
}
next(w, r, user, session, tenantFrom(r))
}
}
+7 -5
View File
@@ -16,6 +16,7 @@ type settingsPageData struct {
Counts map[string]int
ChurchCount int
CanEdit bool
CanManageSecrets bool
IsAdmin bool
Database string
DemoReset bool
@@ -103,13 +104,14 @@ func (s *Server) handleSettings(w http.ResponseWriter, r *http.Request, user *st
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.CanEdit {
if page.CanManageSecrets {
config := s.loadSMTPConfig(r.Context(), tenant.ID)
page.SMTPHost = config.Host
if config.Port > 0 {
@@ -165,7 +167,7 @@ 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) {
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")),
@@ -179,7 +181,7 @@ func (s *Server) handleSettingsSave(w http.ResponseWriter, r *http.Request, user
smtpValues["smtp.port"] = ""
}
for key, value := range smtpValues {
if err := s.store.SetTenantSetting(r.Context(), tenant.ID, key, value); err != nil {
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
@@ -187,9 +189,9 @@ func (s *Server) handleSettingsSave(w http.ResponseWriter, r *http.Request, user
}
switch {
case r.FormValue("smtp_clear_password") == "1":
_ = s.store.SetTenantSetting(r.Context(), tenant.ID, "smtp.password", "")
_ = s.store.SetSecret(r.Context(), tenant.ID, store.ScopeTenant, tenant.ID, "smtp.password", "")
case strings.TrimSpace(r.FormValue("smtp_password")) != "":
_ = s.store.SetTenantSetting(r.Context(), tenant.ID, "smtp.password", r.FormValue("smtp_password"))
_ = s.store.SetSecret(r.Context(), tenant.ID, store.ScopeTenant, tenant.ID, "smtp.password", r.FormValue("smtp_password"))
}
}
+116
View File
@@ -197,6 +197,121 @@
});
}
/* Texte kopieren und mailto-Entwürfe aktuell halten ------------------- */
function initDispatchCopy() {
var form = document.querySelector("[data-dispatch-form]");
if (!form) return;
var intro = form.querySelector("[data-dispatch-intro]");
var greeting = form.querySelector("[data-dispatch-greeting]");
var startLabel = form.getAttribute("data-range-start") || "{start}";
var endLabel = form.getAttribute("data-range-end") || "{end}";
var defaultIntro = form.getAttribute("data-default-intro") || "";
var subject = form.getAttribute("data-mail-subject") || "";
function resolve(value) {
return String(value == null ? "" : value)
.split("{start}").join(startLabel)
.split("{end}").join(endLabel)
.trim();
}
function compose(assignments) {
var parts = [];
var rawIntro = intro ? intro.value : "";
if (!String(rawIntro).trim()) rawIntro = defaultIntro;
var lead = resolve(rawIntro);
var tail = resolve(greeting ? greeting.value : "");
if (lead) parts.push(lead);
var table = String(assignments == null ? "" : assignments).trim();
if (table) parts.push("Ihre Einsätze im Zeitraum:\n\n" + table);
if (tail) parts.push(tail);
return parts.join("\n\n");
}
function mailtoHref(button, body) {
var email = button.getAttribute("data-mailto-email") || "";
return "mailto:" + encodeURIComponent(email) +
"?subject=" + encodeURIComponent(subject) +
"&body=" + encodeURIComponent(body.replace(/\n/g, "\r\n"));
}
function markCopied(button) {
if (!button) return;
var original = button.getAttribute("data-copy-title");
if (original == null) {
original = button.getAttribute("title") || "";
button.setAttribute("data-copy-title", original);
}
button.classList.add("is-copied");
button.setAttribute("title", "In die Zwischenablage kopiert");
window.clearTimeout(button.copyTimer);
button.copyTimer = window.setTimeout(function () {
button.classList.remove("is-copied");
if (original) button.setAttribute("title", original);
}, 1600);
}
function fallbackCopy(text, button) {
var area = document.createElement("textarea");
area.value = text;
area.setAttribute("readonly", "");
area.style.position = "fixed";
area.style.top = "-1000px";
area.style.opacity = "0";
document.body.appendChild(area);
area.select();
var ok = false;
try { ok = document.execCommand("copy"); } catch (err) { ok = false; }
document.body.removeChild(area);
if (ok) {
markCopied(button);
} else {
window.prompt("Text in die Zwischenablage kopieren:", text);
}
}
function copy(text, button) {
if (!text) return;
if (navigator.clipboard && navigator.clipboard.writeText) {
navigator.clipboard.writeText(text).then(function () {
markCopied(button);
}, function () {
fallbackCopy(text, button);
});
} else {
fallbackCopy(text, button);
}
}
form.querySelectorAll("[data-copy-shared]").forEach(function (button) {
button.addEventListener("click", function () {
copy(compose(""), button);
});
});
form.querySelectorAll("[data-copy-person]").forEach(function (button) {
button.addEventListener("click", function () {
copy(compose(button.getAttribute("data-mail-assignments")), button);
});
});
var mailtoLinks = Array.prototype.slice.call(form.querySelectorAll("[data-mailto-link]"));
function refreshMailto() {
mailtoLinks.forEach(function (link) {
link.setAttribute("href", mailtoHref(link, compose(link.getAttribute("data-mail-assignments"))));
});
}
if (mailtoLinks.length) {
[intro, greeting].forEach(function (field) {
if (field) field.addEventListener("input", refreshMailto);
});
refreshMailto();
}
}
/* Formular-Doppelversand verhindern ------------------------------------ */
function initSubmitGuards() {
document.querySelectorAll("form").forEach(function (form) {
@@ -220,6 +335,7 @@
initFileDrop();
initRangeOutputs();
initDispatchBulk();
initDispatchCopy();
initSubmitGuards();
});
})();
+4
View File
@@ -815,7 +815,11 @@ hr { border: 0; border-top: 1px solid var(--line); margin: 1rem 0; }
/* ---------- 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-copy-actions { display: flex; align-items: center; gap: .45rem; flex-wrap: wrap; justify-content: flex-end; }
.dispatch-table td { vertical-align: top; }
.dispatch-text-cell { white-space: nowrap; }
.dispatch-text-cell .icon-button + .icon-button { margin-left: .15rem; }
.icon-button.is-copied { color: var(--green-dark); background: var(--green-soft); border-color: #c3d5c6; }
.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; }
+47 -9
View File
@@ -57,6 +57,8 @@ type personPageData struct {
Weekdays []weekdayOption
CanEdit bool
CanManageAll bool
CanEditContact bool
OwnContact bool
UpcomingCount int
TotalCount int
Year int
@@ -185,6 +187,7 @@ func (s *Server) handlePerson(w http.ResponseWriter, r *http.Request, user *stor
person = *loaded
}
canManageAll := s.store.CanEditTenant(r.Context(), user, tenant.ID)
ownContact := false
if !canManageAll {
linkedID, linked := user.LinkedPerson(tenant.ID)
if isNew || !linked || linkedID != person.ID {
@@ -192,6 +195,7 @@ func (s *Server) handlePerson(w http.ResponseWriter, r *http.Request, user *stor
"Sie dürfen nur die Daten der mit Ihrem Konto verknüpften Person einsehen.")
return
}
ownContact = true
}
absences, err := s.store.AbsencesForPerson(r.Context(), tenant.ID, person.ID)
if err != nil {
@@ -244,11 +248,19 @@ func (s *Server) handlePerson(w http.ResponseWriter, r *http.Request, user *stor
sort.SliceStable(rows, func(i, j int) bool {
return rows[i].Service.Date.After(rows[j].Service.Date)
})
canManageContacts := s.store.CanManageSecrets(r.Context(), user, tenant.ID)
ownScope := store.KeyScope{Type: store.ScopePerson, TenantID: tenant.ID, ID: person.ID}
if !canManageAll {
canManageContacts = s.store.SecretIsInitialized(r.Context(), tenant.ID) &&
s.store.HasScopeAccess(r.Context(), user.ID, ownScope)
}
page := personPageData{
Person: person, IsNew: isNew, Absences: absences, Churches: churches,
Assignments: rows, Weekdays: weekdays,
CanEdit: canManageAll || !isNew, CanManageAll: canManageAll,
UpcomingCount: upcoming, TotalCount: len(rows), Year: domain.Year(today),
CanEditContact: canManageContacts,
OwnContact: ownContact,
UpcomingCount: upcoming, TotalCount: len(rows), Year: domain.Year(today),
PreferredChurches: map[string]domain.Church{},
}
for _, churchID := range person.PreferredChurchIDs {
@@ -280,18 +292,34 @@ func (s *Server) handlePerson(w http.ResponseWriter, r *http.Request, user *stor
func (s *Server) handlePersonSave(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
id := r.PathValue("id")
if id == "" || id == "new" {
isNew := id == "" || id == "new"
if isNew {
id = domain.NewID()
}
canManageAll := s.store.CanEditTenant(r.Context(), user, tenant.ID)
var existing *domain.Person
if !isNew {
if loaded, err := s.store.Person(r.Context(), tenant.ID, id); err == nil {
existing = loaded
}
}
if !canManageAll && existing == nil {
s.renderError(w, r, http.StatusForbidden, "Keine Berechtigung", "Diese Person kann nicht bearbeitet werden.")
return
}
canManageContacts := s.store.CanManageSecrets(r.Context(), user, tenant.ID)
if !canManageAll {
loaded, err := s.store.Person(r.Context(), tenant.ID, id)
if err != nil {
s.renderError(w, r, http.StatusForbidden, "Keine Berechtigung", "Diese Person kann nicht bearbeitet werden.")
linkedID, linked := user.LinkedPerson(tenant.ID)
if !linked || linkedID != id {
s.renderError(w, r, http.StatusForbidden, "Keine Berechtigung",
"Sie dürfen nur die Daten der mit Ihrem Konto verknüpften Person bearbeiten.")
return
}
existing = loaded
// A reader may set their own address as soon as the tenant is
// encrypted and the session holds the person's data key.
canManageContacts = s.store.SecretIsInitialized(r.Context(), tenant.ID) &&
s.store.HasScopeAccess(r.Context(), user.ID,
store.KeyScope{Type: store.ScopePerson, TenantID: tenant.ID, ID: id})
}
var roles []domain.Role
for _, role := range domain.AllRoles {
@@ -299,7 +327,7 @@ func (s *Server) handlePersonSave(w http.ResponseWriter, r *http.Request, user *
roles = append(roles, role)
}
}
if existing != nil {
if existing != nil && !canManageAll {
roles = existing.Roles
}
if len(roles) == 0 {
@@ -310,7 +338,7 @@ func (s *Server) handlePersonSave(w http.ResponseWriter, r *http.Request, user *
person := domain.Person{
ID: id, FirstName: strings.TrimSpace(r.FormValue("first_name")),
LastName: strings.TrimSpace(r.FormValue("last_name")), Roles: roles,
Email: strings.TrimSpace(r.FormValue("email")), Phone: strings.TrimSpace(r.FormValue("phone")),
Email: strings.TrimSpace(r.FormValue("email")),
PreferredChurchIDs: r.Form["preferred_churches"],
PreferredServiceTitles: splitList(r.FormValue("preferred_titles")),
MaxPerMonth: parseInt(r.FormValue("max_per_month"), 6),
@@ -323,13 +351,23 @@ func (s *Server) handlePersonSave(w http.ResponseWriter, r *http.Request, user *
}
}
if existing != nil {
person.Active = existing.Active
// Readers keep their planning status. When their own contact cannot be
// written yet, the existing encrypted value must be preserved.
if !canManageAll {
person.Active = existing.Active
}
if !canManageContacts {
person.Email = existing.Email
person.EmailLocked = true
}
person.EmailLocked = person.EmailLocked || (existing.EmailLocked && person.Email == "")
}
if err := s.store.UpsertPerson(r.Context(), tenant.ID, person); err != nil {
s.setFlash(w, "Die Person konnte nicht gespeichert werden: "+err.Error(), "error")
s.redirectBack(w, r, "/team/person/"+id)
return
}
s.refreshCachedKeyrings(r.Context())
s.setFlash(w, "Person gespeichert.", "success")
s.redirect(w, r, "/team/person/"+id)
}
+43 -14
View File
@@ -9,8 +9,10 @@
<div class="intro-actions">
{{if .Data.SMTPConfigured}}
<span class="badge badge-green">{{icon "mail"}} SMTP bereit · {{.Data.SMTPFrom}}</span>
{{else}}
{{else if .Data.CanManageSecrets}}
<span class="badge badge-gold">{{icon "mail"}} SMTP nicht konfiguriert</span>
{{else}}
<span class="badge badge-gold">{{icon "mail"}} SMTP wird von Redakteuren verwaltet</span>
{{end}}
</div>
</section>
@@ -32,7 +34,7 @@
</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">E-Mail</span><strong>{{.Data.EmailCount}}</strong><small>{{if .Data.CanManageSecrets}}Empfänger mit Adresse{{else}}Adressen für dieses Konto gesperrt{{end}}</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>
@@ -42,14 +44,23 @@
<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>
{{if .Data.CanManageSecrets}}
<strong>Kein SMTP-Konto hinterlegt – Versand über Ihr E-Mail-Programm</strong>
<p>Ohne SMTP-Zugangsdaten kann die App keine E-Mails direkt versenden. Öffnen Sie je Person das E-Mail-Symbol in der Spalte „Text“, um einen fertigen Entwurf im eigenen E-Mail-Programm zu starten, oder kopieren Sie den Text über das Kopier-Symbol. Das Druck-PDF erzeugen Sie anschließend über „Druck-PDF erzeugen“ und hängen es manuell an. SMTP-Daten lassen sich jederzeit in den Einstellungen hinterlegen.</p>
<a class="btn btn-secondary btn-small" href="/settings">{{icon "settings"}} Zu den Einstellungen</a>
{{else}}
<strong>Direkter E-Mail-Versand ist für dieses Konto nicht verfügbar</strong>
<p>SMTP-Zugangsdaten und die E-Mail-Adressen der Empfänger werden ausschließlich von Redakteuren verwaltet. Sie können das Druck-PDF mit den gewählten Listen erzeugen und die Empfänger außerhalb der App informieren. Für den Text steht das Kopier-Symbol in der Spalte „Text“ bereit.</p>
{{end}}
</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>
<form method="post" action="/dispatch/save" class="page-stack" data-dispatch-form
data-mail-subject="{{.Data.MailSubject}}"
data-range-start="{{.Data.StartLabel}}"
data-range-end="{{.Data.EndLabel}}"
data-default-intro="{{.Data.DefaultIntro}}">
<input type="hidden" name="csrf" value="{{.CSRF}}">
<input type="hidden" name="start" value="{{.Data.Start}}">
<input type="hidden" name="end" value="{{.Data.End}}">
@@ -57,20 +68,23 @@
<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 class="dispatch-copy-actions">
<span class="count-pill">Platzhalter {start} und {end}</span>
<button class="icon-button" type="button" data-copy-shared title="Einleitung und Gruß in die Zwischenablage kopieren" aria-label="Einleitung und Gruß kopieren">{{icon "copy"}}</button>
</div>
</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>
<p class="muted">Ein leer gelassenes Einleitungsfeld stellt den Standardtext wieder her. Über das Kopier-Symbol lässt sich der aktuelle Text in die Zwischenablage übernehmen.</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>
<textarea name="intro" rows="6" maxlength="6000" data-dispatch-intro>{{.Data.Intro}}</textarea>
</label>
<label class="field"><span class="field-label">Abschlussgrußformel</span>
<textarea name="greeting" rows="3" maxlength="2000">{{.Data.Greeting}}</textarea>
<textarea name="greeting" rows="3" maxlength="2000" data-dispatch-greeting>{{.Data.Greeting}}</textarea>
</label>
</div>
</div>
@@ -94,6 +108,7 @@
<th>Versandweg</th>
<th>Liste</th>
<th>Vorblatt</th>
<th>Text</th>
</tr>
</thead>
<tbody>
@@ -107,6 +122,8 @@
<small>{{$person.RoleLabel}}</small>
{{if $person.Email}}
<a href="mailto:{{$person.Email}}">{{$person.Email}}</a>
{{else if $person.EmailLocked}}
<span class="dispatch-no-mail">E-Mail-Adresse gesperrt</span>
{{else}}
<span class="dispatch-no-mail">keine E-Mail-Adresse hinterlegt</span>
{{end}}
@@ -132,7 +149,7 @@
<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}}
{{if and (eq .Channel "email") (not $person.Email)}}<small class="dispatch-warn">{{if $person.EmailLocked}}Adresse gesperrt{{else}}ohne Adresse{{end}} → Ausdruck</small>{{end}}
</td>
<td>
<select name="variant_{{$person.ID}}" aria-label="Liste für {{$person.FullName}}">
@@ -146,17 +163,29 @@
<span>{{if eq $effective "email"}}E-Mail-Text{{else}}Anschreiben{{end}}</span>
</label>
</td>
<td class="dispatch-text-cell">
<button class="icon-button" type="button" data-copy-person data-mail-assignments="{{.AssignmentText}}" title="Anschreiben für {{$person.FullName}} kopieren" aria-label="Anschreiben für {{$person.FullName}} kopieren">{{icon "copy"}}</button>
{{if and (not $.Data.SMTPConfigured) $person.Email}}
<a class="icon-button" href="{{.Mailto}}" data-mailto-link data-mailto-email="{{$person.Email}}" data-mail-assignments="{{.AssignmentText}}" title="Entwurf im eigenen E-Mail-Programm öffnen" aria-label="E-Mail an {{$person.FullName}} im E-Mail-Programm öffnen">{{icon "mail"}}</a>
{{end}}
</td>
</tr>
{{else}}
<tr><td colspan="5"><p class="empty-note">Im aktiven Mandanten sind noch keine aktiven Personen hinterlegt.</p></td></tr>
<tr><td colspan="6"><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>
<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. In der Spalte „Text“ kopiert das erste Symbol das persönliche Anschreiben; ohne SMTP öffnet das zweite Symbol einen fertigen Entwurf im eigenen E-Mail-Programm.{{if not .Data.CanManageSecrets}} Empfängeradressen und SMTP-Zugangsdaten sind für dieses Konto gesperrt und werden von Redakteuren verwaltet.{{end}}</p>
<div class="card-foot dispatch-actions">
<button class="btn btn-secondary" type="submit">{{icon "check"}} Auswahl speichern</button>
{{if .Data.SMTPConfigured}}
<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>
{{else if .Data.CanManageSecrets}}
<button class="btn btn-primary" type="button" disabled title="Kein SMTP-Konto hinterlegt – nutzen Sie das E-Mail-Symbol in der Spalte „Text“.">{{icon "send"}} E-Mails senden</button>
{{else}}
<button class="btn btn-primary" type="button" disabled title="SMTP-Zugangsdaten können nur Redakteure hinterlegen.">{{icon "send"}} E-Mails senden</button>
{{end}}
<button class="btn btn-secondary" type="submit" formaction="/dispatch/print" formtarget="_blank">{{icon "printer"}} Druck-PDF erzeugen</button>
</div>
</section>
@@ -199,7 +228,7 @@
<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>{{.PersonName}}</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>
+1 -1
View File
@@ -64,7 +64,7 @@
{{end}}
<div class="auth-note">
<span class="dot"></span>
<span>Sitzungen sind serverseitig gespeichert, Passwörter mit bcrypt geschützt.</span>
<span>Sitzungen sind serverseitig gespeichert, Passwörter mit bcrypt geschützt. Kontaktdaten und SMTP-Zugangsdaten liegen verschlüsselt.</span>
</div>
</section>
</div>
+2 -3
View File
@@ -40,8 +40,7 @@
<label class="field"><span class="field-label">Nachname</span><input type="text" name="last_name" value="{{$person.LastName}}"></label>
</div>
<div class="form-row">
<label class="field"><span class="field-label">E-Mail</span><input type="email" name="email" value="{{$person.Email}}"></label>
<label class="field"><span class="field-label">Telefon</span><input type="text" name="phone" value="{{$person.Phone}}"></label>
<label class="field"><span class="field-label">E-Mail{{if not .Data.CanEditContact}} <small>{{if .Data.OwnContact}}noch nicht freigegeben{{else}}nur Redakteure{{end}}</small>{{else if $person.EmailLocked}} <small>gesperrt</small>{{end}}</span><input type="email" name="email" value="{{$person.Email}}" {{if not .Data.CanEditContact}}disabled placeholder="{{if .Data.OwnContact}}Wird nach der Einrichtung durch einen Redakteur freigegeben{{else}}Wird nur von Redakteuren verwaltet{{end}}"{{else if $person.EmailLocked}}placeholder="Verschlüsselt – zum Ändern neu eingeben"{{end}}></label>
</div>
<div class="field-group">
<span class="field-label">Dienste</span>
@@ -81,7 +80,7 @@
<dt>Name</dt><dd>{{$person.FullName}}</dd>
<dt>Dienste</dt><dd>{{$person.RoleLabel}}</dd>
{{if $person.Email}}<dt>E-Mail</dt><dd>{{$person.Email}}</dd>{{end}}
{{if $person.Phone}}<dt>Telefon</dt><dd>{{$person.Phone}}</dd>{{end}}
{{if $person.EmailLocked}}<dt>Kontaktdaten</dt><dd>verschlüsselt und für dieses Konto nicht entsperrt</dd>{{end}}
<dt>Monatslimit</dt><dd>{{if gt $person.MaxPerMonth 0}}{{$person.MaxPerMonth}}{{else}}kein Limit{{end}}</dd>
{{if $person.Notes}}<dt>Notizen</dt><dd>{{$person.Notes}}</dd>{{end}}
</dl>
+2 -2
View File
@@ -50,14 +50,14 @@
</section>
{{end}}
{{if .Data.CanEdit}}
{{if .Data.CanManageSecrets}}
<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>
<p class="muted">Die Zugangsdaten werden verschlüsselt gespeichert und sind nur für entsperrte Redakteure dieses Mandanten lesbar. Das Passwort wird nie wieder angezeigt – leer lassen, um es beizubehalten.</p>
</div>
<div class="settings-fields">
<div class="form-row">
+1 -2
View File
@@ -50,8 +50,7 @@
</div>
<div class="person-details">
{{if .Email}}<a href="mailto:{{.Email}}">{{.Email}}</a>{{end}}
{{if .Phone}}<span>{{.Phone}}</span>{{end}}
{{if or .Email .Phone}}{{else}}<span class="muted">Keine Kontaktdaten</span>{{end}}
{{if .EmailLocked}}<span class="muted">Kontaktdaten gesperrt</span>{{else if not .Email}}<span class="muted">Keine Kontaktdaten</span>{{end}}
</div>
{{if .HasPreference}}
<div class="preference-tags">
+27
View File
@@ -0,0 +1,27 @@
{{define "content"}}
<div class="page-stack narrow-page">
<section class="page-intro">
<div>
<span class="eyebrow">Sicherheit</span>
<h2>Daten entsperren</h2>
<p>Nach einem Neustart des Servers liegen die Entschlüsselungsschlüssel nicht mehr im Arbeitsspeicher. Bitte geben Sie Ihr Anmeldepasswort ein, um Ihre verschlüsselten Daten wieder zu entsperren. Redakteure entsperren damit alle Kontaktdaten und SMTP-Zugangsdaten, Leser die eigene E-Mail-Adresse.</p>
</div>
</section>
<section class="card">
<form method="post" action="/unlock" class="form-stack">
<input type="hidden" name="csrf" value="{{.CSRF}}">
<input type="hidden" name="next" value="{{.Data.Next}}">
<label class="field"><span class="field-label">Passwort</span><input type="password" name="password" required autocomplete="current-password" autofocus></label>
<div class="form-actions">
<button class="btn btn-primary" type="submit">Entsperren</button>
</div>
</form>
<form method="post" action="/logout" class="form-actions">
<input type="hidden" name="csrf" value="{{.CSRF}}">
<button class="btn btn-ghost" type="submit">Stattdessen abmelden</button>
</form>
<p class="empty-note">Wurde Ihr Passwort von einem Administrator zurückgesetzt, melden Sie sich mit dem temporären Passwort an.</p>
</section>
</div>
{{end}}