package domain import ( "fmt" "sort" "strconv" "strings" "time" ) // Role is a service role. Lector and helper do not exclude each other. type Role string const ( RoleLector Role = "lector" RoleHelper Role = "helper" ) var AllRoles = []Role{RoleLector, RoleHelper} func (r Role) Title() string { if r == RoleHelper { return "Kommunionhelfer" } return "Lektor" } func (r Role) Plural() string { if r == RoleHelper { return "Kommunionhelfer" } return "Lektoren" } func (r Role) ShortCode() string { if r == RoleHelper { return "K" } return "L" } func (r Role) Complementary() Role { if r == RoleLector { return RoleHelper } return RoleLector } func (r Role) IsValid() bool { return r == RoleLector || r == RoleHelper } // RoleTitles returns a readable list of roles in canonical order. A person can // hold both roles in the same service, which is shown as // "Lektor und Kommunionhelfer" instead of two separate entries. func RoleTitles(roles []Role) string { var titles []string for _, role := range AllRoles { for _, candidate := range roles { if candidate == role { titles = append(titles, role.Title()) break } } } switch len(titles) { case 0: return "" case 1: return titles[0] default: return strings.Join(titles[:len(titles)-1], ", ") + " und " + titles[len(titles)-1] } } type ChurchSymbol string const ( SymbolBasilica ChurchSymbol = "basilica" SymbolGothic ChurchSymbol = "gothic" SymbolModern ChurchSymbol = "modern" SymbolRotunda ChurchSymbol = "rotunda" SymbolRoundTower ChurchSymbol = "roundTower" SymbolChapel ChurchSymbol = "chapel" ) var AllChurchSymbols = []ChurchSymbol{ SymbolBasilica, SymbolGothic, SymbolModern, SymbolRotunda, SymbolRoundTower, SymbolChapel, } func (s ChurchSymbol) Caption() string { switch s { case SymbolBasilica: return "Romanische Basilika" case SymbolGothic: return "Neugotische Kirche" case SymbolModern: return "Moderner Kirchenbau" case SymbolRotunda: return "Rundkirche" case SymbolRoundTower: return "Rundturm" default: return "Kapelle" } } type Church struct { ID string `json:"id"` Name string `json:"name"` ShortName string `json:"shortName"` Symbol ChurchSymbol `json:"symbol"` ColorHex string `json:"colorHex"` Address string `json:"address"` SortIndex int `json:"sortIndex"` Notes string `json:"notes"` } // WeekdayPeriod narrows a preferred weekday to a part of the day. type WeekdayPeriod string const ( PeriodAllDay WeekdayPeriod = "all" PeriodMorning WeekdayPeriod = "morning" PeriodAfternoon WeekdayPeriod = "afternoon" PeriodEvening WeekdayPeriod = "evening" ) var AllWeekdayPeriods = []WeekdayPeriod{PeriodAllDay, PeriodMorning, PeriodAfternoon, PeriodEvening} func (p WeekdayPeriod) Label() string { switch p { case PeriodMorning: return "vormittags (0–12 Uhr)" case PeriodAfternoon: return "nachmittags (12–17 Uhr)" case PeriodEvening: return "abends (ab 17 Uhr)" default: return "ganztägig" } } func (p WeekdayPeriod) ShortLabel() string { switch p { case PeriodMorning: return "vormittags" case PeriodAfternoon: return "nachmittags" case PeriodEvening: return "abends" default: return "ganztägig" } } func (p WeekdayPeriod) IsValid() bool { return p == PeriodAllDay || p == PeriodMorning || p == PeriodAfternoon || p == PeriodEvening } // Matches reports whether a service starting at timeMinutes falls into the // selected part of the day. Morning is 0–12, afternoon 12–17, evening after 17. func (p WeekdayPeriod) Matches(timeMinutes int) bool { switch p { case PeriodMorning: return timeMinutes < 12*60 case PeriodAfternoon: return timeMinutes >= 12*60 && timeMinutes < 17*60 case PeriodEvening: return timeMinutes >= 17*60 default: return true } } // WeekdayPeriodPreference stores the selected part of the day for one // preferred weekday. Weekdays without an entry count as all day. type WeekdayPeriodPreference struct { Weekday int `json:"weekday"` Period WeekdayPeriod `json:"period"` } type Person struct { ID string `json:"id"` ShortCode string `json:"shortCode"` FirstName string `json:"firstName"` LastName string `json:"lastName"` Roles []Role `json:"roles"` Email string `json:"email"` EmailLocked bool `json:"-"` PreferredChurchIDs []string `json:"preferredChurchIDs"` PreferredWeekdays []int `json:"preferredWeekdays"` PreferredWeekdayPeriods []WeekdayPeriodPreference `json:"preferredWeekdayPeriods"` PreferredServiceTitles []string `json:"preferredServiceTitles"` MaxPerMonth int `json:"maxPerMonth"` AllowBeyondPreferences bool `json:"allowBeyondPreferences"` Active bool `json:"active"` Notes string `json:"notes"` } func (p Person) FullName() string { return strings.TrimSpace(p.FirstName + " " + p.LastName) } func (p Person) Initials() string { f := "" l := "" if r := []rune(p.FirstName); len(r) > 0 { f = string(r[0]) } if r := []rune(p.LastName); len(r) > 0 { l = string(r[0]) } return strings.ToUpper(f + l) } func (p Person) AbbreviatedName() string { if r := []rune(p.FirstName); len(r) > 0 { return string(r[0]) + ". " + p.LastName } return p.LastName } // DisplayShort is the guest-facing label: an explicitly maintained Kürzel wins, // otherwise the initials from first and last name. func (p Person) DisplayShort() string { if code := strings.TrimSpace(p.ShortCode); code != "" { return code } return p.Initials() } // WeekdayPeriodFor returns the selected part of the day for a weekday. func (p Person) WeekdayPeriodFor(weekday int) WeekdayPeriod { for _, preference := range p.PreferredWeekdayPeriods { if preference.Weekday == weekday && preference.Period.IsValid() { return preference.Period } } return PeriodAllDay } // MatchesWeekdayPreference reports whether the service day and time satisfy // the weekday preferences. High feasts count like Sundays, so a Sunday // preference also covers them. An empty weekday list means no restriction. func (p Person) MatchesWeekdayPreference(weekday, timeMinutes int, highFeast bool) bool { if len(p.PreferredWeekdays) == 0 { return true } candidates := []int{weekday} if highFeast && weekday != 1 { candidates = append(candidates, 1) } for _, day := range candidates { if IntContains(p.PreferredWeekdays, day) && p.WeekdayPeriodFor(day).Matches(timeMinutes) { return true } } return false } // PreferenceNote is the free-text planning note shown next to assignments. func (p Person) PreferenceNote() string { return strings.TrimSpace(p.Notes) } // PersonLabels computes stable short labels for a set of people. If two people // share a label, every member of that group gets a running number appended. func PersonLabels(people []Person) map[string]string { sorted := append([]Person(nil), people...) sort.SliceStable(sorted, func(i, j int) bool { if sorted[i].LastName != sorted[j].LastName { return sorted[i].LastName < sorted[j].LastName } if sorted[i].FirstName != sorted[j].FirstName { return sorted[i].FirstName < sorted[j].FirstName } return sorted[i].ID < sorted[j].ID }) base := make(map[string]string, len(sorted)) counts := map[string]int{} for _, person := range sorted { label := person.DisplayShort() base[person.ID] = label counts[label]++ } seen := map[string]int{} labels := make(map[string]string, len(sorted)) for _, person := range sorted { label := base[person.ID] if counts[label] > 1 { seen[label]++ label += strconv.Itoa(seen[label]) } labels[person.ID] = label } return labels } func (p Person) RoleLabel() string { var parts []string for _, role := range AllRoles { if p.CanFill(role) { parts = append(parts, role.Title()) } } return strings.Join(parts, " · ") } func (p Person) CanFill(role Role) bool { for _, r := range p.Roles { if r == role { return true } } return false } func (p Person) HasRole(role Role) bool { return p.CanFill(role) } func (p Person) HasPreference() bool { return len(p.PreferredChurchIDs) > 0 || len(p.PreferredWeekdays) > 0 || len(p.PreferredServiceTitles) > 0 } func IntContains(values []int, needle int) bool { for _, v := range values { if v == needle { return true } } return false } func StringContains(values []string, needle string) bool { for _, v := range values { if v == needle { return true } } return false } func UniqueStrings(values []string) []string { seen := map[string]bool{} var out []string for _, v := range values { if !seen[v] { seen[v] = true out = append(out, v) } } return out } type Absence struct { ID string `json:"id"` PersonID string `json:"personID"` Start time.Time `json:"start"` End time.Time `json:"end"` Reason string `json:"reason"` } func (a Absence) Range() DayRange { return NewDayRange(a.Start, a.End) } func (a Absence) Overlaps(t time.Time) bool { return Normalize(t).Compare(Normalize(a.Start)) >= 0 && Normalize(t).Compare(Normalize(a.End)) <= 0 } func (a Absence) Label() string { start := MediumString(a.Start) end := MediumString(a.End) base := start if start != end { base = start + " – " + end } if a.Reason == "" { return base } return base + " · " + a.Reason } type ServiceTemplate struct { ID string `json:"id"` ChurchID string `json:"churchID"` Weekday int `json:"weekday"` TimeMinutes int `json:"timeMinutes"` Title string `json:"title"` LectorsNeeded int `json:"lectorsNeeded"` HelpersNeeded int `json:"helpersNeeded"` ValidFrom time.Time `json:"validFrom"` ValidTo *time.Time `json:"validTo"` Active bool `json:"active"` Notes string `json:"notes"` } func (t ServiceTemplate) TimeLabel() string { return TimeString(t.TimeMinutes) } func (t ServiceTemplate) WeekdayLabel() string { if t.Weekday >= 1 && t.Weekday <= 7 { return weekdayNames[t.Weekday] } return "?" } func (t ServiceTemplate) RequirementLabel() string { var parts []string if t.LectorsNeeded > 0 { parts = append(parts, pluralCount(t.LectorsNeeded, "Lektor", "Lektoren")) } if t.HelpersNeeded > 0 { parts = append(parts, pluralCount(t.HelpersNeeded, "Kommunionhelfer", "Kommunionhelfer")) } if len(parts) == 0 { return "Keine Dienste" } return strings.Join(parts, " · ") } func pluralCount(n int, singular, plural string) string { if n == 1 { return "1× " + singular } return fmt.Sprintf("%d× %s", n, plural) } func (t ServiceTemplate) IsValid(on time.Time) bool { if !t.Active { return false } day := Normalize(on) if Weekday(day) != t.Weekday { return false } if day.Before(Normalize(t.ValidFrom)) { return false } if t.ValidTo != nil && day.After(Normalize(*t.ValidTo)) { return false } return true } type ServiceException struct { ID string `json:"id"` TemplateID string `json:"templateID"` Date time.Time `json:"date"` Reason string `json:"reason"` } type ServiceKind string const ( KindRegular ServiceKind = "regular" KindSpecial ServiceKind = "special" ) func (k ServiceKind) Title() string { if k == KindSpecial { return "Sondergottesdienst" } return "Regulär" } type ServiceOccurrence struct { ID string `json:"id"` ChurchID string `json:"churchID"` Location *string `json:"location"` TemplateID *string `json:"templateID"` Date time.Time `json:"date"` TimeMinutes int `json:"timeMinutes"` Title string `json:"title"` LectorsNeeded int `json:"lectorsNeeded"` HelpersNeeded int `json:"helpersNeeded"` Kind ServiceKind `json:"kind"` Notes string `json:"notes"` Locked bool `json:"locked"` CreatedAt time.Time `json:"createdAt"` } func (s ServiceOccurrence) PlaceName(church Church) string { if s.Location != nil && strings.TrimSpace(*s.Location) != "" { return *s.Location } return church.Name } func (s ServiceOccurrence) TimeLabel() string { return TimeString(s.TimeMinutes) } func (s ServiceOccurrence) DateKey() string { return Key(s.Date) } func (s ServiceOccurrence) RequiredSlots() int { return s.LectorsNeeded + s.HelpersNeeded } func (s ServiceOccurrence) RequiredCount(role Role) int { if role == RoleHelper { return s.HelpersNeeded } return s.LectorsNeeded } func (s ServiceOccurrence) RolesNeeded() []Role { var roles []Role if s.LectorsNeeded > 0 { roles = append(roles, RoleLector) } if s.HelpersNeeded > 0 { roles = append(roles, RoleHelper) } return roles } type Assignment struct { ID string `json:"id"` ServiceID string `json:"serviceID"` PersonID string `json:"personID"` Role Role `json:"role"` Locked bool `json:"locked"` BeyondPreferences bool `json:"beyondPreferences"` Note string `json:"note"` CreatedAt time.Time `json:"createdAt"` } // Liturgical model --------------------------------------------------------- type LiturgicalRank string const ( RankWeekday LiturgicalRank = "" RankMemorial LiturgicalRank = "g" RankObligatoryMemorial LiturgicalRank = "G" RankFeast LiturgicalRank = "F" RankSolemnity LiturgicalRank = "H" ) func (r LiturgicalRank) Label() string { switch r { case RankMemorial: return "Gedenktag" case RankObligatoryMemorial: return "Gebotener Gedenktag" case RankFeast: return "Fest" case RankSolemnity: return "Hochfest" default: return "Wochentag" } } func (r LiturgicalRank) ShortLabel() string { return string(r) } func (r LiturgicalRank) Priority() int { switch r { case RankMemorial: return 1 case RankObligatoryMemorial: return 2 case RankFeast: return 3 case RankSolemnity: return 4 default: return 0 } } func (r LiturgicalRank) IsFeast() bool { return r == RankFeast || r == RankSolemnity } type LiturgicalColor string const ( ColorWhite LiturgicalColor = "w" ColorRed LiturgicalColor = "r" ColorGreen LiturgicalColor = "g" ColorViolet LiturgicalColor = "v" ColorRose LiturgicalColor = "ros" ColorBlack LiturgicalColor = "s" ColorGold LiturgicalColor = "gold" ) func (c LiturgicalColor) Label() string { switch c { case ColorRed: return "Rot" case ColorGreen: return "Grün" case ColorViolet: return "Violett" case ColorRose: return "Rosa" case ColorBlack: return "Schwarz" case ColorGold: return "Gold" default: return "Weiß" } } func LiturgicalColorFromAPI(value string) LiturgicalColor { switch strings.ToLower(strings.TrimSpace(value)) { case "r": return ColorRed case "g": return ColorGreen case "v": return ColorViolet case "ros", "rose": return ColorRose case "s", "sw": return ColorBlack case "gold": return ColorGold default: return ColorWhite } } func LiturgicalColorHex(c LiturgicalColor) string { switch c { case ColorRed: return "#A5453F" case ColorGreen: return "#4F7D5A" case ColorViolet: return "#6E4B8E" case ColorRose: return "#C07A8B" case ColorBlack: return "#4A4440" default: return "#C2A14D" } } type LiturgicalSeason string const ( SeasonAdvent LiturgicalSeason = "advent" SeasonChristmas LiturgicalSeason = "christmas" SeasonOrdinary LiturgicalSeason = "ordinary" SeasonLent LiturgicalSeason = "lent" SeasonEaster LiturgicalSeason = "easter" ) func (s LiturgicalSeason) Title() string { switch s { case SeasonAdvent: return "Advent" case SeasonChristmas: return "Weihnachtszeit" case SeasonLent: return "Österliche Bußzeit" case SeasonEaster: return "Osterzeit" default: return "Jahreskreis" } } func (s LiturgicalSeason) ShortTitle() string { switch s { case SeasonAdvent: return "Advent" case SeasonChristmas: return "Weihnachten" case SeasonLent: return "Fastenzeit" case SeasonEaster: return "Osterzeit" default: return "Jahreskreis" } } func (s LiturgicalSeason) ColorHex() string { switch s { case SeasonAdvent: return "#6E4B8E" case SeasonChristmas: return "#B58A3B" case SeasonLent: return "#75516F" case SeasonEaster: return "#C9A227" default: return "#4F7D5A" } } type FeastSymbol string const ( FeastCross FeastSymbol = "cross" FeastStar FeastSymbol = "star" FeastFlame FeastSymbol = "flame" FeastSun FeastSymbol = "sun" FeastLily FeastSymbol = "lily" FeastCrown FeastSymbol = "crown" FeastHeart FeastSymbol = "heart" FeastBook FeastSymbol = "book" FeastCandle FeastSymbol = "candle" FeastDove FeastSymbol = "dove" ) func (f FeastSymbol) Label() string { switch f { case FeastCross: return "Kreuz" case FeastStar: return "Stern" case FeastFlame: return "Feuer" case FeastSun: return "Sonne" case FeastLily: return "Lilie" case FeastCrown: return "Krone" case FeastHeart: return "Herz" case FeastBook: return "Buch" case FeastCandle: return "Licht" case FeastDove: return "Taube" default: return "" } } type Readings struct { First string `json:"first"` Psalm string `json:"psalm"` Second string `json:"second"` Gospel string `json:"gospel"` } func (r Readings) IsEmpty() bool { return r.First == "" && r.Psalm == "" && r.Second == "" && r.Gospel == "" } func (r Readings) ShortLabel() string { var parts []string if r.First != "" { parts = append(parts, r.First) } if r.Second != "" { parts = append(parts, r.Second) } if r.Gospel != "" { parts = append(parts, r.Gospel) } return strings.Join(parts, " · ") } func (r Readings) FullLabel() string { var lines []string if r.First != "" { lines = append(lines, "1. Lesung: "+r.First) } if r.Psalm != "" { lines = append(lines, "Psalm: "+r.Psalm) } if r.Second != "" { lines = append(lines, "2. Lesung: "+r.Second) } if r.Gospel != "" { lines = append(lines, "Evangelium: "+r.Gospel) } return strings.Join(lines, "\n") } type LiturgicalDay struct { Date time.Time `json:"date"` Title string `json:"title"` Rank LiturgicalRank `json:"rank"` Color LiturgicalColor `json:"color"` Remark string `json:"remark"` Readings Readings `json:"readings"` IsObligation bool `json:"isObligation"` Source string `json:"source"` UpdatedAt time.Time `json:"updatedAt"` } func (d LiturgicalDay) DateKey() string { return Key(d.Date) } func (d LiturgicalDay) IsSunday() bool { return IsSunday(d.Date) } func (d LiturgicalDay) IsHighFeast() bool { return d.Rank == RankSolemnity || strings.Contains(strings.ToLower(d.Title), "hochfest") } func (d LiturgicalDay) IsFeast() bool { return d.Rank.IsFeast() || d.IsHighFeast() } func (d LiturgicalDay) Season() LiturgicalSeason { return SeasonFor(d.Date) } func (d LiturgicalDay) Symbol() FeastSymbol { return SymbolFor(d.Title, d.Rank, d.Date) } func (d LiturgicalDay) DisplayTitle() string { if d.Title == "" { if d.IsSunday() { return "Sonntag" } return LongString(d.Date) } return d.Title } func (d LiturgicalDay) BadgeText() string { if d.IsSunday() && d.IsObligation { return "Sonntag" } if d.Rank != RankWeekday { return d.Rank.Label() } if d.IsObligation { return "Gebotener Feiertag" } return "" } func (d LiturgicalDay) ColorHex() string { return LiturgicalColorHex(d.Color) } // View support ------------------------------------------------------------- type ServiceWithAssignments struct { Service ServiceOccurrence Church Church Assignments []Assignment } func (s ServiceWithAssignments) AssignmentsFor(role Role) []Assignment { var out []Assignment for _, a := range s.Assignments { if a.Role == role { out = append(out, a) } } return out } func (s ServiceWithAssignments) OpenSlotsFor(role Role) int { open := s.Service.RequiredCount(role) - len(s.AssignmentsFor(role)) if open < 0 { return 0 } return open } func (s ServiceWithAssignments) FilledSlots() int { return len(s.Assignments) } func (s ServiceWithAssignments) OpenSlots() int { open := s.Service.RequiredSlots() - len(s.Assignments) if open < 0 { return 0 } return open } func (s ServiceWithAssignments) IsFullyStaffed() bool { return s.OpenSlots() == 0 } type DayPlanRow struct { Date time.Time LiturgicalDay *LiturgicalDay Services []ServiceWithAssignments } func (r DayPlanRow) DateKey() string { return Key(r.Date) } func (r DayPlanRow) OpenSlots() int { total := 0 for _, s := range r.Services { total += s.OpenSlots() } return total } func (r DayPlanRow) AssignmentCount() int { total := 0 for _, s := range r.Services { total += len(s.Assignments) } return total } func (r DayPlanRow) HasServices() bool { return len(r.Services) > 0 } // HasBeyondPreferences marks days with at least one assignment that goes // beyond the person's preferences. func (r DayPlanRow) HasBeyondPreferences() bool { for _, service := range r.Services { for _, assignment := range service.Assignments { if assignment.BeyondPreferences { return true } } } return false } func (r DayPlanRow) IsSunday() bool { return (r.LiturgicalDay != nil && r.LiturgicalDay.IsSunday()) || IsSunday(r.Date) } func (r DayPlanRow) IsHighFeast() bool { return r.LiturgicalDay != nil && r.LiturgicalDay.IsHighFeast() } func (r DayPlanRow) IsFeast() bool { return r.LiturgicalDay != nil && r.LiturgicalDay.IsFeast() } func (r DayPlanRow) IsSpecialDay() bool { if r.IsSunday() || r.IsFeast() { return true } return r.LiturgicalDay != nil && r.LiturgicalDay.IsObligation } func (r DayPlanRow) IsObligation() bool { return r.LiturgicalDay != nil && r.LiturgicalDay.IsObligation } func (r DayPlanRow) ServicesForChurch(churchID string) []ServiceWithAssignments { var out []ServiceWithAssignments for _, s := range r.Services { if s.Church.ID == churchID { out = append(out, s) } } return out } type UnfilledSlot struct { Service ServiceOccurrence ChurchName string Role Role Reason string } func (u UnfilledSlot) ID() string { return u.Service.ID + "-" + string(u.Role) } type PersonStat struct { Person Person Total int Lectors int Helpers int ChurchCounts map[string]int PreferredHits int SundayCount int LastAssignment *time.Time } func (s PersonStat) PreferenceRate() float64 { if s.Total == 0 { return 0 } return float64(s.PreferredHits) / float64(s.Total) } type ChurchStat struct { Church Church Assignments int Services int OpenSlots int PersonCount int } type RangeStatistics struct { Range DayRange ServiceCount int AssignmentCount int OpenSlots int RequiredSlots int PersonStats []PersonStat ChurchStats []ChurchStat MonthlyCounts map[string]int SundayServiceCount int SundayFilled int PreferenceHits int PreferenceEligible int AbsenceDays int } func (s RangeStatistics) CoverageRate() float64 { if s.RequiredSlots == 0 { return 1 } return float64(s.AssignmentCount) / float64(s.RequiredSlots) } func (s RangeStatistics) PreferenceRate() float64 { if s.PreferenceEligible == 0 { return 0 } return float64(s.PreferenceHits) / float64(s.PreferenceEligible) } func (s RangeStatistics) ActivePeople() int { n := 0 for _, p := range s.PersonStats { if p.Total > 0 { n++ } } return n } func (s RangeStatistics) AverageAssignments() float64 { count, total := 0, 0 for _, p := range s.PersonStats { if p.Total > 0 { count++ total += p.Total } } if count == 0 { return 0 } return float64(total) / float64(count) } type PlannerOptions struct { ReplaceExisting bool RespectPreferredWeekdays bool AllowBeyondPreferences bool AllowDoubleRolesOnSameDay bool WeightChurchPreference float64 WeightServicePreference float64 WeightFairness float64 WeightDualRolePreference float64 MaxAssignmentsPerDay int } func DefaultPlannerOptions() PlannerOptions { return PlannerOptions{ RespectPreferredWeekdays: true, WeightChurchPreference: 8, WeightServicePreference: 4, WeightFairness: 2.2, WeightDualRolePreference: 14, MaxAssignmentsPerDay: 1, } } type PlanResult struct { Assignments []Assignment Unfilled []UnfilledSlot FilledCount int Message string } type CandidateSuggestion struct { Person Person Score float64 Warnings []string Blocked bool Preferred bool BeyondPreferences bool TotalAssignments int }