430 lines
13 KiB
Go
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
|
|
}
|