Files
LektorenPlan/web/domain/models.go
T

1019 lines
24 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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 }
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
}