Gastansicht, Verbesserungen bei Planung
This commit is contained in:
1 parent
b3afa3ef32
commit
c08d43e7dd
38 files changed
+3845
-219
No files matched your search
@@ -1,6 +1,7 @@
|
||||
package web
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log"
|
||||
"net/http"
|
||||
"net/url"
|
||||
@@ -69,10 +70,30 @@ func (s *Server) handleLoginPost(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
s.setFlash(w, "Willkommen zurück, "+user.DisplayName+".", "success")
|
||||
if notice := s.readerRosterNotice(r.Context(), user); notice != "" {
|
||||
s.setFlash(w, notice, "info")
|
||||
}
|
||||
next := safeNext(r.FormValue("next"))
|
||||
s.redirect(w, r, next)
|
||||
}
|
||||
|
||||
// readerRosterNotice returns a login hint when the reader directory changed
|
||||
// since the last review of the sharing list.
|
||||
func (s *Server) readerRosterNotice(ctx context.Context, user *store.User) string {
|
||||
if user == nil || user.Role != store.RoleReader {
|
||||
return ""
|
||||
}
|
||||
personID, linked := user.LinkedPerson(user.LinkedTenantID)
|
||||
if !linked {
|
||||
return ""
|
||||
}
|
||||
changed, known, err := s.store.ContactRosterChanged(ctx, user.LinkedTenantID, user.ID, personID)
|
||||
if err != nil || !known || !changed {
|
||||
return ""
|
||||
}
|
||||
return "Die Liste der Lektoren und Kommunionhelfer hat sich geändert. Bitte prüfen Sie unter „Team & Abwesenheiten“, wer Ihre E-Mail-Adresse sehen darf."
|
||||
}
|
||||
|
||||
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 {
|
||||
|
||||
+92
-10
@@ -3,33 +3,41 @@ package web
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"lektorenplan/domain"
|
||||
"lektorenplan/store"
|
||||
)
|
||||
|
||||
// guestPageData is the read-only public plan. It deliberately contains no
|
||||
// person records: assignments are shown by role only.
|
||||
// guestPageData is the read-only public plan. It exposes only short labels
|
||||
// (Kürzel or initials) of assigned people, never full names or contact data.
|
||||
type guestPageData struct {
|
||||
Range domain.DayRange
|
||||
Start string
|
||||
End string
|
||||
MinDate string
|
||||
MaxDate string
|
||||
PrevStart string
|
||||
PrevEnd string
|
||||
NextStart string
|
||||
NextEnd string
|
||||
CanPrev bool
|
||||
CanNext bool
|
||||
DefaultStart string
|
||||
DefaultEnd string
|
||||
Rows []domain.DayPlanRow
|
||||
Churches []domain.Church
|
||||
Tenants []store.Tenant
|
||||
TenantID string
|
||||
TenantName string
|
||||
PersonLabels map[string]string
|
||||
ServiceCount int
|
||||
OpenSlots int
|
||||
Today string
|
||||
}
|
||||
|
||||
// handleGuest renders the plan without authentication. It never exposes
|
||||
// settings, write actions or the names of assigned people.
|
||||
// settings, write actions or the full names of assigned people.
|
||||
func (s *Server) handleGuest(w http.ResponseWriter, r *http.Request) {
|
||||
tenants, err := s.store.Tenants(r.Context())
|
||||
if err != nil {
|
||||
@@ -51,7 +59,18 @@ func (s *Server) handleGuest(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
}
|
||||
|
||||
rng := s.rangeFromRequest(r)
|
||||
today := domain.Today()
|
||||
// The selectable range starts at the most recent Sunday and ends with the
|
||||
// last day that actually has planning data.
|
||||
minDate := domain.AddingDays(-(domain.Weekday(today) - 1), today)
|
||||
maxDate := today
|
||||
if latest, err := s.store.LatestServiceDate(r.Context(), tenant.ID); err == nil && latest != nil {
|
||||
maxDate = *latest
|
||||
}
|
||||
if maxDate.Before(minDate) {
|
||||
maxDate = minDate
|
||||
}
|
||||
rng := guestRangeFromRequest(r, today, minDate, maxDate)
|
||||
rows, err := s.store.PlanRows(r.Context(), tenant.ID, rng)
|
||||
if err != nil {
|
||||
http.Error(w, "Der Gastzugang ist derzeit nicht verfügbar.", http.StatusInternalServerError)
|
||||
@@ -63,15 +82,50 @@ func (s *Server) handleGuest(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
|
||||
prev := domain.MonthRange(domain.AddingMonths(-1, rng.Start))
|
||||
next := domain.MonthRange(domain.AddingMonths(1, rng.Start))
|
||||
assignedIDs := map[string]bool{}
|
||||
for _, row := range rows {
|
||||
for _, service := range row.Services {
|
||||
for _, assignment := range service.Assignments {
|
||||
assignedIDs[assignment.PersonID] = true
|
||||
}
|
||||
}
|
||||
}
|
||||
labels := map[string]string{}
|
||||
if len(assignedIDs) > 0 {
|
||||
people, err := s.store.People(r.Context(), tenant.ID)
|
||||
if err != nil {
|
||||
http.Error(w, "Der Gastzugang ist derzeit nicht verfügbar.", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
var assigned []domain.Person
|
||||
for _, person := range people {
|
||||
if assignedIDs[person.ID] {
|
||||
assigned = append(assigned, person)
|
||||
}
|
||||
}
|
||||
labels = domain.PersonLabels(assigned)
|
||||
}
|
||||
|
||||
prevEnd := domain.AddingDays(-1, rng.Start)
|
||||
nextStart := domain.AddingDays(1, rng.End)
|
||||
page := guestPageData{
|
||||
Range: rng, Start: domain.Key(rng.Start), End: domain.Key(rng.End),
|
||||
PrevStart: domain.Key(prev.Start), PrevEnd: domain.Key(prev.End),
|
||||
NextStart: domain.Key(next.Start), NextEnd: domain.Key(next.End),
|
||||
MinDate: domain.Key(minDate), MaxDate: domain.Key(maxDate),
|
||||
Rows: rows, Churches: churches, Tenants: tenants,
|
||||
TenantID: tenant.ID, TenantName: tenant.Name,
|
||||
Today: domain.Key(domain.Today()),
|
||||
TenantID: tenant.ID, TenantName: tenant.Name, PersonLabels: labels,
|
||||
Today: domain.Key(today),
|
||||
DefaultStart: domain.Key(guestClamp(today, minDate, maxDate)),
|
||||
DefaultEnd: domain.Key(guestClamp(domain.AddingDays(28, today), minDate, maxDate)),
|
||||
}
|
||||
page.CanPrev = !prevEnd.Before(minDate)
|
||||
if page.CanPrev {
|
||||
page.PrevEnd = domain.Key(prevEnd)
|
||||
page.PrevStart = domain.Key(guestClamp(domain.AddingDays(-27, prevEnd), minDate, maxDate))
|
||||
}
|
||||
page.CanNext = !nextStart.After(maxDate)
|
||||
if page.CanNext {
|
||||
page.NextStart = domain.Key(nextStart)
|
||||
page.NextEnd = domain.Key(guestClamp(domain.AddingDays(27, nextStart), minDate, maxDate))
|
||||
}
|
||||
for _, row := range rows {
|
||||
page.ServiceCount += len(row.Services)
|
||||
@@ -86,3 +140,31 @@ func (s *Server) handleGuest(w http.ResponseWriter, r *http.Request) {
|
||||
data.Data = page
|
||||
s.renderPage(w, r, "guest", data)
|
||||
}
|
||||
|
||||
// guestRangeFromRequest applies the narrower guest rules: the default is today
|
||||
// through four weeks later, and every requested date is clamped to the
|
||||
// selectable window between the most recent Sunday and the last planned day.
|
||||
func guestRangeFromRequest(r *http.Request, today, minDate, maxDate time.Time) domain.DayRange {
|
||||
start := guestClamp(today, minDate, maxDate)
|
||||
end := guestClamp(domain.AddingDays(28, today), minDate, maxDate)
|
||||
if parsed, ok := domain.DateFromKey(strings.TrimSpace(r.URL.Query().Get("start"))); ok {
|
||||
start = guestClamp(parsed, minDate, maxDate)
|
||||
}
|
||||
if parsed, ok := domain.DateFromKey(strings.TrimSpace(r.URL.Query().Get("end"))); ok {
|
||||
end = guestClamp(parsed, minDate, maxDate)
|
||||
}
|
||||
if end.Before(start) {
|
||||
start, end = end, start
|
||||
}
|
||||
return domain.NewDayRange(start, end)
|
||||
}
|
||||
|
||||
func guestClamp(date, minDate, maxDate time.Time) time.Time {
|
||||
if date.Before(minDate) {
|
||||
return minDate
|
||||
}
|
||||
if date.After(maxDate) {
|
||||
return maxDate
|
||||
}
|
||||
return date
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package web
|
||||
|
||||
import (
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
"lektorenplan/domain"
|
||||
)
|
||||
|
||||
func TestGuestRangeDefaultsToFourWeeks(t *testing.T) {
|
||||
today := domain.MustDate("2026-11-17") // Tuesday
|
||||
minDate := domain.MustDate("2026-11-15")
|
||||
maxDate := domain.MustDate("2027-06-30")
|
||||
request := httptest.NewRequest("GET", "/guest", nil)
|
||||
rng := guestRangeFromRequest(request, today, minDate, maxDate)
|
||||
if got := domain.Key(rng.Start); got != "2026-11-17" {
|
||||
t.Errorf("default start = %s, want today", got)
|
||||
}
|
||||
if got := domain.Key(rng.End); got != "2026-12-15" {
|
||||
t.Errorf("default end = %s, want four weeks", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGuestRangeClampsToSundayAndLatestPlannedDay(t *testing.T) {
|
||||
today := domain.MustDate("2026-11-17")
|
||||
minDate := domain.MustDate("2026-11-15")
|
||||
maxDate := domain.MustDate("2026-12-24")
|
||||
request := httptest.NewRequest("GET", "/guest?start=2026-01-01&end=2027-01-01", nil)
|
||||
rng := guestRangeFromRequest(request, today, minDate, maxDate)
|
||||
if got := domain.Key(rng.Start); got != domain.Key(minDate) {
|
||||
t.Errorf("start = %s, want the most recent Sunday %s", got, domain.Key(minDate))
|
||||
}
|
||||
if got := domain.Key(rng.End); got != domain.Key(maxDate) {
|
||||
t.Errorf("end = %s, want the latest planned day %s", got, domain.Key(maxDate))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGuestRangeSwapsReversedInput(t *testing.T) {
|
||||
today := domain.MustDate("2026-11-17")
|
||||
minDate := domain.MustDate("2026-11-15")
|
||||
maxDate := domain.MustDate("2026-12-31")
|
||||
request := httptest.NewRequest("GET", "/guest?start=2026-12-10&end=2026-11-20", nil)
|
||||
rng := guestRangeFromRequest(request, today, minDate, maxDate)
|
||||
if rng.End.Before(rng.Start) {
|
||||
t.Fatalf("range not normalized: %s – %s", domain.Key(rng.Start), domain.Key(rng.End))
|
||||
}
|
||||
}
|
||||
@@ -62,6 +62,26 @@ func (s *Server) refreshCachedKeyrings(ctx context.Context) {
|
||||
}
|
||||
}
|
||||
|
||||
// forgetCachedScopeForUsers removes a revoked data key from the sessions of
|
||||
// the selected accounts. The owner's own session is deliberately untouched.
|
||||
func (s *Server) forgetCachedScopeForUsers(scope store.KeyScope, userIDs []string) {
|
||||
selected := map[string]bool{}
|
||||
for _, userID := range userIDs {
|
||||
selected[userID] = true
|
||||
}
|
||||
s.keyMu.Lock()
|
||||
keyrings := make([]*store.Keyring, 0, len(s.keyrings))
|
||||
for _, keyring := range s.keyrings {
|
||||
if keyring != nil && selected[keyring.UserID] {
|
||||
keyrings = append(keyrings, keyring)
|
||||
}
|
||||
}
|
||||
s.keyMu.Unlock()
|
||||
for _, keyring := range keyrings {
|
||||
keyring.Forget(scope)
|
||||
}
|
||||
}
|
||||
|
||||
// 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.
|
||||
|
||||
@@ -64,6 +64,9 @@ type planPageData struct {
|
||||
Timeline planTimeline
|
||||
FilterPeople []domain.Person
|
||||
PersonFilter string
|
||||
SwapMarks map[string]string
|
||||
PromptBeyond bool
|
||||
BeyondOpen int
|
||||
}
|
||||
|
||||
func flattenRows(rows []domain.DayPlanRow) ([]domain.ServiceOccurrence, []domain.Assignment) {
|
||||
@@ -158,7 +161,7 @@ func (s *Server) handlePlan(w http.ResponseWriter, r *http.Request, user *store.
|
||||
fourWeeks := domain.DaysRange(28, domain.Today())
|
||||
|
||||
data := s.baseView(w, r, "Gottesdienstplan", "plan")
|
||||
data.Data = planPageData{
|
||||
page := planPageData{
|
||||
Range: rng, Start: domain.Key(rng.Start), End: domain.Key(rng.End),
|
||||
Rows: rows, Churches: churches, People: people, Stats: stats,
|
||||
CanEdit: canEdit,
|
||||
@@ -167,6 +170,11 @@ func (s *Server) handlePlan(w http.ResponseWriter, r *http.Request, user *store.
|
||||
PresetFourStart: domain.Key(fourWeeks.Start), PresetFourEnd: domain.Key(fourWeeks.End),
|
||||
Presets: presets, Timeline: timeline, FilterPeople: filterPeople, PersonFilter: personFilter,
|
||||
}
|
||||
page.PromptBeyond = canEdit && r.URL.Query().Get("beyondPrompt") == "1" &&
|
||||
strings.TrimSpace(r.URL.Query().Get("beyondOpen")) != ""
|
||||
page.BeyondOpen = parseInt(r.URL.Query().Get("beyondOpen"), 0)
|
||||
page.SwapMarks, _ = s.store.PendingSwapAssignmentIDs(r.Context(), tenant.ID)
|
||||
data.Data = page
|
||||
s.renderPage(w, r, "plan", data)
|
||||
}
|
||||
|
||||
@@ -339,7 +347,15 @@ func (s *Server) handleAutoPlan(w http.ResponseWriter, r *http.Request, user *st
|
||||
}
|
||||
rng := formRange(r)
|
||||
options := s.planningOptions(r, tenant.ID)
|
||||
options.ReplaceExisting = r.FormValue("replace") == "1" || r.FormValue("replace") == "on"
|
||||
allowBeyond := r.FormValue("beyond") == "1" || r.FormValue("beyond") == "on"
|
||||
if allowBeyond {
|
||||
// Keep the result of the first pass and only add the fallback
|
||||
// assignments for volunteers who explicitly allowed it.
|
||||
options.ReplaceExisting = false
|
||||
options.AllowBeyondPreferences = true
|
||||
} else {
|
||||
options.ReplaceExisting = r.FormValue("replace") == "1" || r.FormValue("replace") == "on"
|
||||
}
|
||||
|
||||
services, err := s.store.Services(r.Context(), tenant.ID, rng)
|
||||
if err != nil {
|
||||
@@ -376,9 +392,11 @@ func (s *Server) handleAutoPlan(w http.ResponseWriter, r *http.Request, user *st
|
||||
s.redirect(w, r, "/plan")
|
||||
return
|
||||
}
|
||||
liturgicalDays, _ := s.store.LiturgicalDays(r.Context(), rng)
|
||||
planner := domain.ServicePlanner{
|
||||
People: people, Absences: absences, Services: services,
|
||||
ExistingAssignments: existing, Churches: churches, Options: options,
|
||||
ExistingAssignments: existing, Churches: churches, LiturgicalDays: liturgicalDays,
|
||||
Options: options,
|
||||
}
|
||||
result := planner.Plan()
|
||||
if err := s.store.SavePlan(r.Context(), tenant.ID, result.Assignments, rng, options.ReplaceExisting); err != nil {
|
||||
@@ -390,7 +408,20 @@ func (s *Server) handleAutoPlan(w http.ResponseWriter, r *http.Request, user *st
|
||||
}
|
||||
s.setFlash(w, result.Message, kind)
|
||||
}
|
||||
s.redirect(w, r, "/plan?start="+domain.Key(rng.Start)+"&end="+domain.Key(rng.End))
|
||||
target := "/plan?start=" + domain.Key(rng.Start) + "&end=" + domain.Key(rng.End)
|
||||
if !allowBeyond && len(result.Unfilled) > 0 && hasBeyondVolunteers(people) {
|
||||
target += fmt.Sprintf("&beyondPrompt=1&beyondOpen=%d", len(result.Unfilled))
|
||||
}
|
||||
s.redirect(w, r, target)
|
||||
}
|
||||
|
||||
func hasBeyondVolunteers(people []domain.Person) bool {
|
||||
for _, person := range people {
|
||||
if person.Active && person.AllowBeyondPreferences {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func formRange(r *http.Request) domain.DayRange {
|
||||
|
||||
@@ -68,6 +68,7 @@ func New(st *store.Store, opts Options) (*Server, error) {
|
||||
"login", "plan", "service", "services", "team", "person", "statistics",
|
||||
"exchange", "settings", "liturgy", "dispatch", "guest", "admin_tenants", "admin_users",
|
||||
"admin_churches", "password", "unlock", "error", "no_tenant",
|
||||
"swap_request", "swap_detail",
|
||||
}
|
||||
views := make(map[string]*template.Template, len(names))
|
||||
for _, name := range names {
|
||||
@@ -158,6 +159,15 @@ func (s *Server) Handler() http.Handler {
|
||||
mux.HandleFunc("POST /team/person/{id}/delete", s.editor(s.handlePersonDelete))
|
||||
mux.HandleFunc("POST /team/person/{id}/absence", s.personEditor(s.handleAbsenceSave))
|
||||
mux.HandleFunc("POST /team/person/{id}/absence/delete", s.personEditor(s.handleAbsenceDelete))
|
||||
mux.HandleFunc("POST /team/sharing", s.auth(s.handleContactSharesSave))
|
||||
mux.HandleFunc("POST /team/sharing/ack", s.auth(s.handleContactRosterAck))
|
||||
|
||||
mux.HandleFunc("GET /swap/new", s.auth(s.handleSwapNew))
|
||||
mux.HandleFunc("POST /swap/request", s.auth(s.handleSwapRequestCreate))
|
||||
mux.HandleFunc("GET /swap/requests/{id}", s.auth(s.handleSwapRequestView))
|
||||
mux.HandleFunc("GET /swap/{token}", s.auth(s.handleSwapTokenView))
|
||||
mux.HandleFunc("GET /swap/{token}/{action}", s.auth(s.handleSwapTokenAction))
|
||||
mux.HandleFunc("POST /swap/{token}/respond", s.auth(s.handleSwapRespond))
|
||||
|
||||
mux.HandleFunc("GET /statistics", s.auth(s.handleStatistics))
|
||||
mux.HandleFunc("GET /exchange", s.auth(s.handleExchange))
|
||||
|
||||
+88
-16
@@ -41,6 +41,8 @@ type serviceDetailData struct {
|
||||
HelperCandidates []domain.CandidateSuggestion
|
||||
LectorAssigned []domain.Assignment
|
||||
HelperAssigned []domain.Assignment
|
||||
SwapMarks map[string]string
|
||||
SwapCandidates map[string]bool
|
||||
}
|
||||
|
||||
func (s *Server) handleServiceOrder(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
@@ -106,11 +108,22 @@ func (s *Server) handleServiceOrder(w http.ResponseWriter, r *http.Request, user
|
||||
}
|
||||
var editingSpecial *domain.ServiceOccurrence
|
||||
if id := strings.TrimSpace(r.URL.Query().Get("edit_special")); id != "" {
|
||||
for i := range specials {
|
||||
if specials[i].ID == id {
|
||||
copy := specials[i]
|
||||
editingSpecial = ©
|
||||
break
|
||||
if id == "new" {
|
||||
date, ok := domain.DateFromKey(strings.TrimSpace(r.URL.Query().Get("date")))
|
||||
if !ok {
|
||||
date = domain.Today()
|
||||
}
|
||||
editingSpecial = &domain.ServiceOccurrence{
|
||||
Date: date, TimeMinutes: 18 * 60, Kind: domain.KindSpecial,
|
||||
LectorsNeeded: 1, HelpersNeeded: 1,
|
||||
}
|
||||
} else {
|
||||
for i := range specials {
|
||||
if specials[i].ID == id {
|
||||
copy := specials[i]
|
||||
editingSpecial = ©
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -187,18 +200,55 @@ func (s *Server) handleServiceDetail(w http.ResponseWriter, r *http.Request, use
|
||||
}
|
||||
detail.LectorOpen = withAssignments.OpenSlotsFor(domain.RoleLector)
|
||||
detail.HelperOpen = withAssignments.OpenSlotsFor(domain.RoleHelper)
|
||||
detail.SwapMarks, _ = s.store.PendingSwapAssignmentIDs(r.Context(), tenant.ID)
|
||||
detail.SwapCandidates = map[string]bool{}
|
||||
if requesterPersonID, linked := user.LinkedPerson(tenant.ID); linked && user.Role == store.RoleReader {
|
||||
directory, err := s.store.ReaderDirectory(r.Context(), tenant.ID)
|
||||
if err == nil {
|
||||
readerByPerson := map[string]string{}
|
||||
for _, entry := range directory {
|
||||
readerByPerson[entry.Person.ID] = entry.UserID
|
||||
}
|
||||
for _, assignment := range assignments {
|
||||
if assignment.PersonID == requesterPersonID {
|
||||
continue
|
||||
}
|
||||
targetUserID, ok := readerByPerson[assignment.PersonID]
|
||||
if !ok || service.Date.Before(domain.Today()) || service.Locked || assignment.Locked {
|
||||
continue
|
||||
}
|
||||
if detail.SwapMarks[assignment.ID] != "" {
|
||||
continue
|
||||
}
|
||||
if s.swapConsent(r.Context(), tenant.ID, user.ID, requesterPersonID,
|
||||
targetUserID, assignment.PersonID) {
|
||||
detail.SwapCandidates[assignment.ID] = true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if detail.LectorOpen > 0 {
|
||||
detail.LectorCandidates = domain.CandidateSuggestions(*service, domain.RoleLector, people, absences,
|
||||
rangeAssignments, rangeServices, assignments, false)
|
||||
rangeAssignments, rangeServices, assignments, false, s.liturgicalDay(r, service.Date))
|
||||
}
|
||||
if detail.HelperOpen > 0 {
|
||||
detail.HelperCandidates = domain.CandidateSuggestions(*service, domain.RoleHelper, people, absences,
|
||||
rangeAssignments, rangeServices, assignments, false)
|
||||
rangeAssignments, rangeServices, assignments, false, s.liturgicalDay(r, service.Date))
|
||||
}
|
||||
data.Data = detail
|
||||
s.renderPage(w, r, "service", data)
|
||||
}
|
||||
|
||||
// liturgicalDay loads the liturgical entry for one date so candidate lists and
|
||||
// manual assignments can treat high feasts like Sundays.
|
||||
func (s *Server) liturgicalDay(r *http.Request, date time.Time) *domain.LiturgicalDay {
|
||||
days, err := s.store.LiturgicalDays(r.Context(), domain.NewDayRange(date, date))
|
||||
if err != nil || len(days) == 0 {
|
||||
return nil
|
||||
}
|
||||
return &days[0]
|
||||
}
|
||||
|
||||
func (s *Server) serviceRange(r *http.Request, date time.Time) domain.DayRange {
|
||||
start, startOK := domain.DateFromKey(strings.TrimSpace(r.URL.Query().Get("start")))
|
||||
end, endOK := domain.DateFromKey(strings.TrimSpace(r.URL.Query().Get("end")))
|
||||
@@ -251,9 +301,26 @@ func (s *Server) handleAssign(w http.ResponseWriter, r *http.Request, user *stor
|
||||
return
|
||||
}
|
||||
locked := r.FormValue("locked") == "1" || r.FormValue("locked") == "on"
|
||||
highFeast := false
|
||||
if day := s.liturgicalDay(r, service.Date); day != nil {
|
||||
highFeast = day.IsHighFeast()
|
||||
}
|
||||
beyond := !person.MatchesWeekdayPreference(domain.Weekday(service.Date), service.TimeMinutes, highFeast)
|
||||
if !beyond && person.MaxPerMonth > 0 {
|
||||
if monthAssignments, err := s.store.Assignments(r.Context(), tenant.ID, domain.MonthRange(service.Date)); err == nil {
|
||||
used := 0
|
||||
for _, existing := range monthAssignments {
|
||||
if existing.PersonID == person.ID && existing.ServiceID != service.ID {
|
||||
used++
|
||||
}
|
||||
}
|
||||
beyond = used >= person.MaxPerMonth
|
||||
}
|
||||
}
|
||||
assignment := domain.Assignment{
|
||||
ID: domain.NewID(), ServiceID: service.ID, PersonID: person.ID,
|
||||
Role: role, Locked: locked, Note: strings.TrimSpace(r.FormValue("note")),
|
||||
Role: role, Locked: locked, BeyondPreferences: beyond,
|
||||
Note: strings.TrimSpace(r.FormValue("note")),
|
||||
}
|
||||
if err := s.store.UpsertAssignment(r.Context(), tenant.ID, assignment); err != nil {
|
||||
s.setFlash(w, "Die Einteilung konnte nicht gespeichert werden: "+err.Error(), "error")
|
||||
@@ -344,18 +411,23 @@ func (s *Server) handleServiceDelete(w http.ResponseWriter, r *http.Request, use
|
||||
s.redirect(w, r, "/plan")
|
||||
return
|
||||
}
|
||||
if service.Kind == domain.KindRegular {
|
||||
s.setFlash(w, "Regelmäßige Gottesdienste werden über die Gottesdienstordnung verwaltet und können nicht einzeln gelöscht werden.", "info")
|
||||
if err := s.store.DeleteService(r.Context(), tenant.ID, id); err != nil {
|
||||
s.setFlash(w, "Der Gottesdienst konnte nicht gelöscht werden.", "error")
|
||||
s.redirectBack(w, r, "/plan")
|
||||
return
|
||||
}
|
||||
if err := s.store.DeleteService(r.Context(), tenant.ID, id); err != nil {
|
||||
s.setFlash(w, "Der Gottesdienst konnte nicht gelöscht werden.", "error")
|
||||
s.redirectBack(w, r, "/services")
|
||||
return
|
||||
if service.Kind == domain.KindSpecial {
|
||||
s.setFlash(w, "Sondergottesdienst gelöscht.", "success")
|
||||
} else {
|
||||
s.setFlash(w, "Gottesdienst gelöscht. Die Gottesdienstordnung bleibt unverändert.", "success")
|
||||
}
|
||||
s.setFlash(w, "Sondergottesdienst gelöscht.", "success")
|
||||
s.redirectBack(w, r, "/services")
|
||||
// The detail page no longer exists, so always return to the overview and
|
||||
// keep the visible range when the caller supplied one.
|
||||
target := "/plan"
|
||||
if start, end := r.FormValue("start"), r.FormValue("end"); start != "" && end != "" {
|
||||
target += "?start=" + start + "&end=" + end
|
||||
}
|
||||
s.redirect(w, r, target)
|
||||
}
|
||||
|
||||
func (s *Server) handleSpecialServiceSave(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
|
||||
@@ -0,0 +1,553 @@
|
||||
package web
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"lektorenplan/domain"
|
||||
"lektorenplan/store"
|
||||
)
|
||||
|
||||
// readerPairFixture prepares two linked reader accounts and one future
|
||||
// assignment for each of them. The editor logs in after the accounts exist so
|
||||
// that the initial key reconciliation grants every reader their own scope.
|
||||
type readerPairFixture struct {
|
||||
ts *httptest.Server
|
||||
st *store.Store
|
||||
tenantID string
|
||||
editor *http.Client
|
||||
anna *http.Client
|
||||
markus *http.Client
|
||||
annaUser *store.User
|
||||
markUser *store.User
|
||||
annaPass string
|
||||
markPass string
|
||||
annaJob domain.Assignment
|
||||
markJob domain.Assignment
|
||||
annaSvc domain.ServiceOccurrence
|
||||
markSvc domain.ServiceOccurrence
|
||||
}
|
||||
|
||||
// httptestServer was intentionally removed; the fixture uses *httptest.Server.
|
||||
func newReaderPairFixture(t *testing.T) *readerPairFixture {
|
||||
t.Helper()
|
||||
ts, st := newTestServer(t)
|
||||
ctx := context.Background()
|
||||
tenant, err := st.TenantBySlug(ctx, "bad-godesberg")
|
||||
if err != nil {
|
||||
t.Fatalf("tenant: %v", err)
|
||||
}
|
||||
annaUser, err := st.CreateUser(ctx, "anna", "Anna Berg", "annaread123",
|
||||
store.RoleReader, true, []string{tenant.ID})
|
||||
if err != nil {
|
||||
t.Fatalf("create anna: %v", err)
|
||||
}
|
||||
if err := st.SetUserPersonLink(ctx, annaUser.ID, tenant.ID, "p-anna"); err != nil {
|
||||
t.Fatalf("link anna: %v", err)
|
||||
}
|
||||
markusUser, err := st.CreateUser(ctx, "markus", "Markus Weber", "markusread123",
|
||||
store.RoleReader, true, []string{tenant.ID})
|
||||
if err != nil {
|
||||
t.Fatalf("create markus: %v", err)
|
||||
}
|
||||
if err := st.SetUserPersonLink(ctx, markusUser.ID, tenant.ID, "p-markus"); err != nil {
|
||||
t.Fatalf("link markus: %v", err)
|
||||
}
|
||||
|
||||
editor := newClient(t)
|
||||
login(t, editor, ts.URL, "editor", "editor123")
|
||||
anna := newClient(t)
|
||||
login(t, anna, ts.URL, "anna", "annaread123")
|
||||
markus := newClient(t)
|
||||
login(t, markus, ts.URL, "markus", "markusread123")
|
||||
|
||||
fixture := &readerPairFixture{
|
||||
ts: ts, st: st, tenantID: tenant.ID,
|
||||
editor: editor, anna: anna, markus: markus,
|
||||
annaUser: annaUser, markUser: markusUser,
|
||||
annaPass: "annaread1231", markPass: "markusread1231",
|
||||
}
|
||||
|
||||
// The demo seeds a cure for Markus that would hide the next days. Clear
|
||||
// both volunteers so the fixture controls the only absence in a test.
|
||||
for _, personID := range []string{"p-anna", "p-markus"} {
|
||||
absences, err := st.AbsencesForPerson(ctx, tenant.ID, personID)
|
||||
if err != nil {
|
||||
t.Fatalf("absences for %s: %v", personID, err)
|
||||
}
|
||||
for _, absence := range absences {
|
||||
if err := st.DeleteAbsence(ctx, tenant.ID, absence.ID); err != nil {
|
||||
t.Fatalf("delete absence %s: %v", absence.ID, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
annaDate := domain.AddingDays(1, domain.Today())
|
||||
markDate := domain.AddingDays(2, domain.Today())
|
||||
annaServiceID, err := st.UpsertService(ctx, tenant.ID, domain.ServiceOccurrence{
|
||||
ID: "swap-service-anna", ChurchID: "c-andreas", Date: annaDate,
|
||||
TimeMinutes: 9 * 60, Title: "Tauschprobe Anna", Kind: domain.KindSpecial,
|
||||
LectorsNeeded: 1, CreatedAt: time.Now().UTC(),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("create anna service: %v", err)
|
||||
}
|
||||
markServiceID, err := st.UpsertService(ctx, tenant.ID, domain.ServiceOccurrence{
|
||||
ID: "swap-service-markus", ChurchID: "c-evergislus", Date: markDate,
|
||||
TimeMinutes: 10 * 60, Title: "Tauschprobe Markus", Kind: domain.KindSpecial,
|
||||
LectorsNeeded: 1, CreatedAt: time.Now().UTC(),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("create markus service: %v", err)
|
||||
}
|
||||
fixture.annaJob = domain.Assignment{ID: "swap-assignment-anna", ServiceID: annaServiceID,
|
||||
PersonID: "p-anna", Role: domain.RoleLector}
|
||||
fixture.markJob = domain.Assignment{ID: "swap-assignment-markus", ServiceID: markServiceID,
|
||||
PersonID: "p-markus", Role: domain.RoleLector}
|
||||
for _, assignment := range []domain.Assignment{fixture.annaJob, fixture.markJob} {
|
||||
if err := st.UpsertAssignment(ctx, tenant.ID, assignment); err != nil {
|
||||
t.Fatalf("create assignment %s: %v", assignment.ID, err)
|
||||
}
|
||||
}
|
||||
fixture.annaSvc, _ = serviceByID(t, st, tenant.ID, annaServiceID)
|
||||
fixture.markSvc, _ = serviceByID(t, st, tenant.ID, markServiceID)
|
||||
return fixture
|
||||
}
|
||||
|
||||
func serviceByID(t *testing.T, st *store.Store, tenantID, id string) (domain.ServiceOccurrence, bool) {
|
||||
t.Helper()
|
||||
service, err := st.Service(context.Background(), tenantID, id)
|
||||
if err != nil {
|
||||
return domain.ServiceOccurrence{}, false
|
||||
}
|
||||
return *service, true
|
||||
}
|
||||
|
||||
// shareContacts lets owner share their address with the given reader accounts.
|
||||
func shareContacts(t *testing.T, client *http.Client, base string, viewerIDs ...string) {
|
||||
t.Helper()
|
||||
page := get(t, client, base+"/team", http.StatusOK)
|
||||
form := url.Values{"csrf": {extractCSRF(t, page)}}
|
||||
for _, viewerID := range viewerIDs {
|
||||
form.Add("viewer", viewerID)
|
||||
}
|
||||
resp := postForm(t, client, base+"/team/sharing", form)
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusSeeOther {
|
||||
t.Fatalf("save sharing = %d, want 303", resp.StatusCode)
|
||||
}
|
||||
}
|
||||
|
||||
func mutualShares(t *testing.T, f *readerPairFixture) {
|
||||
t.Helper()
|
||||
shareContacts(t, f.anna, f.ts.URL, f.markUser.ID)
|
||||
shareContacts(t, f.markus, f.ts.URL, f.annaUser.ID)
|
||||
}
|
||||
|
||||
func decodeFlash(t *testing.T, resp *http.Response) string {
|
||||
t.Helper()
|
||||
message := ""
|
||||
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)
|
||||
}
|
||||
// A second flash overwrites the first one; the client keeps the last
|
||||
// Set-Cookie value.
|
||||
message = string(data)
|
||||
}
|
||||
return message
|
||||
}
|
||||
|
||||
func TestReaderContactSharingAndRevocation(t *testing.T) {
|
||||
f := newReaderPairFixture(t)
|
||||
|
||||
before := get(t, f.markus, f.ts.URL+"/team", http.StatusOK)
|
||||
if strings.Contains(before, "anna.berg@example.org") {
|
||||
t.Fatal("reader sees an address that was not shared")
|
||||
}
|
||||
|
||||
shareContacts(t, f.anna, f.ts.URL, f.markUser.ID)
|
||||
|
||||
after := get(t, f.markus, f.ts.URL+"/team", http.StatusOK)
|
||||
if !strings.Contains(after, "anna.berg@example.org") {
|
||||
t.Fatal("shared address is not visible to the other reader")
|
||||
}
|
||||
if !strings.Contains(after, "Freigegeben für Sie") {
|
||||
t.Fatal("team page is missing the shared-with-me section")
|
||||
}
|
||||
|
||||
// A shared scope survives the login policy pruning.
|
||||
if err := f.st.PruneUserWrappers(context.Background(), f.markUser.ID); err != nil {
|
||||
t.Fatalf("prune wrappers: %v", err)
|
||||
}
|
||||
scopes, err := f.st.ScopesForUser(context.Background(), f.markUser.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("scopes: %v", err)
|
||||
}
|
||||
if !hasPersonScope(scopes, f.tenantID, "p-anna") {
|
||||
t.Fatal("shared scope was pruned although the consent still exists")
|
||||
}
|
||||
|
||||
// Revoking removes the wrapper and the open session loses the key.
|
||||
shareContacts(t, f.anna, f.ts.URL)
|
||||
|
||||
revoked := get(t, f.markus, f.ts.URL+"/team", http.StatusOK)
|
||||
if strings.Contains(revoked, "anna.berg@example.org") {
|
||||
t.Fatal("address is still visible after revoking the share")
|
||||
}
|
||||
scopes, err = f.st.ScopesForUser(context.Background(), f.markUser.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("scopes after revoke: %v", err)
|
||||
}
|
||||
if hasPersonScope(scopes, f.tenantID, "p-anna") {
|
||||
t.Fatal("revoked scope is still wrapped for the reader")
|
||||
}
|
||||
}
|
||||
|
||||
func hasPersonScope(scopes []store.KeyScope, tenantID, personID string) bool {
|
||||
for _, scope := range scopes {
|
||||
if scope.Type == store.ScopePerson && scope.TenantID == tenantID && scope.ID == personID {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func TestReaderRosterChangeNotice(t *testing.T) {
|
||||
f := newReaderPairFixture(t)
|
||||
|
||||
// One review makes the current reader directory known.
|
||||
shareContacts(t, f.anna, f.ts.URL, f.markUser.ID)
|
||||
page := get(t, f.anna, f.ts.URL+"/team", http.StatusOK)
|
||||
if strings.Contains(page, "hat sich geändert") {
|
||||
t.Fatal("roster notice appears without a roster change")
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
third, err := f.st.CreateUser(ctx, "jonas", "Jonas Schmitz", "jonasread123",
|
||||
store.RoleReader, true, []string{f.tenantID})
|
||||
if err != nil {
|
||||
t.Fatalf("create third reader: %v", err)
|
||||
}
|
||||
if err := f.st.SetUserPersonLink(ctx, third.ID, f.tenantID, "p-johannes"); err != nil {
|
||||
t.Fatalf("link third reader: %v", err)
|
||||
}
|
||||
|
||||
page = get(t, f.anna, f.ts.URL+"/team", http.StatusOK)
|
||||
if !strings.Contains(page, "Die Liste der Leserinnen und Leser hat sich geändert.") {
|
||||
t.Fatal("persistent roster notice is missing")
|
||||
}
|
||||
|
||||
// The hint is repeated as a login flash on the next sign-in.
|
||||
relogin := newClient(t)
|
||||
resp, err := relogin.PostForm(f.ts.URL+"/login", url.Values{
|
||||
"username": {"anna"}, "password": {f.annaPass},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("relogin: %v", err)
|
||||
}
|
||||
resp.Body.Close()
|
||||
flash := decodeFlash(t, resp)
|
||||
if !strings.Contains(flash, "Liste der Lektoren und Kommunionhelfer hat sich geändert") {
|
||||
t.Fatalf("login flash = %q, want roster notice", flash)
|
||||
}
|
||||
|
||||
// Acknowledging keeps the existing shares but silences the notice.
|
||||
page = get(t, relogin, f.ts.URL+"/team", http.StatusOK)
|
||||
csrf := extractCSRF(t, page)
|
||||
ack := postForm(t, relogin, f.ts.URL+"/team/sharing/ack", url.Values{"csrf": {csrf}})
|
||||
ack.Body.Close()
|
||||
if ack.StatusCode != http.StatusSeeOther {
|
||||
t.Fatalf("ack = %d, want 303", ack.StatusCode)
|
||||
}
|
||||
page = get(t, relogin, f.ts.URL+"/team", http.StatusOK)
|
||||
if strings.Contains(page, "Die Liste der Leserinnen und Leser hat sich geändert.") {
|
||||
t.Fatal("roster notice is still shown after acknowledgement")
|
||||
}
|
||||
if !f.st.ContactShareExists(context.Background(), f.tenantID, "p-anna", f.markUser.ID) {
|
||||
t.Fatal("acknowledging the roster dropped the existing share")
|
||||
}
|
||||
}
|
||||
|
||||
func createSwapRequest(t *testing.T, f *readerPairFixture) (requestID, token string) {
|
||||
t.Helper()
|
||||
page := get(t, f.anna, f.ts.URL+"/swap/new?assignment="+f.markJob.ID, http.StatusOK)
|
||||
if !strings.Contains(page, f.markJob.ID) {
|
||||
t.Fatalf("request page does not describe the wanted assignment:\n%s", page)
|
||||
}
|
||||
if !strings.Contains(page, f.annaJob.ID) {
|
||||
t.Fatal("request page does not offer the own assignment")
|
||||
}
|
||||
csrf := extractCSRF(t, page)
|
||||
resp := postForm(t, f.anna, f.ts.URL+"/swap/request", url.Values{
|
||||
"csrf": {csrf},
|
||||
"wanted": {f.markJob.ID},
|
||||
"offered": {f.annaJob.ID},
|
||||
})
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusSeeOther {
|
||||
t.Fatalf("create swap = %d, want 303", resp.StatusCode)
|
||||
}
|
||||
location := resp.Header.Get("Location")
|
||||
parsed, err := url.Parse(location)
|
||||
if err != nil {
|
||||
t.Fatalf("parse redirect %q: %v", location, err)
|
||||
}
|
||||
requestID = strings.TrimPrefix(parsed.Path, "/swap/requests/")
|
||||
token = parsed.Query().Get("token")
|
||||
if requestID == "" || token == "" {
|
||||
t.Fatalf("redirect %q is missing request id or token", location)
|
||||
}
|
||||
return requestID, token
|
||||
}
|
||||
|
||||
func TestSwapRequestLifecycle(t *testing.T) {
|
||||
f := newReaderPairFixture(t)
|
||||
mutualShares(t, f)
|
||||
|
||||
// The reader sees a request button next to the other reader's assignment.
|
||||
detail := get(t, f.anna, f.ts.URL+"/services/"+f.markSvc.ID, http.StatusOK)
|
||||
if !strings.Contains(detail, "/swap/new?assignment="+f.markJob.ID) {
|
||||
t.Fatal("service view is missing the swap request button")
|
||||
}
|
||||
|
||||
requestID, token := createSwapRequest(t, f)
|
||||
|
||||
page := get(t, f.anna, f.ts.URL+"/swap/requests/"+requestID+"?token="+url.QueryEscape(token), http.StatusOK)
|
||||
if !strings.Contains(page, "markus.weber@example.org") {
|
||||
t.Fatal("request page does not offer a mail draft to the target address")
|
||||
}
|
||||
if strings.Count(page, token) < 2 || !strings.Contains(page, "Annehmen") || !strings.Contains(page, "Ablehnen") {
|
||||
t.Fatal("request mail draft is missing the accept and decline links")
|
||||
}
|
||||
|
||||
marks, err := f.st.PendingSwapAssignmentIDs(context.Background(), f.tenantID)
|
||||
if err != nil {
|
||||
t.Fatalf("pending marks: %v", err)
|
||||
}
|
||||
if marks[f.annaJob.ID] == "" || marks[f.markJob.ID] == "" {
|
||||
t.Fatal("both assignments must be marked as swap-requested")
|
||||
}
|
||||
plan := get(t, f.anna, f.ts.URL+"/plan?start="+domain.Key(domain.Today())+
|
||||
"&end="+domain.Key(domain.AddingDays(10, domain.Today())), http.StatusOK)
|
||||
if !strings.Contains(plan, "Tausch angefragt") {
|
||||
t.Fatal("plan does not mark the pending swap")
|
||||
}
|
||||
|
||||
// The target can confirm and accept the swap.
|
||||
targetPage := get(t, f.markus, f.ts.URL+"/swap/"+token, http.StatusOK)
|
||||
if !strings.Contains(targetPage, "Möchten Sie tauschen?") {
|
||||
t.Fatal("target does not see the response controls")
|
||||
}
|
||||
confirm := get(t, f.markus, f.ts.URL+"/swap/"+token+"/accept", http.StatusOK)
|
||||
if !strings.Contains(confirm, "Tausch annehmen?") {
|
||||
t.Fatal("accept confirmation page is missing")
|
||||
}
|
||||
csrf := extractCSRF(t, confirm)
|
||||
response := postForm(t, f.markus, f.ts.URL+"/swap/"+token+"/respond", url.Values{
|
||||
"csrf": {csrf},
|
||||
"action": {"accept"},
|
||||
})
|
||||
response.Body.Close()
|
||||
if response.StatusCode != http.StatusSeeOther {
|
||||
t.Fatalf("accept = %d, want 303", response.StatusCode)
|
||||
}
|
||||
|
||||
if !personHasAssignment(t, f.st, f.tenantID, "p-anna", f.markSvc.ID) {
|
||||
t.Fatal("anna did not receive the wanted assignment")
|
||||
}
|
||||
if !personHasAssignment(t, f.st, f.tenantID, "p-markus", f.annaSvc.ID) {
|
||||
t.Fatal("markus did not receive the offered assignment")
|
||||
}
|
||||
if assignmentPerson(t, f.st, f.tenantID, f.annaJob.ID) != "p-markus" {
|
||||
t.Fatal("offered assignment was not transferred")
|
||||
}
|
||||
if assignmentPerson(t, f.st, f.tenantID, f.markJob.ID) != "p-anna" {
|
||||
t.Fatal("wanted assignment was not transferred")
|
||||
}
|
||||
|
||||
marks, err = f.st.PendingSwapAssignmentIDs(context.Background(), f.tenantID)
|
||||
if err != nil {
|
||||
t.Fatalf("pending marks after accept: %v", err)
|
||||
}
|
||||
if marks[f.annaJob.ID] != "" || marks[f.markJob.ID] != "" {
|
||||
t.Fatal("accepted swap is still marked as pending")
|
||||
}
|
||||
|
||||
// The target receives a response draft addressed to the requester.
|
||||
result := get(t, f.markus, f.ts.URL+"/swap/"+token, http.StatusOK)
|
||||
if !strings.Contains(result, "Antwort-E-Mail öffnen") {
|
||||
t.Fatal("accepted request has no response mail draft")
|
||||
}
|
||||
if !strings.Contains(result, "anna.berg@example.org") {
|
||||
t.Fatal("response draft does not use the requester address")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSwapDeclineKeepsPlan(t *testing.T) {
|
||||
f := newReaderPairFixture(t)
|
||||
mutualShares(t, f)
|
||||
_, token := createSwapRequest(t, f)
|
||||
|
||||
confirm := get(t, f.markus, f.ts.URL+"/swap/"+token+"/decline", http.StatusOK)
|
||||
if !strings.Contains(confirm, "Tausch ablehnen?") {
|
||||
t.Fatal("decline confirmation page is missing")
|
||||
}
|
||||
csrf := extractCSRF(t, confirm)
|
||||
response := postForm(t, f.markus, f.ts.URL+"/swap/"+token+"/respond", url.Values{
|
||||
"csrf": {csrf},
|
||||
"action": {"decline"},
|
||||
})
|
||||
response.Body.Close()
|
||||
if response.StatusCode != http.StatusSeeOther {
|
||||
t.Fatalf("decline = %d, want 303", response.StatusCode)
|
||||
}
|
||||
|
||||
if assignmentPerson(t, f.st, f.tenantID, f.annaJob.ID) != "p-anna" {
|
||||
t.Fatal("decline changed the offered assignment")
|
||||
}
|
||||
if assignmentPerson(t, f.st, f.tenantID, f.markJob.ID) != "p-markus" {
|
||||
t.Fatal("decline changed the wanted assignment")
|
||||
}
|
||||
marks, err := f.st.PendingSwapAssignmentIDs(context.Background(), f.tenantID)
|
||||
if err != nil {
|
||||
t.Fatalf("pending marks: %v", err)
|
||||
}
|
||||
if marks[f.annaJob.ID] != "" || marks[f.markJob.ID] != "" {
|
||||
t.Fatal("declined swap is still marked as pending")
|
||||
}
|
||||
result := get(t, f.markus, f.ts.URL+"/swap/"+token, http.StatusOK)
|
||||
if !strings.Contains(result, "Abgelehnt") && !strings.Contains(result, "abgelehnt") {
|
||||
t.Fatal("result page does not show the declined state")
|
||||
}
|
||||
if !strings.Contains(result, "Antwort-E-Mail öffnen") {
|
||||
t.Fatal("declined request has no response mail draft")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAcceptRevalidatesAbsence(t *testing.T) {
|
||||
f := newReaderPairFixture(t)
|
||||
mutualShares(t, f)
|
||||
_, token := createSwapRequest(t, f)
|
||||
|
||||
ctx := context.Background()
|
||||
if err := f.st.UpsertAbsence(ctx, f.tenantID, domain.Absence{
|
||||
ID: "late-absence", PersonID: "p-markus",
|
||||
Start: f.annaSvc.Date, End: f.annaSvc.Date, Reason: "Kurzfristig krank",
|
||||
}); err != nil {
|
||||
t.Fatalf("create absence: %v", err)
|
||||
}
|
||||
|
||||
if _, err := f.st.RespondSwapRequest(ctx, f.tenantID, token, f.markUser.ID, true); err == nil ||
|
||||
!strings.Contains(err.Error(), "abwesend") {
|
||||
t.Fatalf("accept error = %v, want absence rejection", err)
|
||||
}
|
||||
if assignmentPerson(t, f.st, f.tenantID, f.annaJob.ID) != "p-anna" {
|
||||
t.Fatal("rejected acceptance still moved the offered assignment")
|
||||
}
|
||||
if assignmentPerson(t, f.st, f.tenantID, f.markJob.ID) != "p-markus" {
|
||||
t.Fatal("rejected acceptance still moved the wanted assignment")
|
||||
}
|
||||
marks, err := f.st.PendingSwapAssignmentIDs(ctx, f.tenantID)
|
||||
if err != nil {
|
||||
t.Fatalf("pending marks: %v", err)
|
||||
}
|
||||
if marks[f.annaJob.ID] == "" || marks[f.markJob.ID] == "" {
|
||||
t.Fatal("open request lost its plan marks after a rejected acceptance")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRevokingConsentCancelsPendingSwap(t *testing.T) {
|
||||
f := newReaderPairFixture(t)
|
||||
mutualShares(t, f)
|
||||
requestID, _ := createSwapRequest(t, f)
|
||||
|
||||
// Anna revokes the share; the pending request can no longer be answered
|
||||
// and the plan markers must disappear.
|
||||
shareContacts(t, f.anna, f.ts.URL)
|
||||
|
||||
request, err := f.st.SwapRequestByID(context.Background(), f.tenantID, requestID)
|
||||
if err != nil {
|
||||
t.Fatalf("load request: %v", err)
|
||||
}
|
||||
if request.Status != store.SwapCancelled {
|
||||
t.Fatalf("request status = %q, want cancelled", request.Status)
|
||||
}
|
||||
marks, err := f.st.PendingSwapAssignmentIDs(context.Background(), f.tenantID)
|
||||
if err != nil {
|
||||
t.Fatalf("pending marks: %v", err)
|
||||
}
|
||||
if marks[f.annaJob.ID] != "" || marks[f.markJob.ID] != "" {
|
||||
t.Fatal("cancelled swap is still marked as pending")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSwapRequestRequiresMutualConsent(t *testing.T) {
|
||||
f := newReaderPairFixture(t)
|
||||
// Only the requester shares; the target has not shared the other way.
|
||||
shareContacts(t, f.anna, f.ts.URL, f.markUser.ID)
|
||||
|
||||
get(t, f.anna, f.ts.URL+"/swap/new?assignment="+f.markJob.ID, http.StatusForbidden)
|
||||
page := get(t, f.anna, f.ts.URL+"/services/"+f.markSvc.ID, http.StatusOK)
|
||||
if strings.Contains(page, "/swap/new?assignment="+f.markJob.ID) {
|
||||
t.Fatal("swap button is offered without mutual consent")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSwapRejectsAbsence(t *testing.T) {
|
||||
f := newReaderPairFixture(t)
|
||||
mutualShares(t, f)
|
||||
ctx := context.Background()
|
||||
if err := f.st.UpsertAbsence(ctx, f.tenantID, domain.Absence{
|
||||
ID: "swap-absence", PersonID: "p-markus",
|
||||
Start: f.annaSvc.Date, End: f.annaSvc.Date, Reason: "Testabwesenheit",
|
||||
}); err != nil {
|
||||
t.Fatalf("create absence: %v", err)
|
||||
}
|
||||
|
||||
_, _, err := f.st.CreateSwapRequest(ctx, f.tenantID, f.annaUser.ID,
|
||||
"p-anna", f.markUser.ID, "p-markus", f.annaJob.ID, f.markJob.ID)
|
||||
if err == nil || !strings.Contains(err.Error(), "abwesend") {
|
||||
t.Fatalf("swap request error = %v, want absence rejection", err)
|
||||
}
|
||||
options, err := f.st.SwapOptions(ctx, f.tenantID, "p-anna", "p-markus", f.markJob.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("swap options: %v", err)
|
||||
}
|
||||
if len(options) != 0 {
|
||||
t.Fatalf("swap options = %d, want none while the target is absent", len(options))
|
||||
}
|
||||
}
|
||||
|
||||
func personHasAssignment(t *testing.T, st *store.Store, tenantID, personID, serviceID string) bool {
|
||||
t.Helper()
|
||||
assignments, err := st.AssignmentsForPerson(context.Background(), tenantID, personID)
|
||||
if err != nil {
|
||||
t.Fatalf("assignments for %s: %v", personID, err)
|
||||
}
|
||||
for _, assignment := range assignments {
|
||||
if assignment.ServiceID == serviceID {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func assignmentPerson(t *testing.T, st *store.Store, tenantID, assignmentID string) string {
|
||||
t.Helper()
|
||||
info, err := st.SwapAssignmentInfo(context.Background(), tenantID, assignmentID)
|
||||
if err != nil {
|
||||
t.Fatalf("assignment %s: %v", assignmentID, err)
|
||||
}
|
||||
return info.Assignment.PersonID
|
||||
}
|
||||
@@ -50,6 +50,8 @@
|
||||
show = parseInt(row.getAttribute("data-open") || "0", 10) > 0;
|
||||
} else if (filter === "feasts") {
|
||||
show = row.getAttribute("data-special") === "true";
|
||||
} else if (filter === "beyond") {
|
||||
show = row.getAttribute("data-beyond") === "true";
|
||||
}
|
||||
row.hidden = !show;
|
||||
if (show) visible++;
|
||||
|
||||
@@ -963,3 +963,97 @@ hr { border: 0; border-top: 1px solid var(--line); margin: 1rem 0; }
|
||||
@media (prefers-reduced-motion: reduce) {
|
||||
* { transition: none !important; animation: none !important; }
|
||||
}
|
||||
|
||||
/* E-Mail-Freigaben und Tauschanfragen ------------------------------------- */
|
||||
.sharing-card { display: flex; flex-direction: column; gap: .9rem; }
|
||||
.sharing-intro { margin: 0; color: var(--ink-soft, #6b6257); line-height: 1.55; }
|
||||
.sharing-notice {
|
||||
display: flex; align-items: flex-start; justify-content: space-between; gap: 1rem;
|
||||
padding: .9rem 1rem; border-radius: 12px;
|
||||
background: color-mix(in srgb, #c2a14d 16%, transparent);
|
||||
border: 1px solid color-mix(in srgb, #c2a14d 42%, transparent);
|
||||
}
|
||||
.sharing-notice p { margin: .25rem 0 0; color: var(--ink-soft, #6b6257); }
|
||||
.sharing-form { display: flex; flex-direction: column; gap: .8rem; }
|
||||
.sharing-all { padding-bottom: .6rem; border-bottom: 1px dashed color-mix(in srgb, #6b6257 22%, transparent); }
|
||||
.sharing-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: .35rem .9rem; }
|
||||
.sharing-grid .check small { color: var(--ink-soft, #6b6257); }
|
||||
.sharing-people { display: flex; flex-direction: column; gap: .55rem; }
|
||||
.sharing-person {
|
||||
display: flex; align-items: center; gap: .65rem; flex-wrap: wrap;
|
||||
padding: .55rem .7rem; border-radius: 10px;
|
||||
background: color-mix(in srgb, #2e5c57 6%, transparent);
|
||||
}
|
||||
.sharing-person-name { display: flex; flex-direction: column; min-width: 140px; }
|
||||
.sharing-person-name small { color: var(--ink-soft, #6b6257); }
|
||||
.sharing-person a { margin-left: auto; }
|
||||
.swap-panel .swap-assignment { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: .8rem; }
|
||||
.swap-assignment > div { display: flex; flex-direction: column; gap: .15rem; }
|
||||
.swap-assignment span { color: var(--ink-soft, #6b6257); }
|
||||
.swap-option-list { display: flex; flex-direction: column; gap: .45rem; }
|
||||
.swap-option {
|
||||
display: flex; align-items: center; gap: .7rem;
|
||||
padding: .65rem .8rem; border: 1px solid color-mix(in srgb, #6b6257 22%, transparent);
|
||||
border-radius: 10px; cursor: pointer;
|
||||
}
|
||||
.swap-option:has(input:checked) { border-color: #2e5c57; background: color-mix(in srgb, #2e5c57 7%, transparent); }
|
||||
.swap-option-main { display: flex; flex-direction: column; flex: 1; }
|
||||
.swap-option-main span { color: var(--ink-soft, #6b6257); }
|
||||
.swap-compare { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 1rem; }
|
||||
.swap-actions { display: flex; flex-wrap: wrap; gap: .6rem; }
|
||||
.swap-action-card { display: flex; flex-direction: column; gap: .5rem; }
|
||||
.swap-action-card p { margin: 0; color: var(--ink-soft, #6b6257); }
|
||||
.mail-card { border-color: color-mix(in srgb, #2e5c57 30%, transparent); }
|
||||
.person-chip.swap-pending { outline: 1px dashed #b0833c; outline-offset: 1px; }
|
||||
.swap-mark { margin-right: .15rem; color: #b0833c; font-weight: 700; }
|
||||
@media (max-width: 760px) {
|
||||
.swap-panel .swap-assignment, .swap-compare { grid-template-columns: 1fr; }
|
||||
.sharing-notice { flex-direction: column; }
|
||||
}
|
||||
|
||||
/* Präferenzen: Tageszeiten, Kürzel und Planung über Präferenzen hinaus */
|
||||
.weekday-preference { display: flex; align-items: center; gap: .3rem; }
|
||||
.weekday-period {
|
||||
font-size: .66rem; padding: .22rem .3rem; border-radius: 6px;
|
||||
border: 1px solid color-mix(in srgb, #6b6257 25%, transparent);
|
||||
background: #fffdf7; color: var(--ink, #332f2a);
|
||||
}
|
||||
.person-note {
|
||||
display: block; margin-top: .15rem; font-size: .68rem; line-height: 1.35;
|
||||
color: var(--ink-soft, #6b6257); font-style: italic;
|
||||
}
|
||||
.candidate .person-note { max-width: 34rem; }
|
||||
.person-chip.beyond-pref {
|
||||
background: color-mix(in srgb, #8d3b4a 16%, #fffdf7);
|
||||
color: var(--burgundy, #8d3b4a);
|
||||
outline: 1px dashed color-mix(in srgb, #8d3b4a 55%, transparent);
|
||||
outline-offset: 1px;
|
||||
}
|
||||
.beyond-mark { margin-right: .15rem; font-weight: 800; color: var(--burgundy, #8d3b4a); }
|
||||
.beyond-prompt {
|
||||
display: flex; align-items: center; justify-content: space-between; gap: 1.2rem;
|
||||
flex-wrap: wrap; border-color: color-mix(in srgb, #b0833c 45%, transparent);
|
||||
background: color-mix(in srgb, #c2a14d 10%, #fffdf7);
|
||||
}
|
||||
.beyond-prompt h3 { margin: .15rem 0 .35rem; }
|
||||
.beyond-prompt p { margin: 0; max-width: 62ch; color: var(--ink-soft, #6b6257); }
|
||||
.service-card-wrap { position: relative; }
|
||||
.service-delete-form { position: absolute; top: -2px; right: -2px; }
|
||||
.service-delete {
|
||||
opacity: 0; transition: opacity .12s ease; width: 1.25rem; height: 1.25rem;
|
||||
background: color-mix(in srgb, #fffdf7 88%, transparent);
|
||||
}
|
||||
.service-card-wrap:hover .service-delete, .service-delete:focus-visible { opacity: 1; }
|
||||
.col-day-action { width: 2.2rem; }
|
||||
.day-action { text-align: right; vertical-align: top; padding-top: .55rem; }
|
||||
.day-special-add { width: 1.55rem; height: 1.55rem; color: var(--burgundy, #8d3b4a); }
|
||||
.day-special-add-mobile { margin-bottom: .55rem; }
|
||||
.icon-button.is-disabled { opacity: .35; pointer-events: none; }
|
||||
.visually-hidden {
|
||||
position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px;
|
||||
overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; border: 0;
|
||||
}
|
||||
@media (max-width: 760px) {
|
||||
.beyond-prompt { flex-direction: column; align-items: flex-start; }
|
||||
.service-delete { opacity: 1; }
|
||||
}
|
||||
@@ -0,0 +1,387 @@
|
||||
package web
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
|
||||
"lektorenplan/domain"
|
||||
"lektorenplan/store"
|
||||
)
|
||||
|
||||
type swapAssignmentView struct {
|
||||
Assignment domain.Assignment
|
||||
Service domain.ServiceOccurrence
|
||||
Church domain.Church
|
||||
}
|
||||
|
||||
func (v swapAssignmentView) Exists() bool { return v.Assignment.ID != "" }
|
||||
|
||||
type swapRequestPageData struct {
|
||||
Request *store.SwapRequest
|
||||
Token string
|
||||
RequesterPerson domain.Person
|
||||
TargetPerson domain.Person
|
||||
Offered swapAssignmentView
|
||||
Wanted swapAssignmentView
|
||||
StatusLabel string
|
||||
CanRespond bool
|
||||
Action string
|
||||
ShowRequestMail bool
|
||||
RequestMailto string
|
||||
ResponseMailto string
|
||||
ResponseUnavailable bool
|
||||
}
|
||||
|
||||
type swapNewPageData struct {
|
||||
Requester domain.Person
|
||||
Target domain.Person
|
||||
Wanted swapAssignmentView
|
||||
Options []swapAssignmentView
|
||||
}
|
||||
|
||||
func (s *Server) swapReader(user *store.User, tenant *store.Tenant) (string, bool) {
|
||||
if tenant == nil || user == nil || user.Role != store.RoleReader {
|
||||
return "", false
|
||||
}
|
||||
return user.LinkedPerson(tenant.ID)
|
||||
}
|
||||
|
||||
func (s *Server) swapView(ctx context.Context, tenantID string, info store.SwapAssignmentInfo) swapAssignmentView {
|
||||
view := swapAssignmentView{Assignment: info.Assignment, Service: info.Service}
|
||||
if church, err := s.store.Church(ctx, tenantID, info.Service.ChurchID); err == nil {
|
||||
view.Church = *church
|
||||
} else {
|
||||
view.Church = domain.Church{ID: info.Service.ChurchID, Name: "Unbekannte Kirche"}
|
||||
}
|
||||
return view
|
||||
}
|
||||
|
||||
func (s *Server) swapConsent(ctx context.Context, tenantID, requesterUserID, requesterPersonID, targetUserID, targetPersonID string) bool {
|
||||
return s.store.ContactShareExists(ctx, tenantID, targetPersonID, requesterUserID) &&
|
||||
s.store.ContactShareExists(ctx, tenantID, requesterPersonID, targetUserID)
|
||||
}
|
||||
|
||||
func (s *Server) swapRequestTarget(ctx context.Context, tenantID, personID string) (string, bool) {
|
||||
return s.store.ReaderForPerson(ctx, tenantID, personID)
|
||||
}
|
||||
|
||||
func (s *Server) handleSwapNew(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
if tenant == nil {
|
||||
s.renderNoTenant(w, r)
|
||||
return
|
||||
}
|
||||
requesterPersonID, ok := s.swapReader(user, tenant)
|
||||
if !ok {
|
||||
s.renderError(w, r, http.StatusForbidden, "Tausch",
|
||||
"Nur verknüpfte Leser-Konten können Einsätze tauschen.")
|
||||
return
|
||||
}
|
||||
wantedID := strings.TrimSpace(r.URL.Query().Get("assignment"))
|
||||
// Load the wanted assignment first to determine the target person, then
|
||||
// compute the selectable own assignments.
|
||||
wantedInfo, err := s.store.SwapAssignmentInfo(r.Context(), tenant.ID, wantedID)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusNotFound, "Tausch", "Dieser Einsatz wurde nicht gefunden.")
|
||||
return
|
||||
}
|
||||
targetUserID, ok := s.swapRequestTarget(r.Context(), tenant.ID, wantedInfo.Assignment.PersonID)
|
||||
if !ok {
|
||||
s.renderError(w, r, http.StatusConflict, "Tausch",
|
||||
"Für die angefragte Person ist kein Leser-Konto verknüpft.")
|
||||
return
|
||||
}
|
||||
if !s.swapConsent(r.Context(), tenant.ID, user.ID, requesterPersonID, targetUserID, wantedInfo.Assignment.PersonID) {
|
||||
s.renderError(w, r, http.StatusForbidden, "Tausch",
|
||||
"Für eine Tauschanfrage müssen beide Seiten ihre E-Mail-Adresse gegenseitig freigegeben haben. "+
|
||||
"Prüfen Sie die Einstellungen unter „Team & Abwesenheiten“.")
|
||||
return
|
||||
}
|
||||
options, err := s.store.SwapOptions(r.Context(), tenant.ID, requesterPersonID,
|
||||
wantedInfo.Assignment.PersonID, wantedID)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusConflict, "Tausch", err.Error())
|
||||
return
|
||||
}
|
||||
requester, err := s.store.Person(r.Context(), tenant.ID, requesterPersonID)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusInternalServerError, "Tausch", err.Error())
|
||||
return
|
||||
}
|
||||
target, err := s.store.Person(r.Context(), tenant.ID, wantedInfo.Assignment.PersonID)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusInternalServerError, "Tausch", err.Error())
|
||||
return
|
||||
}
|
||||
page := swapNewPageData{
|
||||
Requester: *requester,
|
||||
Target: *target,
|
||||
Wanted: s.swapView(r.Context(), tenant.ID, *wantedInfo),
|
||||
}
|
||||
for _, option := range options {
|
||||
page.Options = append(page.Options, s.swapView(r.Context(), tenant.ID, option))
|
||||
}
|
||||
data := s.baseView(w, r, "Tausch anfragen", "team")
|
||||
data.Data = page
|
||||
s.renderPage(w, r, "swap_request", data)
|
||||
}
|
||||
|
||||
func (s *Server) handleSwapRequestCreate(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
if tenant == nil {
|
||||
s.renderNoTenant(w, r)
|
||||
return
|
||||
}
|
||||
requesterPersonID, ok := s.swapReader(user, tenant)
|
||||
if !ok {
|
||||
s.renderError(w, r, http.StatusForbidden, "Tausch",
|
||||
"Nur verknüpfte Leser-Konten können Einsätze tauschen.")
|
||||
return
|
||||
}
|
||||
wantedID := strings.TrimSpace(r.FormValue("wanted"))
|
||||
offeredID := strings.TrimSpace(r.FormValue("offered"))
|
||||
wantedInfo, err := s.store.SwapAssignmentInfo(r.Context(), tenant.ID, wantedID)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusNotFound, "Tausch", "Der gewünschte Einsatz wurde nicht gefunden.")
|
||||
return
|
||||
}
|
||||
if wantedInfo.Assignment.PersonID == requesterPersonID {
|
||||
s.renderError(w, r, http.StatusBadRequest, "Tausch", "Ein Tausch mit sich selbst ist nicht möglich.")
|
||||
return
|
||||
}
|
||||
targetUserID, ok := s.swapRequestTarget(r.Context(), tenant.ID, wantedInfo.Assignment.PersonID)
|
||||
if !ok {
|
||||
s.renderError(w, r, http.StatusConflict, "Tausch",
|
||||
"Für die angefragte Person ist kein Leser-Konto verknüpft.")
|
||||
return
|
||||
}
|
||||
if !s.swapConsent(r.Context(), tenant.ID, user.ID, requesterPersonID, targetUserID, wantedInfo.Assignment.PersonID) {
|
||||
s.renderError(w, r, http.StatusForbidden, "Tausch",
|
||||
"Für eine Tauschanfrage müssen beide Seiten ihre E-Mail-Adresse gegenseitig freigegeben haben.")
|
||||
return
|
||||
}
|
||||
request, token, err := s.store.CreateSwapRequest(r.Context(), tenant.ID, user.ID,
|
||||
requesterPersonID, targetUserID, wantedInfo.Assignment.PersonID, offeredID, wantedID)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusConflict, "Tausch", err.Error())
|
||||
return
|
||||
}
|
||||
s.redirect(w, r, "/swap/requests/"+request.ID+"?token="+url.QueryEscape(token))
|
||||
}
|
||||
|
||||
func (s *Server) handleSwapRequestView(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
if tenant == nil {
|
||||
s.renderNoTenant(w, r)
|
||||
return
|
||||
}
|
||||
request, err := s.store.SwapRequestByID(r.Context(), tenant.ID, r.PathValue("id"))
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusNotFound, "Tausch", "Diese Tauschanfrage wurde nicht gefunden.")
|
||||
return
|
||||
}
|
||||
if request.RequesterUserID != user.ID && request.TargetUserID != user.ID {
|
||||
s.renderError(w, r, http.StatusForbidden, "Tausch", "Diese Tauschanfrage gehört nicht zu Ihrem Konto.")
|
||||
return
|
||||
}
|
||||
token := strings.TrimSpace(r.URL.Query().Get("token"))
|
||||
if token != "" && store.SwapTokenMatches(request, token) {
|
||||
s.renderSwapPage(w, r, user, tenant, request, token, "")
|
||||
return
|
||||
}
|
||||
s.renderSwapPage(w, r, user, tenant, request, "", "")
|
||||
}
|
||||
|
||||
func (s *Server) handleSwapTokenView(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
if tenant == nil {
|
||||
s.renderNoTenant(w, r)
|
||||
return
|
||||
}
|
||||
token := strings.TrimSpace(r.PathValue("token"))
|
||||
request, err := s.store.SwapRequestByToken(r.Context(), tenant.ID, token)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusNotFound, "Tausch", "Diese Tauschanfrage wurde nicht gefunden oder ist abgelaufen.")
|
||||
return
|
||||
}
|
||||
if request.RequesterUserID != user.ID && request.TargetUserID != user.ID {
|
||||
s.renderError(w, r, http.StatusForbidden, "Tausch", "Diese Tauschanfrage gehört nicht zu Ihrem Konto.")
|
||||
return
|
||||
}
|
||||
s.renderSwapPage(w, r, user, tenant, request, token, "")
|
||||
}
|
||||
|
||||
func (s *Server) handleSwapTokenAction(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
if tenant == nil {
|
||||
s.renderNoTenant(w, r)
|
||||
return
|
||||
}
|
||||
action := strings.TrimSpace(r.PathValue("action"))
|
||||
if action != "accept" && action != "decline" {
|
||||
s.renderError(w, r, http.StatusNotFound, "Tausch", "Unbekannte Aktion.")
|
||||
return
|
||||
}
|
||||
token := strings.TrimSpace(r.PathValue("token"))
|
||||
request, err := s.store.SwapRequestByToken(r.Context(), tenant.ID, token)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusNotFound, "Tausch", "Diese Tauschanfrage wurde nicht gefunden oder ist abgelaufen.")
|
||||
return
|
||||
}
|
||||
if request.TargetUserID != user.ID {
|
||||
s.renderError(w, r, http.StatusForbidden, "Tausch", "Diese Tauschanfrage richtet sich an ein anderes Konto.")
|
||||
return
|
||||
}
|
||||
if request.Status != store.SwapPending {
|
||||
s.setFlash(w, "Diese Tauschanfrage ist bereits "+store.SwapStatusLabel(request.Status)+".", "info")
|
||||
s.redirect(w, r, "/swap/"+token)
|
||||
return
|
||||
}
|
||||
s.renderSwapPage(w, r, user, tenant, request, token, action)
|
||||
}
|
||||
|
||||
func (s *Server) handleSwapRespond(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
if tenant == nil {
|
||||
s.renderNoTenant(w, r)
|
||||
return
|
||||
}
|
||||
token := strings.TrimSpace(r.PathValue("token"))
|
||||
action := strings.TrimSpace(r.FormValue("action"))
|
||||
if action != "accept" && action != "decline" {
|
||||
s.renderError(w, r, http.StatusBadRequest, "Tausch", "Unbekannte Aktion.")
|
||||
return
|
||||
}
|
||||
request, err := s.store.SwapRequestByToken(r.Context(), tenant.ID, token)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusNotFound, "Tausch", "Diese Tauschanfrage wurde nicht gefunden oder ist abgelaufen.")
|
||||
return
|
||||
}
|
||||
if request.TargetUserID != user.ID {
|
||||
s.renderError(w, r, http.StatusForbidden, "Tausch", "Diese Tauschanfrage richtet sich an ein anderes Konto.")
|
||||
return
|
||||
}
|
||||
if _, err := s.store.RespondSwapRequest(r.Context(), tenant.ID, token, user.ID, action == "accept"); err != nil {
|
||||
s.setFlash(w, "Die Tauschanfrage konnte nicht beantwortet werden: "+err.Error(), "error")
|
||||
s.redirect(w, r, "/swap/"+token)
|
||||
return
|
||||
}
|
||||
if action == "accept" {
|
||||
s.setFlash(w, "Der Tausch wurde durchgeführt. Der Plan ist aktualisiert.", "success")
|
||||
} else {
|
||||
s.setFlash(w, "Die Tauschanfrage wurde abgelehnt. Der Plan bleibt unverändert.", "success")
|
||||
}
|
||||
s.redirect(w, r, "/swap/"+token)
|
||||
}
|
||||
|
||||
func (s *Server) renderSwapPage(w http.ResponseWriter, r *http.Request, user *store.User, tenant *store.Tenant, request *store.SwapRequest, token, action string) {
|
||||
requester, requesterErr := s.store.Person(r.Context(), tenant.ID, request.RequesterPersonID)
|
||||
target, targetErr := s.store.Person(r.Context(), tenant.ID, request.TargetPersonID)
|
||||
if requesterErr != nil || targetErr != nil {
|
||||
s.renderError(w, r, http.StatusNotFound, "Tausch", "Die an der Tauschanfrage beteiligten Personen wurden nicht gefunden.")
|
||||
return
|
||||
}
|
||||
page := swapRequestPageData{
|
||||
Request: request,
|
||||
Token: token,
|
||||
RequesterPerson: *requester,
|
||||
TargetPerson: *target,
|
||||
StatusLabel: store.SwapStatusLabel(request.Status),
|
||||
Action: action,
|
||||
}
|
||||
if offered, err := s.store.SwapAssignmentInfo(r.Context(), tenant.ID, request.OfferedAssignmentID); err == nil {
|
||||
page.Offered = s.swapView(r.Context(), tenant.ID, *offered)
|
||||
}
|
||||
if wanted, err := s.store.SwapAssignmentInfo(r.Context(), tenant.ID, request.WantedAssignmentID); err == nil {
|
||||
page.Wanted = s.swapView(r.Context(), tenant.ID, *wanted)
|
||||
}
|
||||
isRequester := request.RequesterUserID == user.ID
|
||||
isTarget := request.TargetUserID == user.ID
|
||||
page.CanRespond = isTarget && request.Status == store.SwapPending && token != ""
|
||||
|
||||
if isRequester && request.Status == store.SwapPending && token != "" && target.Email != "" {
|
||||
page.ShowRequestMail = true
|
||||
acceptURL := s.absoluteURL(r, "/swap/"+token+"/accept")
|
||||
declineURL := s.absoluteURL(r, "/swap/"+token+"/decline")
|
||||
subject := "Tauschanfrage: " + swapAssignmentSummary(page.Offered)
|
||||
body := swapRequestEmailBody(*requester, *target, page.Offered, page.Wanted, acceptURL, declineURL)
|
||||
page.RequestMailto = dispatchMailto(target.Email, subject, body)
|
||||
}
|
||||
if isTarget && (request.Status == store.SwapAccepted || request.Status == store.SwapDeclined) {
|
||||
if requester.Email != "" {
|
||||
subject := "Antwort auf die Tauschanfrage: " + swapAssignmentSummary(page.Wanted)
|
||||
body := swapResponseEmailBody(*target, *requester, page.Offered, page.Wanted, request.Status)
|
||||
page.ResponseMailto = dispatchMailto(requester.Email, subject, body)
|
||||
} else {
|
||||
page.ResponseUnavailable = true
|
||||
}
|
||||
}
|
||||
data := s.baseView(w, r, "Tausch", "team")
|
||||
data.Data = page
|
||||
s.renderPage(w, r, "swap_detail", data)
|
||||
}
|
||||
|
||||
func (s *Server) absoluteURL(r *http.Request, path string) string {
|
||||
scheme := "http"
|
||||
if r.TLS != nil {
|
||||
scheme = "https"
|
||||
}
|
||||
if proto := strings.TrimSpace(strings.Split(r.Header.Get("X-Forwarded-Proto"), ",")[0]); proto != "" {
|
||||
scheme = proto
|
||||
}
|
||||
host := r.Host
|
||||
if forwarded := strings.TrimSpace(strings.Split(r.Header.Get("X-Forwarded-Host"), ",")[0]); forwarded != "" {
|
||||
host = forwarded
|
||||
}
|
||||
return scheme + "://" + host + path
|
||||
}
|
||||
|
||||
func swapAssignmentSummary(view swapAssignmentView) string {
|
||||
if !view.Exists() {
|
||||
return "Einsatz"
|
||||
}
|
||||
date := domain.LongString(view.Service.Date)
|
||||
if view.Service.Title != "" {
|
||||
return date + " · " + view.Service.Title
|
||||
}
|
||||
return date
|
||||
}
|
||||
|
||||
func swapAssignmentLine(view swapAssignmentView) string {
|
||||
if !view.Exists() {
|
||||
return "Der Einsatz ist nicht mehr vorhanden."
|
||||
}
|
||||
church := view.Church.Name
|
||||
if church == "" {
|
||||
church = "Kirche unbekannt"
|
||||
}
|
||||
return fmt.Sprintf("%s, %s Uhr · %s\n %s (%s)",
|
||||
domain.LongString(view.Service.Date), domain.TimeString(view.Service.TimeMinutes),
|
||||
church, view.Service.Title, view.Assignment.Role.Title())
|
||||
}
|
||||
|
||||
func swapRequestEmailBody(requester, target domain.Person, offered, wanted swapAssignmentView, acceptURL, declineURL string) string {
|
||||
return strings.Join([]string{
|
||||
"Guten Tag " + target.FullName() + ",",
|
||||
requester.FullName() + " möchte mit Ihnen einen Dienst tauschen.",
|
||||
"Ihr Einsatz, den " + requester.FullName() + " übernehmen würde:\n" + swapAssignmentLine(wanted),
|
||||
"Der angebotene Einsatz von " + requester.FullName() + ":\n" + swapAssignmentLine(offered),
|
||||
"Bitte antworten Sie nach der Anmeldung über einen dieser Links:\n\n" +
|
||||
"Annehmen: " + acceptURL + "\n" +
|
||||
"Ablehnen: " + declineURL,
|
||||
"Der Plan wird erst geändert, nachdem Sie den Tausch auf der Bestätigungsseite angenommen haben.",
|
||||
"Mit freundlichen Grüßen\nIhr Planungsteam",
|
||||
}, "\n\n")
|
||||
}
|
||||
|
||||
func swapResponseEmailBody(target, requester domain.Person, offered, wanted swapAssignmentView, status string) string {
|
||||
answer := "angenommen"
|
||||
if status == store.SwapDeclined {
|
||||
answer = "abgelehnt"
|
||||
}
|
||||
return strings.Join([]string{
|
||||
"Guten Tag " + requester.FullName() + ",",
|
||||
target.FullName() + " hat Ihre Tauschanfrage " + answer + ".",
|
||||
"Ihr angebotener Einsatz:\n" + swapAssignmentLine(offered),
|
||||
"Der gewünschte Einsatz:\n" + swapAssignmentLine(wanted),
|
||||
"Bei Annahme ist der Plan bereits aktualisiert. Bei Ablehnung bleibt der Plan unverändert.",
|
||||
"Mit freundlichen Grüßen\nIhr Planungsteam",
|
||||
}, "\n\n")
|
||||
}
|
||||
+152
-3
@@ -1,6 +1,7 @@
|
||||
package web
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"sort"
|
||||
"strings"
|
||||
@@ -39,6 +40,21 @@ type teamPageData struct {
|
||||
LectorCount int
|
||||
HelperCount int
|
||||
Year int
|
||||
Sharing *contactSharingData
|
||||
}
|
||||
|
||||
type contactShareReader struct {
|
||||
UserID string
|
||||
Person domain.Person
|
||||
Shared bool
|
||||
}
|
||||
|
||||
type contactSharingData struct {
|
||||
Owner domain.Person
|
||||
Readers []contactShareReader
|
||||
SharedWithMe []domain.Person
|
||||
RosterChanged bool
|
||||
RosterKnown bool
|
||||
}
|
||||
|
||||
type personAssignmentRow struct {
|
||||
@@ -55,6 +71,7 @@ type personPageData struct {
|
||||
Assignments []personAssignmentRow
|
||||
Stats domain.PersonStat
|
||||
Weekdays []weekdayOption
|
||||
Periods []domain.WeekdayPeriod
|
||||
CanEdit bool
|
||||
CanManageAll bool
|
||||
CanEditContact bool
|
||||
@@ -156,11 +173,134 @@ func (s *Server) handleTeam(w http.ResponseWriter, r *http.Request, user *store.
|
||||
page.HelperCount++
|
||||
}
|
||||
}
|
||||
if !canManageAll {
|
||||
linkedID, _ := user.LinkedPerson(tenant.ID)
|
||||
if linkedID != "" {
|
||||
sharing, err := s.contactSharingData(r.Context(), tenant.ID, user, linkedID)
|
||||
if err != nil {
|
||||
s.renderError(w, r, http.StatusInternalServerError, "E-Mail-Freigaben", err.Error())
|
||||
return
|
||||
}
|
||||
page.Sharing = sharing
|
||||
}
|
||||
}
|
||||
data := s.baseView(w, r, "Team", "team")
|
||||
data.Data = page
|
||||
s.renderPage(w, r, "team", data)
|
||||
}
|
||||
|
||||
// contactSharingData prepares the reader self-service card: whom the owner has
|
||||
// shared their address with and who shared an address with the owner.
|
||||
func (s *Server) contactSharingData(ctx context.Context, tenantID string, user *store.User, ownerPersonID string) (*contactSharingData, error) {
|
||||
directory, err := s.store.ReaderDirectory(ctx, tenantID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
grants, err := s.store.ContactSharesForOwner(ctx, tenantID, ownerPersonID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
sharedWithMe, err := s.store.ContactSharesForViewer(ctx, tenantID, user.ID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := &contactSharingData{}
|
||||
readerByPerson := map[string]domain.Person{}
|
||||
for _, entry := range directory {
|
||||
readerByPerson[entry.Person.ID] = entry.Person
|
||||
if entry.Person.ID == ownerPersonID {
|
||||
out.Owner = entry.Person
|
||||
continue
|
||||
}
|
||||
out.Readers = append(out.Readers, contactShareReader{
|
||||
UserID: entry.UserID, Person: entry.Person, Shared: grants[entry.UserID],
|
||||
})
|
||||
}
|
||||
for _, personID := range sharedWithMe {
|
||||
if person, ok := readerByPerson[personID]; ok {
|
||||
out.SharedWithMe = append(out.SharedWithMe, person)
|
||||
}
|
||||
}
|
||||
changed, known, err := s.store.ContactRosterChanged(ctx, tenantID, user.ID, ownerPersonID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out.RosterChanged = changed
|
||||
out.RosterKnown = known
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (s *Server) handleContactSharesSave(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
if tenant == nil {
|
||||
s.redirect(w, r, "/plan")
|
||||
return
|
||||
}
|
||||
ownerPersonID, linked := user.LinkedPerson(tenant.ID)
|
||||
if user.Role != store.RoleReader || !linked {
|
||||
s.renderError(w, r, http.StatusForbidden, "E-Mail-Freigaben",
|
||||
"E-Mail-Freigaben können nur verknüpfte Leser-Konten verwalten.")
|
||||
return
|
||||
}
|
||||
directory, err := s.store.ReaderDirectory(r.Context(), tenant.ID)
|
||||
if err != nil {
|
||||
s.setFlash(w, "Die Freigaben konnten nicht geladen werden.", "error")
|
||||
s.redirect(w, r, "/team")
|
||||
return
|
||||
}
|
||||
var selected []string
|
||||
if r.FormValue("share_all") == "1" {
|
||||
for _, entry := range directory {
|
||||
if entry.UserID != user.ID {
|
||||
selected = append(selected, entry.UserID)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
selected = r.Form["viewer"]
|
||||
}
|
||||
added, removed, err := s.store.SetContactShares(r.Context(), store.KeyringFrom(r.Context()),
|
||||
tenant.ID, user.ID, ownerPersonID, selected)
|
||||
if err != nil {
|
||||
s.setFlash(w, "Die Freigaben konnten nicht gespeichert werden: "+err.Error(), "error")
|
||||
s.redirect(w, r, "/team")
|
||||
return
|
||||
}
|
||||
if len(removed) > 0 {
|
||||
s.forgetCachedScopeForUsers(store.KeyScope{Type: store.ScopePerson, TenantID: tenant.ID, ID: ownerPersonID}, removed)
|
||||
}
|
||||
if err := s.store.MarkContactRosterReviewed(r.Context(), tenant.ID, user.ID, ownerPersonID); err != nil {
|
||||
s.setFlash(w, "Die Freigaben wurden gespeichert, die Prüfmarke konnte aber nicht aktualisiert werden.", "error")
|
||||
s.redirect(w, r, "/team")
|
||||
return
|
||||
}
|
||||
s.refreshCachedKeyrings(r.Context())
|
||||
if len(added) == 0 && len(removed) == 0 {
|
||||
s.setFlash(w, "Die E-Mail-Freigaben sind unverändert.", "info")
|
||||
} else {
|
||||
s.setFlash(w, "E-Mail-Freigaben gespeichert: "+plural(len(added), "neue Freigabe", "neue Freigaben")+
|
||||
", "+plural(len(removed), "entzogene Freigabe", "entzogene Freigaben")+".", "success")
|
||||
}
|
||||
s.redirect(w, r, "/team")
|
||||
}
|
||||
|
||||
func (s *Server) handleContactRosterAck(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
|
||||
if tenant == nil {
|
||||
s.redirect(w, r, "/plan")
|
||||
return
|
||||
}
|
||||
ownerPersonID, linked := user.LinkedPerson(tenant.ID)
|
||||
if user.Role != store.RoleReader || !linked {
|
||||
s.renderError(w, r, http.StatusForbidden, "E-Mail-Freigaben",
|
||||
"E-Mail-Freigaben können nur verknüpfte Leser-Konten verwalten.")
|
||||
return
|
||||
}
|
||||
if err := s.store.MarkContactRosterReviewed(r.Context(), tenant.ID, user.ID, ownerPersonID); err != nil {
|
||||
s.setFlash(w, "Die Prüfmarke konnte nicht gespeichert werden.", "error")
|
||||
} else {
|
||||
s.setFlash(w, "Die geänderte Leserliste wurde zur Kenntnis genommen. Ihre Freigaben bleiben unverändert.", "success")
|
||||
}
|
||||
s.redirect(w, r, "/team")
|
||||
}
|
||||
|
||||
func blankPerson() domain.Person {
|
||||
return domain.Person{
|
||||
ID: domain.NewID(), Roles: []domain.Role{domain.RoleLector},
|
||||
@@ -256,7 +396,7 @@ func (s *Server) handlePerson(w http.ResponseWriter, r *http.Request, user *stor
|
||||
}
|
||||
page := personPageData{
|
||||
Person: person, IsNew: isNew, Absences: absences, Churches: churches,
|
||||
Assignments: rows, Weekdays: weekdays,
|
||||
Assignments: rows, Weekdays: weekdays, Periods: domain.AllWeekdayPeriods,
|
||||
CanEdit: canManageAll || !isNew, CanManageAll: canManageAll,
|
||||
CanEditContact: canManageContacts,
|
||||
OwnContact: ownContact,
|
||||
@@ -336,18 +476,27 @@ func (s *Server) handlePersonSave(w http.ResponseWriter, r *http.Request, user *
|
||||
return
|
||||
}
|
||||
person := domain.Person{
|
||||
ID: id, FirstName: strings.TrimSpace(r.FormValue("first_name")),
|
||||
LastName: strings.TrimSpace(r.FormValue("last_name")), Roles: roles,
|
||||
ID: id, ShortCode: strings.TrimSpace(r.FormValue("short_code")),
|
||||
FirstName: strings.TrimSpace(r.FormValue("first_name")),
|
||||
LastName: strings.TrimSpace(r.FormValue("last_name")), Roles: roles,
|
||||
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),
|
||||
AllowBeyondPreferences: r.FormValue("allow_beyond_preferences") == "1" || r.FormValue("allow_beyond_preferences") == "on",
|
||||
Active: r.FormValue("active") == "1" || r.FormValue("active") == "on",
|
||||
Notes: strings.TrimSpace(r.FormValue("notes")),
|
||||
}
|
||||
for _, raw := range r.Form["preferred_weekdays"] {
|
||||
if value := parseInt(raw, 0); value >= 1 && value <= 7 {
|
||||
person.PreferredWeekdays = append(person.PreferredWeekdays, value)
|
||||
period := domain.WeekdayPeriod(strings.TrimSpace(r.FormValue("weekday_period_" + raw)))
|
||||
if !period.IsValid() {
|
||||
period = domain.PeriodAllDay
|
||||
}
|
||||
person.PreferredWeekdayPeriods = append(person.PreferredWeekdayPeriods, domain.WeekdayPeriodPreference{
|
||||
Weekday: value, Period: period,
|
||||
})
|
||||
}
|
||||
}
|
||||
if existing != nil {
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
<div>
|
||||
<span class="eyebrow">Öffentlicher Plan · {{.Data.TenantName}}</span>
|
||||
<h2>{{rangeLong .Data.Range}}</h2>
|
||||
<p>Alle Gottesdienste mit liturgischen Angaben und Lesungsverweisen – ohne Namen der eingesetzten Personen, ohne Einstellungen und ohne Schreibzugriffe.</p>
|
||||
<p>Alle Gottesdienste mit liturgischen Angaben und Lesungsverweisen – ohne vollständige Namen, ohne Einstellungen und ohne Schreibzugriffe. Lektoren und Kommunionhelfer erscheinen mit Kürzel oder Initialen.</p>
|
||||
</div>
|
||||
<div class="intro-actions">
|
||||
{{if gt (len .Data.Tenants) 1}}
|
||||
@@ -23,17 +23,17 @@
|
||||
|
||||
<section class="toolbar card">
|
||||
<div class="toolbar-group range-nav">
|
||||
<a class="icon-button" href="/guest?tid={{.Data.TenantID}}&start={{.Data.PrevStart}}&end={{.Data.PrevEnd}}" title="Vorheriger Monat">{{icon "left"}}</a>
|
||||
{{if .Data.CanPrev}}<a class="icon-button" href="/guest?tid={{.Data.TenantID}}&start={{.Data.PrevStart}}&end={{.Data.PrevEnd}}" title="Vorheriger Zeitraum">{{icon "left"}}</a>{{else}}<span class="icon-button is-disabled" title="Keine früheren Planungsdaten">{{icon "left"}}</span>{{end}}
|
||||
<form class="range-form" method="get" action="/guest">
|
||||
<input type="hidden" name="tid" value="{{.Data.TenantID}}">
|
||||
<label class="field field-inline"><span>Von</span><input type="date" name="start" value="{{.Data.Start}}"></label>
|
||||
<label class="field field-inline"><span>Bis</span><input type="date" name="end" value="{{.Data.End}}"></label>
|
||||
<label class="field field-inline"><span>Von</span><input type="date" name="start" value="{{.Data.Start}}" min="{{.Data.MinDate}}" max="{{.Data.MaxDate}}"></label>
|
||||
<label class="field field-inline"><span>Bis</span><input type="date" name="end" value="{{.Data.End}}" min="{{.Data.MinDate}}" max="{{.Data.MaxDate}}"></label>
|
||||
<button class="btn btn-secondary btn-small" type="submit">Anzeigen</button>
|
||||
</form>
|
||||
<a class="icon-button" href="/guest?tid={{.Data.TenantID}}&start={{.Data.NextStart}}&end={{.Data.NextEnd}}" title="Nächster Monat">{{icon "right"}}</a>
|
||||
{{if .Data.CanNext}}<a class="icon-button" href="/guest?tid={{.Data.TenantID}}&start={{.Data.NextStart}}&end={{.Data.NextEnd}}" title="Nächster Zeitraum">{{icon "right"}}</a>{{else}}<span class="icon-button is-disabled" title="Keine späteren Planungsdaten">{{icon "right"}}</span>{{end}}
|
||||
</div>
|
||||
<div class="toolbar-group">
|
||||
<a class="chip" href="/guest?tid={{.Data.TenantID}}">{{icon "calendar"}} Dieser Monat</a>
|
||||
<a class="chip" href="/guest?tid={{.Data.TenantID}}&start={{.Data.DefaultStart}}&end={{.Data.DefaultEnd}}">{{icon "calendar"}} Aktuelle 4 Wochen</a>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
@@ -118,7 +118,7 @@
|
||||
{{if .Service.Location}}<span class="service-location">{{deref .Service.Location}}</span>{{end}}
|
||||
<span class="service-people">
|
||||
{{range .Assignments}}
|
||||
<span class="person-chip role-{{roleShort .Role}}" title="{{roleTitle .Role}}">{{roleTitle .Role}}</span>
|
||||
<span class="person-chip role-{{roleShort .Role}}" title="{{roleTitle .Role}}">{{with index $.Data.PersonLabels .PersonID}}{{.}}{{else}}?{{end}}</span>
|
||||
{{end}}
|
||||
</span>
|
||||
{{if not .IsFullyStaffed}}<span class="open-badge">{{plural .OpenSlots "Platz offen" "Plätze offen"}}</span>{{end}}
|
||||
@@ -198,7 +198,7 @@
|
||||
{{if .Service.Location}}<span class="service-location">{{deref .Service.Location}}</span>{{end}}
|
||||
<span class="service-people">
|
||||
{{range .Assignments}}
|
||||
<span class="person-chip role-{{roleShort .Role}}" title="{{roleTitle .Role}}">{{roleTitle .Role}}</span>
|
||||
<span class="person-chip role-{{roleShort .Role}}" title="{{roleTitle .Role}}">{{with index $.Data.PersonLabels .PersonID}}{{.}}{{else}}?{{end}}</span>
|
||||
{{end}}
|
||||
</span>
|
||||
{{if not .IsFullyStaffed}}<span class="open-badge">{{plural .OpenSlots "Platz offen" "Plätze offen"}}</span>{{end}}
|
||||
@@ -215,6 +215,6 @@
|
||||
<p class="plan-mobile-empty empty-note" data-plan-mobile-empty hidden>Keine Tage passen zu diesem Filter.</p>
|
||||
</div>
|
||||
</section>
|
||||
<p class="table-note">Gastansicht: Die Einsätze werden nur mit ihrer Rolle angezeigt. Liturgische Daten von www.eucharistiefeier.de, Lesungen verlinkt zu Schott.</p>
|
||||
<p class="table-note">Gastansicht: Die Einsätze werden mit Kürzel oder Initialen angezeigt; vollständige Namen und Kontaktdaten bleiben verborgen. Liturgische Daten von www.eucharistiefeier.de, Lesungen verlinkt zu Schott.</p>
|
||||
</div>
|
||||
{{end}}
|
||||
@@ -39,6 +39,7 @@
|
||||
<label class="field"><span class="field-label">Vorname</span><input type="text" name="first_name" value="{{$person.FirstName}}"></label>
|
||||
<label class="field"><span class="field-label">Nachname</span><input type="text" name="last_name" value="{{$person.LastName}}"></label>
|
||||
</div>
|
||||
<label class="field"><span class="field-label">Kürzel <small>optional, erscheint in der Gastansicht statt der Initialen</small></span><input type="text" name="short_code" value="{{$person.ShortCode}}" maxlength="8" placeholder="z. B. AB"></label>
|
||||
<div class="form-row">
|
||||
<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>
|
||||
@@ -58,10 +59,15 @@
|
||||
</div>
|
||||
</div>
|
||||
<div class="field-group">
|
||||
<span class="field-label">Bevorzugte Einsatztage</span>
|
||||
<span class="field-label">Bevorzugte Einsatztage <small>Hochfeste gelten zusätzlich als Sonntag</small></span>
|
||||
<div class="weekday-grid">
|
||||
{{range .Data.Weekdays}}
|
||||
<label class="weekday-check"><input type="checkbox" name="preferred_weekdays" value="{{.Number}}" {{if containsInt $person.PreferredWeekdays .Number}}checked{{end}}><span>{{.Short}}</span></label>
|
||||
{{range $weekday := .Data.Weekdays}}
|
||||
<div class="weekday-preference">
|
||||
<label class="weekday-check"><input type="checkbox" name="preferred_weekdays" value="{{$weekday.Number}}" {{if containsInt $person.PreferredWeekdays $weekday.Number}}checked{{end}}><span>{{$weekday.Short}}</span></label>
|
||||
<select name="weekday_period_{{$weekday.Number}}" class="weekday-period" aria-label="Tageszeit für {{$weekday.Name}}">
|
||||
{{range $.Data.Periods}}<option value="{{.}}" {{if eq ($person.WeekdayPeriodFor $weekday.Number) .}}selected{{end}}>{{.ShortLabel}}</option>{{end}}
|
||||
</select>
|
||||
</div>
|
||||
{{end}}
|
||||
</div>
|
||||
</div>
|
||||
@@ -72,12 +78,14 @@
|
||||
<label class="check standalone"><input type="checkbox" name="active" value="1" {{if $person.Active}}checked{{end}} {{if not .Data.CanManageAll}}disabled{{end}}><span>aktiv und planbar</span></label>
|
||||
</label>
|
||||
</div>
|
||||
<label class="field"><span class="field-label">Notizen</span><textarea name="notes" rows="3">{{$person.Notes}}</textarea></label>
|
||||
<label class="check"><input type="checkbox" name="allow_beyond_preferences" value="1" {{if $person.AllowBeyondPreferences}}checked{{end}}><span>Diese Person darf nach Rückfrage auch über ihre Präferenzen hinaus eingeplant werden</span></label>
|
||||
<label class="field"><span class="field-label">Notizen <small>erscheinen in der Dienstplanung bei Einsätzen und Vorschlägen</small></span><textarea name="notes" rows="3">{{$person.Notes}}</textarea></label>
|
||||
<button class="btn btn-primary" type="submit">{{if .Data.IsNew}}Person anlegen{{else}}Person speichern{{end}}</button>
|
||||
</form>
|
||||
{{else}}
|
||||
<dl class="detail-list">
|
||||
<dt>Name</dt><dd>{{$person.FullName}}</dd>
|
||||
{{if $person.ShortCode}}<dt>Kürzel</dt><dd>{{$person.ShortCode}}</dd>{{end}}
|
||||
<dt>Dienste</dt><dd>{{$person.RoleLabel}}</dd>
|
||||
{{if $person.Email}}<dt>E-Mail</dt><dd>{{$person.Email}}</dd>{{end}}
|
||||
{{if $person.EmailLocked}}<dt>Kontaktdaten</dt><dd>verschlüsselt und für dieses Konto nicht entsperrt</dd>{{end}}
|
||||
|
||||
@@ -93,6 +93,23 @@
|
||||
</div>
|
||||
</section>
|
||||
|
||||
{{if .Data.PromptBeyond}}
|
||||
<section class="beyond-prompt card">
|
||||
<div>
|
||||
<span class="eyebrow">Rückfrage zur Planung</span>
|
||||
<h3>{{.Data.BeyondOpen}} {{plural .Data.BeyondOpen "Dienst bleibt" "Dienste bleiben"}} offen</h3>
|
||||
<p>Es gibt Personen, die ausdrücklich bereit sind, auch über ihre Präferenzen hinaus eingeplant zu werden. Sollen sie für die verbleibenden Dienste eingesetzt werden? Die Einsätze werden im Plan besonders gekennzeichnet.</p>
|
||||
</div>
|
||||
<form method="post" action="/plan/auto" class="inline-form">
|
||||
<input type="hidden" name="csrf" value="{{.CSRF}}">
|
||||
<input type="hidden" name="start" value="{{.Data.Start}}">
|
||||
<input type="hidden" name="end" value="{{.Data.End}}">
|
||||
<input type="hidden" name="beyond" value="1">
|
||||
<button class="btn btn-primary btn-small" type="submit">{{icon "sparkles"}} Ja, freigegebene Personen einplanen</button>
|
||||
</form>
|
||||
</section>
|
||||
{{end}}
|
||||
|
||||
<section class="stat-strip">
|
||||
<article class="mini-stat">
|
||||
<span class="mini-stat-label">Gottesdienste</span>
|
||||
@@ -122,11 +139,13 @@
|
||||
<button class="chip" type="button" data-plan-filter="services">Mit Gottesdiensten</button>
|
||||
<button class="chip" type="button" data-plan-filter="open">Nur offene</button>
|
||||
<button class="chip" type="button" data-plan-filter="feasts">Sonn- & Feiertage</button>
|
||||
<button class="chip" type="button" data-plan-filter="beyond">Über Präferenzen</button>
|
||||
</div>
|
||||
<div class="legend-items">
|
||||
<span><i class="swatch sunday"></i>Sonntag</span>
|
||||
<span><i class="swatch feast"></i>Hochfest</span>
|
||||
<span><i class="swatch open"></i>Offener Dienst</span>
|
||||
<span><span class="beyond-mark">↑</span>Über Präferenzen</span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -145,6 +164,7 @@
|
||||
</span>
|
||||
</th>
|
||||
{{end}}
|
||||
<th class="col-day-action"><span class="visually-hidden">Aktionen</span></th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
@@ -153,7 +173,8 @@
|
||||
data-plan-row
|
||||
data-has-services="{{if .HasServices}}true{{else}}false{{end}}"
|
||||
data-open="{{.OpenSlots}}"
|
||||
data-special="{{if .IsSpecialDay}}true{{else}}false{{end}}">
|
||||
data-special="{{if .IsSpecialDay}}true{{else}}false{{end}}"
|
||||
data-beyond="{{if .HasBeyondPreferences}}true{{else}}false{{end}}">
|
||||
<td class="date-cell">
|
||||
<div class="date-number">{{dayNumber .Date}}</div>
|
||||
<div class="date-meta"><span>{{shortWeekday .Date}}</span><span>{{shortMonth .Date}}</span></div>
|
||||
@@ -185,6 +206,7 @@
|
||||
{{if $services}}
|
||||
<div class="service-stack">
|
||||
{{range $services}}
|
||||
<div class="service-card-wrap">
|
||||
<a class="service-card {{if .IsFullyStaffed}}staffed{{else}}open{{end}}" href="/services/{{.Service.ID}}?start={{$.Data.Start}}&end={{$.Data.End}}">
|
||||
<span class="service-time">{{timeLabel .Service.TimeMinutes}}</span>
|
||||
<span class="service-title">{{.Service.Title}}{{if eq (printf "%s" .Service.Kind) "special"}}<span class="service-kind">Sonder</span>{{end}}</span>
|
||||
@@ -192,11 +214,20 @@
|
||||
<span class="service-people">
|
||||
{{range .Assignments}}
|
||||
{{$person := index $.Data.People .PersonID}}
|
||||
<span class="person-chip role-{{roleShort .Role}}" title="{{roleTitle .Role}}{{if $person}} · {{$person.FullName}}{{end}}">{{if $person}}{{$person.AbbreviatedName}}{{else}}?{{end}}</span>
|
||||
<span class="person-chip role-{{roleShort .Role}}{{if index $.Data.SwapMarks .ID}} swap-pending{{end}}{{if .BeyondPreferences}} beyond-pref{{end}}" title="{{roleTitle .Role}}{{if $person}} · {{$person.FullName}}{{end}}{{if index $.Data.SwapMarks .ID}} · Tausch angefragt{{end}}{{if .BeyondPreferences}} · über Präferenzen hinaus{{end}}{{if and $person $person.PreferenceNote}} · {{$person.PreferenceNote}}{{end}}">{{if index $.Data.SwapMarks .ID}}<span class="swap-mark" aria-hidden="true">⇄</span>{{end}}{{if .BeyondPreferences}}<span class="beyond-mark" aria-hidden="true">↑</span>{{end}}{{if $person}}{{$person.AbbreviatedName}}{{else}}?{{end}}</span>
|
||||
{{end}}
|
||||
</span>
|
||||
{{if not .IsFullyStaffed}}<span class="open-badge">{{plural .OpenSlots "Platz offen" "Plätze offen"}}</span>{{end}}
|
||||
</a>
|
||||
{{if $.Data.CanEdit}}
|
||||
<form class="service-delete-form" method="post" action="/services/{{.Service.ID}}/delete" data-confirm="Diesen Gottesdienst mit allen Einteilungen wirklich löschen?">
|
||||
<input type="hidden" name="csrf" value="{{$.CSRF}}">
|
||||
<input type="hidden" name="start" value="{{$.Data.Start}}">
|
||||
<input type="hidden" name="end" value="{{$.Data.End}}">
|
||||
<button class="icon-button danger service-delete" type="submit" title="Gottesdienst löschen">{{icon "trash"}}</button>
|
||||
</form>
|
||||
{{end}}
|
||||
</div>
|
||||
{{end}}
|
||||
</div>
|
||||
{{else}}
|
||||
@@ -204,6 +235,11 @@
|
||||
{{end}}
|
||||
</td>
|
||||
{{end}}
|
||||
<td class="day-action">
|
||||
{{if $.Data.CanEdit}}
|
||||
<a class="icon-button day-special-add" href="/services?edit_special=new&date={{isoDate .Date}}" title="Sondergottesdienst an diesem Tag anlegen">{{icon "plus"}}</a>
|
||||
{{end}}
|
||||
</td>
|
||||
</tr>
|
||||
{{end}}
|
||||
</tbody>
|
||||
@@ -217,7 +253,8 @@
|
||||
data-plan-row
|
||||
data-has-services="{{if .HasServices}}true{{else}}false{{end}}"
|
||||
data-open="{{.OpenSlots}}"
|
||||
data-special="{{if .IsSpecialDay}}true{{else}}false{{end}}">
|
||||
data-special="{{if .IsSpecialDay}}true{{else}}false{{end}}"
|
||||
data-beyond="{{if .HasBeyondPreferences}}true{{else}}false{{end}}">
|
||||
<summary class="plan-day-summary">
|
||||
<span class="day-date">
|
||||
<span class="date-number">{{dayNumber $row.Date}}</span>
|
||||
@@ -255,6 +292,9 @@
|
||||
<span class="day-chevron" aria-hidden="true">{{icon "right"}}</span>
|
||||
</summary>
|
||||
<div class="day-details">
|
||||
{{if $.Data.CanEdit}}
|
||||
<a class="btn btn-secondary btn-tiny day-special-add-mobile" href="/services?edit_special=new&date={{isoDate $row.Date}}">{{icon "plus"}} Sondergottesdienst an diesem Tag</a>
|
||||
{{end}}
|
||||
{{if $row.LiturgicalDay}}
|
||||
{{if not $row.LiturgicalDay.Readings.IsEmpty}}
|
||||
<a class="readings day-readings" href="https://schott.erzabtei-beuron.de/?datum={{isoDate $row.Date}}" target="_blank" rel="noopener" title="{{$row.LiturgicalDay.Readings.FullLabel}} · Tageslesungen bei Schott öffnen">{{$row.LiturgicalDay.Readings.ShortLabel}}{{icon "external"}}</a>
|
||||
@@ -272,6 +312,7 @@
|
||||
</div>
|
||||
<div class="service-stack">
|
||||
{{range $services}}
|
||||
<div class="service-card-wrap">
|
||||
<a class="service-card day-service-card {{if .IsFullyStaffed}}staffed{{else}}open{{end}}" href="/services/{{.Service.ID}}?start={{$.Data.Start}}&end={{$.Data.End}}">
|
||||
<span class="service-time">{{timeLabel .Service.TimeMinutes}}</span>
|
||||
<span class="service-title">{{.Service.Title}}{{if eq (printf "%s" .Service.Kind) "special"}}<span class="service-kind">Sonder</span>{{end}}</span>
|
||||
@@ -279,11 +320,20 @@
|
||||
<span class="service-people">
|
||||
{{range .Assignments}}
|
||||
{{$person := index $.Data.People .PersonID}}
|
||||
<span class="person-chip role-{{roleShort .Role}}" title="{{roleTitle .Role}}{{if $person}} · {{$person.FullName}}{{end}}">{{if $person}}{{$person.AbbreviatedName}}{{else}}?{{end}}</span>
|
||||
<span class="person-chip role-{{roleShort .Role}}{{if index $.Data.SwapMarks .ID}} swap-pending{{end}}{{if .BeyondPreferences}} beyond-pref{{end}}" title="{{roleTitle .Role}}{{if $person}} · {{$person.FullName}}{{end}}{{if index $.Data.SwapMarks .ID}} · Tausch angefragt{{end}}{{if .BeyondPreferences}} · über Präferenzen hinaus{{end}}{{if and $person $person.PreferenceNote}} · {{$person.PreferenceNote}}{{end}}">{{if index $.Data.SwapMarks .ID}}<span class="swap-mark" aria-hidden="true">⇄</span>{{end}}{{if .BeyondPreferences}}<span class="beyond-mark" aria-hidden="true">↑</span>{{end}}{{if $person}}{{$person.AbbreviatedName}}{{else}}?{{end}}</span>
|
||||
{{end}}
|
||||
</span>
|
||||
{{if not .IsFullyStaffed}}<span class="open-badge">{{plural .OpenSlots "Platz offen" "Plätze offen"}}</span>{{end}}
|
||||
</a>
|
||||
{{if $.Data.CanEdit}}
|
||||
<form class="service-delete-form" method="post" action="/services/{{.Service.ID}}/delete" data-confirm="Diesen Gottesdienst mit allen Einteilungen wirklich löschen?">
|
||||
<input type="hidden" name="csrf" value="{{$.CSRF}}">
|
||||
<input type="hidden" name="start" value="{{$.Data.Start}}">
|
||||
<input type="hidden" name="end" value="{{$.Data.End}}">
|
||||
<button class="icon-button danger service-delete" type="submit" title="Gottesdienst löschen">{{icon "trash"}}</button>
|
||||
</form>
|
||||
{{end}}
|
||||
</div>
|
||||
{{end}}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -21,8 +21,8 @@
|
||||
</div>
|
||||
<div class="detail-hero-actions">
|
||||
<a class="btn btn-ghost btn-small" href="/plan?start={{.Data.Start}}&end={{.Data.End}}">{{icon "calendar"}} Zum Plan</a>
|
||||
{{if and .Data.CanEdit (eq (printf "%s" $service.Kind) "special")}}
|
||||
<form method="post" action="/services/{{$service.ID}}/delete" data-confirm="Diesen Sondergottesdienst wirklich löschen?">
|
||||
{{if .Data.CanEdit}}
|
||||
<form method="post" action="/services/{{$service.ID}}/delete" data-confirm="Diesen Gottesdienst mit allen Einteilungen wirklich löschen?">
|
||||
<input type="hidden" name="csrf" value="{{.CSRF}}">
|
||||
<button class="btn btn-danger btn-small" type="submit">{{icon "trash"}} Löschen</button>
|
||||
</form>
|
||||
@@ -42,8 +42,11 @@
|
||||
{{$person := index $.Data.People .PersonID}}
|
||||
<div class="assignment-row">
|
||||
<span class="avatar small">{{if $person}}{{$person.Initials}}{{else}}?{{end}}</span>
|
||||
<span class="assignment-person"><strong>{{if $person}}{{$person.FullName}}{{else}}Unbekannt{{end}}</strong><small>{{if $person}}{{$person.RoleLabel}}{{else}}—{{end}}</small></span>
|
||||
<span class="assignment-person"><strong>{{if $person}}{{$person.FullName}}{{else}}Unbekannt{{end}}</strong><small>{{if $person}}{{$person.RoleLabel}}{{else}}—{{end}}</small>{{if and $person $person.PreferenceNote}}<span class="person-note">{{$person.PreferenceNote}}</span>{{end}}</span>
|
||||
{{if .Locked}}<span class="badge badge-gold">gesperrt</span>{{end}}
|
||||
{{if .BeyondPreferences}}<span class="badge badge-burgundy">über Präferenzen</span>{{end}}
|
||||
{{if index $.Data.SwapMarks .ID}}<span class="badge badge-gold">Tausch angefragt</span>{{end}}
|
||||
{{if index $.Data.SwapCandidates .ID}}<a class="btn btn-secondary btn-tiny" href="/swap/new?assignment={{.ID}}">Tausch anfragen</a>{{end}}
|
||||
{{if $.Data.CanEdit}}
|
||||
<div class="assignment-actions">
|
||||
<form method="post" action="/services/{{$service.ID}}/lock">
|
||||
@@ -69,9 +72,10 @@
|
||||
<div class="candidate {{if .Blocked}}blocked{{end}}">
|
||||
<div class="candidate-main">
|
||||
<span class="avatar small">{{.Person.Initials}}</span>
|
||||
<div><strong>{{.Person.FullName}}</strong><small>{{.TotalAssignments}} Einsätze im Zeitraum · Score {{formatFloat .Score}}</small></div>
|
||||
<div><strong>{{.Person.FullName}}</strong><small>{{.TotalAssignments}} Einsätze im Zeitraum · Score {{formatFloat .Score}}</small>{{if .Person.PreferenceNote}}<span class="person-note">{{.Person.PreferenceNote}}</span>{{end}}</div>
|
||||
</div>
|
||||
<div class="candidate-tags">
|
||||
{{if .BeyondPreferences}}<span class="badge badge-burgundy">über Präferenzen</span>{{end}}
|
||||
{{if .Preferred}}<span class="badge badge-green">Präferenz</span>{{end}}
|
||||
{{range .Warnings}}<span class="badge badge-burgundy">{{.}}</span>{{end}}
|
||||
</div>
|
||||
@@ -100,8 +104,11 @@
|
||||
{{$person := index $.Data.People .PersonID}}
|
||||
<div class="assignment-row">
|
||||
<span class="avatar small">{{if $person}}{{$person.Initials}}{{else}}?{{end}}</span>
|
||||
<span class="assignment-person"><strong>{{if $person}}{{$person.FullName}}{{else}}Unbekannt{{end}}</strong><small>{{if $person}}{{$person.RoleLabel}}{{else}}—{{end}}</small></span>
|
||||
<span class="assignment-person"><strong>{{if $person}}{{$person.FullName}}{{else}}Unbekannt{{end}}</strong><small>{{if $person}}{{$person.RoleLabel}}{{else}}—{{end}}</small>{{if and $person $person.PreferenceNote}}<span class="person-note">{{$person.PreferenceNote}}</span>{{end}}</span>
|
||||
{{if .Locked}}<span class="badge badge-gold">gesperrt</span>{{end}}
|
||||
{{if .BeyondPreferences}}<span class="badge badge-burgundy">über Präferenzen</span>{{end}}
|
||||
{{if index $.Data.SwapMarks .ID}}<span class="badge badge-gold">Tausch angefragt</span>{{end}}
|
||||
{{if index $.Data.SwapCandidates .ID}}<a class="btn btn-secondary btn-tiny" href="/swap/new?assignment={{.ID}}">Tausch anfragen</a>{{end}}
|
||||
{{if $.Data.CanEdit}}
|
||||
<div class="assignment-actions">
|
||||
<form method="post" action="/services/{{$service.ID}}/lock">
|
||||
@@ -127,9 +134,10 @@
|
||||
<div class="candidate {{if .Blocked}}blocked{{end}}">
|
||||
<div class="candidate-main">
|
||||
<span class="avatar small">{{.Person.Initials}}</span>
|
||||
<div><strong>{{.Person.FullName}}</strong><small>{{.TotalAssignments}} Einsätze im Zeitraum · Score {{formatFloat .Score}}</small></div>
|
||||
<div><strong>{{.Person.FullName}}</strong><small>{{.TotalAssignments}} Einsätze im Zeitraum · Score {{formatFloat .Score}}</small>{{if .Person.PreferenceNote}}<span class="person-note">{{.Person.PreferenceNote}}</span>{{end}}</div>
|
||||
</div>
|
||||
<div class="candidate-tags">
|
||||
{{if .BeyondPreferences}}<span class="badge badge-burgundy">über Präferenzen</span>{{end}}
|
||||
{{if .Preferred}}<span class="badge badge-green">Präferenz</span>{{end}}
|
||||
{{range .Warnings}}<span class="badge badge-burgundy">{{.}}</span>{{end}}
|
||||
</div>
|
||||
|
||||
@@ -0,0 +1,105 @@
|
||||
{{define "content"}}
|
||||
{{$request := .Data.Request}}
|
||||
{{$offered := .Data.Offered}}
|
||||
{{$wanted := .Data.Wanted}}
|
||||
<div class="page-stack">
|
||||
<section class="detail-hero card">
|
||||
<div class="detail-hero-main">
|
||||
<span class="avatar large">⇄</span>
|
||||
<div>
|
||||
<span class="eyebrow">Tauschanfrage</span>
|
||||
<h2>{{.Data.RequesterPerson.FullName}} ⇄ {{.Data.TargetPerson.FullName}}</h2>
|
||||
<p class="detail-place">Angelegt am {{longDate $request.CreatedAt}}{{if ne $request.Status "pending"}} · beantwortet am {{longDate $request.RespondedAt}}{{end}}</p>
|
||||
<div class="badge-row">
|
||||
<span class="badge {{if eq $request.Status "pending"}}badge-gold{{else if eq $request.Status "accepted"}}badge-green{{else}}badge-burgundy{{end}}">{{.Data.StatusLabel}}</span>
|
||||
<span class="badge badge-neutral">{{$wanted.Assignment.Role.Title}}</span>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="detail-hero-actions">
|
||||
<a class="btn btn-ghost btn-small" href="/plan">{{icon "calendar"}} Zum Plan</a>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<div class="swap-compare">
|
||||
<section class="card">
|
||||
<div class="card-head"><div><span class="eyebrow">Angebot von {{.Data.RequesterPerson.FullName}}</span><h3>{{$offered.Service.Title}}</h3></div></div>
|
||||
{{if $offered.Exists}}
|
||||
<dl class="detail-list">
|
||||
<dt>Datum</dt><dd>{{longDate $offered.Service.Date}}, {{timeLabel $offered.Service.TimeMinutes}} Uhr</dd>
|
||||
<dt>Ort</dt><dd>{{$offered.Church.Name}}</dd>
|
||||
<dt>Rolle</dt><dd>{{$offered.Assignment.Role.Title}}</dd>
|
||||
</dl>
|
||||
{{else}}<p class="empty-note">Dieser Einsatz ist nicht mehr vorhanden.</p>{{end}}
|
||||
</section>
|
||||
<section class="card">
|
||||
<div class="card-head"><div><span class="eyebrow">Gewünscht von {{.Data.TargetPerson.FullName}}</span><h3>{{$wanted.Service.Title}}</h3></div></div>
|
||||
{{if $wanted.Exists}}
|
||||
<dl class="detail-list">
|
||||
<dt>Datum</dt><dd>{{longDate $wanted.Service.Date}}, {{timeLabel $wanted.Service.TimeMinutes}} Uhr</dd>
|
||||
<dt>Ort</dt><dd>{{$wanted.Church.Name}}</dd>
|
||||
<dt>Rolle</dt><dd>{{$wanted.Assignment.Role.Title}}</dd>
|
||||
</dl>
|
||||
{{else}}<p class="empty-note">Dieser Einsatz ist nicht mehr vorhanden.</p>{{end}}
|
||||
</section>
|
||||
</div>
|
||||
|
||||
{{if .Data.Action}}
|
||||
<section class="card swap-action-card">
|
||||
<span class="eyebrow">Bestätigung</span>
|
||||
<h3>{{if eq .Data.Action "accept"}}Tausch annehmen?{{else}}Tausch ablehnen?{{end}}</h3>
|
||||
{{if eq .Data.Action "accept"}}
|
||||
<p>Beim Annehmen werden beide Einsätze sofort getauscht. Der Plan wird erst nach Ihrer Bestätigung geändert.</p>
|
||||
{{else}}
|
||||
<p>Beim Ablehnen bleibt der Plan unverändert. {{.Data.RequesterPerson.FullName}} erhält anschließend die Möglichkeit, eine Antwort-E-Mail zu senden.</p>
|
||||
{{end}}
|
||||
<form method="post" action="/swap/{{.Data.Token}}/respond" class="inline-form">
|
||||
<input type="hidden" name="csrf" value="{{.CSRF}}">
|
||||
<input type="hidden" name="action" value="{{.Data.Action}}">
|
||||
<button class="btn {{if eq .Data.Action "accept"}}btn-primary{{else}}btn-danger{{end}}" type="submit">{{if eq .Data.Action "accept"}}Tausch annehmen{{else}}Tausch ablehnen{{end}}</button>
|
||||
<a class="btn btn-ghost" href="/swap/{{.Data.Token}}">Abbrechen</a>
|
||||
</form>
|
||||
</section>
|
||||
{{else if .Data.CanRespond}}
|
||||
<section class="card swap-action-card">
|
||||
<span class="eyebrow">Ihre Antwort</span>
|
||||
<h3>Möchten Sie tauschen?</h3>
|
||||
<p>Die Anfrage von {{.Data.RequesterPerson.FullName}} ist noch offen. Erst mit Ihrer Bestätigung wird der Plan geändert.</p>
|
||||
<div class="swap-actions">
|
||||
<a class="btn btn-primary" href="/swap/{{.Data.Token}}/accept">{{icon "check"}} Annehmen</a>
|
||||
<a class="btn btn-ghost" href="/swap/{{.Data.Token}}/decline">{{icon "close"}} Ablehnen</a>
|
||||
</div>
|
||||
</section>
|
||||
{{end}}
|
||||
|
||||
{{if .Data.RequestMailto}}
|
||||
<section class="card mail-card">
|
||||
<div class="card-head"><div><span class="eyebrow">E-Mail</span><h3>Anfrage an {{.Data.TargetPerson.FullName}} senden</h3></div>{{icon "mail"}}</div>
|
||||
<p>Der Entwurf enthält beide Termine sowie die Links „Annehmen“ und „Ablehnen“. Öffnen Sie ihn in Ihrem E-Mail-Programm und senden Sie ihn ab.</p>
|
||||
<a class="btn btn-primary" href="{{.Data.RequestMailto}}">{{icon "mail"}} E-Mail-Entwurf öffnen</a>
|
||||
</section>
|
||||
{{end}}
|
||||
|
||||
{{if .Data.ResponseMailto}}
|
||||
<section class="card mail-card">
|
||||
<div class="card-head"><div><span class="eyebrow">E-Mail</span><h3>Antwort an {{.Data.RequesterPerson.FullName}} senden</h3></div>{{icon "mail"}}</div>
|
||||
<p>Der Entwurf enthält Ihre Antwort „{{.Data.StatusLabel}}“ und beide Termine. Öffnen Sie ihn in Ihrem E-Mail-Programm und senden Sie ihn ab.</p>
|
||||
<a class="btn btn-primary" href="{{.Data.ResponseMailto}}">{{icon "mail"}} Antwort-E-Mail öffnen</a>
|
||||
</section>
|
||||
{{end}}
|
||||
|
||||
{{if .Data.ResponseUnavailable}}
|
||||
<section class="card side-note">
|
||||
<span class="eyebrow">Hinweis</span>
|
||||
<p>Die E-Mail-Adresse von {{.Data.RequesterPerson.FullName}} ist für Sie nicht freigegeben. Bitte antworten Sie direkt auf die ursprüngliche Anfrage-E-Mail.</p>
|
||||
</section>
|
||||
{{end}}
|
||||
|
||||
{{if and (eq $request.Status "pending") (not .Data.CanRespond) (not .Data.RequestMailto)}}
|
||||
<section class="card side-note">
|
||||
<span class="eyebrow">Hinweis</span>
|
||||
<p>Der E-Mail-Entwurf mit den Antwort-Links wird nur direkt nach dem Anlegen der Anfrage angezeigt. Die angefragte Person kann die Anfrage weiterhin über ihre E-Mail beantworten.</p>
|
||||
</section>
|
||||
{{end}}
|
||||
</div>
|
||||
{{end}}
|
||||
@@ -0,0 +1,53 @@
|
||||
{{define "content"}}
|
||||
{{$wanted := .Data.Wanted}}
|
||||
<div class="page-stack">
|
||||
<section class="page-intro">
|
||||
<div>
|
||||
<span class="eyebrow">Tausch anfragen</span>
|
||||
<h2>Welchen eigenen Einsatz möchten Sie anbieten?</h2>
|
||||
<p>Die angefragte Person erhält eine E-Mail mit beiden Terminen und kann den Tausch nach der Anmeldung annehmen oder ablehnen. Bis dahin bleibt der Plan unverändert.</p>
|
||||
</div>
|
||||
<div class="intro-actions">
|
||||
<a class="btn btn-ghost btn-small" href="/services/{{$wanted.Service.ID}}">{{icon "left"}} Zurück zum Gottesdienst</a>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<section class="card swap-panel">
|
||||
<div class="card-head">
|
||||
<div><span class="eyebrow">Gewünschter Einsatz</span><h3>{{$wanted.Service.Title}}</h3></div>
|
||||
<span class="badge badge-green">{{$wanted.Assignment.Role.Title}}</span>
|
||||
</div>
|
||||
<div class="swap-assignment">
|
||||
<div><strong>{{longDate $wanted.Service.Date}}</strong><span>{{timeLabel $wanted.Service.TimeMinutes}} Uhr</span></div>
|
||||
<div><strong>{{$wanted.Church.Name}}</strong><span>{{$wanted.Service.Title}}</span></div>
|
||||
<div><strong>{{.Data.Target.FullName}}</strong><span>angefragte Person</span></div>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<section class="card">
|
||||
<div class="card-head"><div><span class="eyebrow">Ihr Angebot</span><h3>Zukünftige eigene Einsätze</h3></div><span class="count-pill">{{len .Data.Options}}</span></div>
|
||||
{{if .Data.Options}}
|
||||
<form method="post" action="/swap/request" class="form-stack">
|
||||
<input type="hidden" name="csrf" value="{{.CSRF}}">
|
||||
<input type="hidden" name="wanted" value="{{$wanted.Assignment.ID}}">
|
||||
<div class="swap-option-list">
|
||||
{{range .Data.Options}}
|
||||
<label class="swap-option">
|
||||
<input type="radio" name="offered" value="{{.Assignment.ID}}" required>
|
||||
<span class="swap-option-main">
|
||||
<strong>{{longDate .Service.Date}} · {{timeLabel .Service.TimeMinutes}} Uhr</strong>
|
||||
<span>{{.Church.Name}} · {{.Service.Title}}</span>
|
||||
</span>
|
||||
<span class="badge badge-neutral">{{.Assignment.Role.Title}}</span>
|
||||
</label>
|
||||
{{end}}
|
||||
</div>
|
||||
<p class="empty-note">Beim Absenden wird noch kein Einsatz geändert. Zuerst öffnet sich ein E-Mail-Entwurf an {{.Data.Target.FullName}}.</p>
|
||||
<button class="btn btn-primary" type="submit">{{icon "mail"}} Tauschanfrage vorbereiten</button>
|
||||
</form>
|
||||
{{else}}
|
||||
<p class="empty-note">Sie haben im selben Dienst keine passenden zukünftigen Einsätze, die Sie anbieten könnten. Ein Tausch ist nur zwischen Einsätzen derselben Rolle möglich, wenn keine Abwesenheit oder Sperre entgegensteht.</p>
|
||||
{{end}}
|
||||
</section>
|
||||
</div>
|
||||
{{end}}
|
||||
@@ -20,6 +20,61 @@
|
||||
<article class="mini-stat"><span class="mini-stat-label">Abwesenheiten</span><strong>{{len .Data.Absences}}</strong><small>hinterlegte Zeiträume</small></article>
|
||||
</section>
|
||||
|
||||
{{with .Data.Sharing}}
|
||||
<section class="card sharing-card">
|
||||
<div class="card-head">
|
||||
<div><span class="eyebrow">E-Mail-Freigaben</span><h3>Wer darf Ihre E-Mail-Adresse sehen?</h3></div>
|
||||
<span class="count-pill">{{len .Readers}}</span>
|
||||
</div>
|
||||
{{if .RosterChanged}}
|
||||
<div class="sharing-notice">
|
||||
<div>
|
||||
<strong>Die Liste der Leserinnen und Leser hat sich geändert.</strong>
|
||||
<p>Bitte prüfen Sie, wer Ihre E-Mail-Adresse sehen darf. Ihre bisherigen Freigaben bleiben unverändert.</p>
|
||||
</div>
|
||||
<form method="post" action="/team/sharing/ack">
|
||||
<input type="hidden" name="csrf" value="{{$.CSRF}}">
|
||||
<button class="btn btn-secondary btn-small" type="submit">Zur Kenntnis genommen</button>
|
||||
</form>
|
||||
</div>
|
||||
{{end}}
|
||||
<p class="sharing-intro">Lektoren und Kommunionhelfer können ihre E-Mail-Adressen gegenseitig freigeben. Für eine Tauschanfrage müssen beide Seiten einverstanden sein. Neue Leser erhalten keinen automatischen Zugriff; wird die Liste erweitert, erscheint nach dem nächsten Anmelden ein Hinweis.</p>
|
||||
<form method="post" action="/team/sharing" class="sharing-form">
|
||||
<input type="hidden" name="csrf" value="{{$.CSRF}}">
|
||||
<label class="check sharing-all"><input type="checkbox" name="share_all" value="1"><span>Alle aktuellen Lektoren und Kommunionhelfer freigeben</span></label>
|
||||
<div class="sharing-grid">
|
||||
{{range .Readers}}
|
||||
<label class="check">
|
||||
<input type="checkbox" name="viewer" value="{{.UserID}}" {{if .Shared}}checked{{end}}>
|
||||
<span>{{.Person.FullName}} <small>{{.Person.RoleLabel}}</small></span>
|
||||
</label>
|
||||
{{else}}
|
||||
<p class="empty-note">Es sind noch keine weiteren Leser-Konten mit diesem Mandanten verknüpft.</p>
|
||||
{{end}}
|
||||
</div>
|
||||
<button class="btn btn-primary btn-small" type="submit">Freigaben speichern</button>
|
||||
</form>
|
||||
</section>
|
||||
|
||||
<section class="card sharing-card">
|
||||
<div class="card-head">
|
||||
<div><span class="eyebrow">Gegenseitig</span><h3>Freigegeben für Sie</h3></div>
|
||||
<span class="count-pill">{{len .SharedWithMe}}</span>
|
||||
</div>
|
||||
<div class="sharing-people">
|
||||
{{range .SharedWithMe}}
|
||||
<div class="sharing-person">
|
||||
<span class="avatar small">{{.Initials}}</span>
|
||||
<span class="sharing-person-name"><strong>{{.FullName}}</strong><small>{{.RoleLabel}}</small></span>
|
||||
{{if .Email}}<a href="mailto:{{.Email}}">{{.Email}}</a>{{else}}<span class="muted">E-Mail noch nicht entschlüsselbar</span>{{end}}
|
||||
</div>
|
||||
{{else}}
|
||||
<p class="empty-note">Noch niemand hat seine E-Mail-Adresse für Sie freigegeben.</p>
|
||||
{{end}}
|
||||
</div>
|
||||
</section>
|
||||
{{end}}
|
||||
|
||||
<div class="team-layout">
|
||||
<section class="card">
|
||||
<div class="card-head">
|
||||
|
||||
Reference in new issue
Block a user