Files
LektorenPlan/web/web/plan_handlers.go
T

430 lines
13 KiB
Go

package web
import (
"fmt"
"net/http"
"sort"
"strconv"
"strings"
"time"
"lektorenplan/domain"
"lektorenplan/store"
)
type planPreset struct {
Label string
Start string
End string
}
type planPresetGroup struct {
Label string
Presets []planPreset
}
type planTimelineMarker struct {
Left float64
Label string
Date string
Kind string
}
type planTimelineSegment struct {
Left float64
Width float64
Label string
Title string
HasData bool
Services int
}
type planTimeline struct {
Markers []planTimelineMarker
Segments []planTimelineSegment
HasData bool
}
type planPageData struct {
Range domain.DayRange
Start string
End string
Rows []domain.DayPlanRow
Churches []domain.Church
People map[string]domain.Person
Stats domain.RangeStatistics
CanEdit bool
PrevStart string
PrevEnd string
NextStart string
NextEnd string
PresetFourStart string
PresetFourEnd string
Presets []planPresetGroup
Timeline planTimeline
FilterPeople []domain.Person
PersonFilter string
}
func flattenRows(rows []domain.DayPlanRow) ([]domain.ServiceOccurrence, []domain.Assignment) {
var services []domain.ServiceOccurrence
var assignments []domain.Assignment
for _, row := range rows {
for _, service := range row.Services {
services = append(services, service.Service)
assignments = append(assignments, service.Assignments...)
}
}
return services, assignments
}
func (s *Server) handlePlan(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.renderNoTenant(w, r)
return
}
canEdit := s.store.CanEditTenant(r.Context(), user, tenant.ID)
rng := s.rangeFromRequest(r)
rows, err := s.store.PlanRows(r.Context(), tenant.ID, rng)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Planung", err.Error())
return
}
churches, err := s.store.Churches(r.Context(), tenant.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Kirchen", err.Error())
return
}
peopleList, err := s.store.People(r.Context(), tenant.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Team", err.Error())
return
}
absences, err := s.store.Absences(r.Context(), tenant.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Abwesenheiten", err.Error())
return
}
people := make(map[string]domain.Person, len(peopleList))
for _, person := range peopleList {
people[person.ID] = person
}
timeline := buildPlanTimeline(rng, rows)
latest, err := s.store.LatestServiceDate(r.Context(), tenant.ID)
if err != nil {
s.renderError(w, r, http.StatusInternalServerError, "Planung", err.Error())
return
}
presets := buildPlanPresets(latest)
var filterPeople []domain.Person
linkedID, linked := user.LinkedPerson(tenant.ID)
switch {
case canEdit:
filterPeople = peopleList
case linked:
for _, person := range peopleList {
if person.ID == linkedID {
filterPeople = append(filterPeople, person)
}
}
}
personFilter := strings.TrimSpace(r.URL.Query().Get("person"))
if !canEdit {
if personFilter != linkedID {
personFilter = ""
}
} else if personFilter != "" {
known := false
for _, person := range peopleList {
if person.ID == personFilter {
known = true
break
}
}
if !known {
personFilter = ""
}
}
if personFilter != "" {
rows = filterPlanRows(rows, personFilter)
}
services, assignments := flattenRows(rows)
stats := domain.ComputeStatistics(rng, services, assignments, peopleList, churches, absences)
prev := domain.MonthRange(domain.AddingMonths(-1, rng.Start))
next := domain.MonthRange(domain.AddingMonths(1, rng.Start))
fourWeeks := domain.DaysRange(28, domain.Today())
data := s.baseView(w, r, "Gottesdienstplan", "plan")
data.Data = planPageData{
Range: rng, Start: domain.Key(rng.Start), End: domain.Key(rng.End),
Rows: rows, Churches: churches, People: people, Stats: stats,
CanEdit: canEdit,
PrevStart: domain.Key(prev.Start), PrevEnd: domain.Key(prev.End),
NextStart: domain.Key(next.Start), NextEnd: domain.Key(next.End),
PresetFourStart: domain.Key(fourWeeks.Start), PresetFourEnd: domain.Key(fourWeeks.End),
Presets: presets, Timeline: timeline, FilterPeople: filterPeople, PersonFilter: personFilter,
}
s.renderPage(w, r, "plan", data)
}
func filterPlanRows(rows []domain.DayPlanRow, personID string) []domain.DayPlanRow {
out := make([]domain.DayPlanRow, 0, len(rows))
for _, row := range rows {
filtered := domain.DayPlanRow{Date: row.Date, LiturgicalDay: row.LiturgicalDay}
for _, service := range row.Services {
for _, assignment := range service.Assignments {
if assignment.PersonID == personID {
filtered.Services = append(filtered.Services, service)
break
}
}
}
if len(filtered.Services) > 0 {
out = append(out, filtered)
}
}
return out
}
func buildPlanTimeline(rng domain.DayRange, rows []domain.DayPlanRow) planTimeline {
totalDays := rng.DayCount()
if totalDays < 1 {
totalDays = 1
}
position := func(date time.Time) float64 {
offset := domain.DaysBetween(rng.Start, date)
if offset < 0 {
offset = 0
}
if offset >= totalDays {
offset = totalDays - 1
}
return float64(offset) / float64(totalDays) * 100
}
servicesByDay := map[string]int{}
for _, row := range rows {
servicesByDay[domain.Key(row.Date)] = len(row.Services)
}
type markerCandidate struct {
date time.Time
label string
kind string
}
var candidates []markerCandidate
for year := domain.Year(rng.Start) - 1; year <= domain.Year(rng.End)+1; year++ {
candidates = append(candidates,
markerCandidate{domain.MustDate(domain.KeyYMD(year, 1, 1)), "Jahresbeginn", "calendar"},
markerCandidate{domain.MustDate(domain.KeyYMD(year, 4, 1)), "2. Quartal", "calendar"},
markerCandidate{domain.MustDate(domain.KeyYMD(year, 7, 1)), "3. Quartal", "calendar"},
markerCandidate{domain.MustDate(domain.KeyYMD(year, 10, 1)), "4. Quartal", "calendar"},
markerCandidate{domain.EasterSunday(year), "Ostern", "church"},
markerCandidate{domain.Pentecost(year), "Pfingsten", "church"},
markerCandidate{domain.ChristKing(year), "Christkönig", "church"},
markerCandidate{domain.AdventStart(year), "1. Advent", "church"},
markerCandidate{domain.MustDate(domain.KeyYMD(year, 12, 25)), "Weihnachten", "church"},
)
}
sort.SliceStable(candidates, func(i, j int) bool { return candidates[i].date.Before(candidates[j].date) })
var markers []planTimelineMarker
for _, candidate := range candidates {
if !rng.Contains(candidate.date) {
continue
}
markers = append(markers, planTimelineMarker{
Left: position(candidate.date), Label: candidate.label,
Date: domain.Key(candidate.date), Kind: candidate.kind,
})
}
var segments []planTimelineSegment
hasData := false
cursor := rng.Start
for !cursor.After(rng.End) {
monthEnd := domain.EndOfMonth(cursor)
if monthEnd.After(rng.End) {
monthEnd = rng.End
}
segment := planTimelineSegment{
Left: position(cursor),
Width: float64(domain.DaysBetween(cursor, monthEnd)+1) / float64(totalDays) * 100,
Label: domain.ShortMonthName(cursor),
}
if domain.Month(cursor) == 1 || domain.Year(rng.Start) != domain.Year(rng.End) {
segment.Label += " " + strconv.Itoa(domain.Year(cursor))
}
for !cursor.After(monthEnd) {
segment.Services += servicesByDay[domain.Key(cursor)]
cursor = domain.AddingDays(1, cursor)
}
segment.HasData = segment.Services > 0
hasData = hasData || segment.HasData
segment.Title = fmt.Sprintf("%s · %d Gottesdienste", segment.Label, segment.Services)
segments = append(segments, segment)
}
return planTimeline{Markers: markers, Segments: segments, HasData: hasData}
}
func buildPlanPresets(latest *time.Time) []planPresetGroup {
today := domain.Today()
currentQuarter := domain.QuarterRange(today)
nextQuarter := domain.QuarterRange(domain.AddingMonths(3, currentQuarter.Start))
christmasStart := domain.MustDate(domain.KeyYMD(domain.Year(today), 12, 24))
christmasEnd := domain.MustDate(domain.KeyYMD(domain.Year(today)+1, 1, 6))
if domain.Month(today) == 1 && domain.DayNumber(today) <= 6 {
// Still inside the Christmas season that began last December.
christmasStart = domain.MustDate(domain.KeyYMD(domain.Year(today)-1, 12, 24))
christmasEnd = domain.MustDate(domain.KeyYMD(domain.Year(today), 1, 6))
}
easterStart := domain.EasterSunday(domain.Year(today))
easterEnd := domain.Pentecost(domain.Year(today))
if today.After(easterEnd) {
easterStart = domain.EasterSunday(domain.Year(today) + 1)
easterEnd = domain.Pentecost(domain.Year(today) + 1)
}
preset := func(label string, rng domain.DayRange) planPreset {
return planPreset{Label: label, Start: domain.Key(rng.Start), End: domain.Key(rng.End)}
}
groups := []planPresetGroup{
{Label: "Quartale", Presets: []planPreset{
preset("Dieses Quartal", currentQuarter),
preset("Nächstes Quartal", nextQuarter),
}},
{Label: "Kirchenjahr", Presets: []planPreset{
preset("Weihnachtszeit", domain.NewDayRange(christmasStart, christmasEnd)),
preset("Osterzeit", domain.NewDayRange(easterStart, easterEnd)),
}},
}
if latest != nil {
var after []planPreset
for _, months := range []int{3, 6, 12} {
start := domain.AddingDays(1, *latest)
end := domain.AddingMonths(months, start)
after = append(after, preset(fmt.Sprintf("%d Monate nach Planungsende", months),
domain.NewDayRange(start, end)))
}
groups = append(groups, planPresetGroup{Label: "Anschlussplanung", Presets: after})
}
return groups
}
func (s *Server) handleGenerateServices(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/plan")
return
}
rng := formRange(r)
created, err := s.store.GenerateServices(r.Context(), tenant.ID, rng, true)
if err != nil {
s.setFlash(w, "Gottesdienste konnten nicht erzeugt werden: "+err.Error(), "error")
} else if created == 0 {
s.setFlash(w, "Alle regelmäßigen Gottesdienste im Zeitraum sind bereits vorhanden.", "info")
} else {
s.setFlash(w, fmt.Sprintf("%d Gottesdienste aus der Gottesdienstordnung erzeugt.", created), "success")
}
s.redirect(w, r, "/plan?start="+domain.Key(rng.Start)+"&end="+domain.Key(rng.End))
}
func (s *Server) handleAutoPlan(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/plan")
return
}
rng := formRange(r)
options := s.planningOptions(r, tenant.ID)
options.ReplaceExisting = r.FormValue("replace") == "1" || r.FormValue("replace") == "on"
services, err := s.store.Services(r.Context(), tenant.ID, rng)
if err != nil {
s.setFlash(w, "Planung fehlgeschlagen: "+err.Error(), "error")
s.redirect(w, r, "/plan")
return
}
if len(services) == 0 {
s.setFlash(w, "Für den Zeitraum sind keine Gottesdienste vorhanden. Bitte zuerst Termine erzeugen.", "info")
s.redirect(w, r, "/plan?start="+domain.Key(rng.Start)+"&end="+domain.Key(rng.End))
return
}
people, err := s.store.People(r.Context(), tenant.ID)
if err != nil {
s.setFlash(w, "Planung fehlgeschlagen: "+err.Error(), "error")
s.redirect(w, r, "/plan")
return
}
absences, err := s.store.Absences(r.Context(), tenant.ID)
if err != nil {
s.setFlash(w, "Planung fehlgeschlagen: "+err.Error(), "error")
s.redirect(w, r, "/plan")
return
}
churches, err := s.store.Churches(r.Context(), tenant.ID)
if err != nil {
s.setFlash(w, "Planung fehlgeschlagen: "+err.Error(), "error")
s.redirect(w, r, "/plan")
return
}
existing, err := s.store.Assignments(r.Context(), tenant.ID, rng)
if err != nil {
s.setFlash(w, "Planung fehlgeschlagen: "+err.Error(), "error")
s.redirect(w, r, "/plan")
return
}
planner := domain.ServicePlanner{
People: people, Absences: absences, Services: services,
ExistingAssignments: existing, Churches: churches, Options: options,
}
result := planner.Plan()
if err := s.store.SavePlan(r.Context(), tenant.ID, result.Assignments, rng, options.ReplaceExisting); err != nil {
s.setFlash(w, "Der Plan konnte nicht gespeichert werden: "+err.Error(), "error")
} else {
kind := "success"
if len(result.Unfilled) > 0 {
kind = "info"
}
s.setFlash(w, result.Message, kind)
}
s.redirect(w, r, "/plan?start="+domain.Key(rng.Start)+"&end="+domain.Key(rng.End))
}
func formRange(r *http.Request) domain.DayRange {
start, startOK := domain.DateFromKey(strings.TrimSpace(r.FormValue("start")))
end, endOK := domain.DateFromKey(strings.TrimSpace(r.FormValue("end")))
today := domain.Today()
if !startOK {
start = domain.StartOfMonth(today)
}
if !endOK {
end = domain.EndOfMonth(start)
}
if end.Before(start) {
start, end = end, start
}
if domain.DaysBetween(start, end) > 400 {
end = domain.AddingDays(400, start)
}
return domain.NewDayRange(start, end)
}
func (s *Server) renderNoTenant(w http.ResponseWriter, r *http.Request) {
data := s.baseView(w, r, "Kein Mandant", "")
data.Data = struct {
IsAdmin bool
}{IsAdmin: data.IsAdmin}
s.renderPage(w, r, "no_tenant", data)
}
func parseInt(value string, fallback int) int {
parsed, err := strconv.Atoi(strings.TrimSpace(value))
if err != nil {
return fallback
}
return parsed
}