Web Variante in Go V0.1
This commit is contained in:
1 parent
f9e3e94629
commit
692b9b6ef8
60 files changed
+13140
No files matched your search
@@ -0,0 +1,510 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ServicePlanner implements the automatic assignment rules of the macOS app.
|
||||
type ServicePlanner struct {
|
||||
People []Person
|
||||
Absences []Absence
|
||||
Services []ServiceOccurrence
|
||||
ExistingAssignments []Assignment
|
||||
Churches []Church
|
||||
Options PlannerOptions
|
||||
}
|
||||
|
||||
type candidateResult struct {
|
||||
person *Person
|
||||
reason string
|
||||
}
|
||||
|
||||
func (p ServicePlanner) Plan() PlanResult {
|
||||
activePeople := make([]Person, 0, len(p.People))
|
||||
for _, person := range p.People {
|
||||
if person.Active {
|
||||
activePeople = append(activePeople, person)
|
||||
}
|
||||
}
|
||||
absencesByPerson := map[string][]Absence{}
|
||||
for _, a := range p.Absences {
|
||||
absencesByPerson[a.PersonID] = append(absencesByPerson[a.PersonID], a)
|
||||
}
|
||||
churchNames := map[string]string{}
|
||||
for _, c := range p.Churches {
|
||||
churchNames[c.ID] = c.Name
|
||||
}
|
||||
serviceByID := map[string]ServiceOccurrence{}
|
||||
for _, s := range p.Services {
|
||||
serviceByID[s.ID] = s
|
||||
}
|
||||
|
||||
working := make([]Assignment, 0, len(p.ExistingAssignments))
|
||||
for _, a := range p.ExistingAssignments {
|
||||
if !p.Options.ReplaceExisting || a.Locked {
|
||||
working = append(working, a)
|
||||
}
|
||||
}
|
||||
|
||||
totalByPerson := map[string]int{}
|
||||
monthByPerson := map[string]int{}
|
||||
dayServicesByPerson := map[string]map[string]bool{}
|
||||
churchByPerson := map[string]map[string]int{}
|
||||
lastDateByPerson := map[string]time.Time{}
|
||||
roleCounts := map[string]map[Role]int{}
|
||||
rolesByServicePerson := map[string]map[string]map[Role]bool{}
|
||||
|
||||
applyToCounts := func(a Assignment, s ServiceOccurrence) {
|
||||
totalByPerson[a.PersonID]++
|
||||
monthByPerson[a.PersonID+"|"+MonthKey(s.Date)]++
|
||||
key := a.PersonID + "|" + s.DateKey()
|
||||
if dayServicesByPerson[key] == nil {
|
||||
dayServicesByPerson[key] = map[string]bool{}
|
||||
}
|
||||
dayServicesByPerson[key][s.ID] = true
|
||||
if churchByPerson[a.PersonID] == nil {
|
||||
churchByPerson[a.PersonID] = map[string]int{}
|
||||
}
|
||||
churchByPerson[a.PersonID][s.ChurchID]++
|
||||
if previous, ok := lastDateByPerson[a.PersonID]; !ok || s.Date.After(previous) {
|
||||
lastDateByPerson[a.PersonID] = s.Date
|
||||
}
|
||||
}
|
||||
|
||||
for _, a := range working {
|
||||
s, ok := serviceByID[a.ServiceID]
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
applyToCounts(a, s)
|
||||
if roleCounts[s.ID] == nil {
|
||||
roleCounts[s.ID] = map[Role]int{}
|
||||
}
|
||||
roleCounts[s.ID][a.Role]++
|
||||
if rolesByServicePerson[s.ID] == nil {
|
||||
rolesByServicePerson[s.ID] = map[string]map[Role]bool{}
|
||||
}
|
||||
if rolesByServicePerson[s.ID][a.PersonID] == nil {
|
||||
rolesByServicePerson[s.ID][a.PersonID] = map[Role]bool{}
|
||||
}
|
||||
rolesByServicePerson[s.ID][a.PersonID][a.Role] = true
|
||||
}
|
||||
|
||||
sortedServices := make([]ServiceOccurrence, len(p.Services))
|
||||
copy(sortedServices, p.Services)
|
||||
sort.SliceStable(sortedServices, func(i, j int) bool {
|
||||
a, b := sortedServices[i], sortedServices[j]
|
||||
if !a.Date.Equal(b.Date) {
|
||||
return a.Date.Before(b.Date)
|
||||
}
|
||||
if a.TimeMinutes != b.TimeMinutes {
|
||||
return a.TimeMinutes < b.TimeMinutes
|
||||
}
|
||||
return a.ID < b.ID
|
||||
})
|
||||
|
||||
var unfilled []UnfilledSlot
|
||||
var newAssignments []Assignment
|
||||
|
||||
for _, service := range sortedServices {
|
||||
assignedRoles := rolesByServicePerson[service.ID]
|
||||
if assignedRoles == nil {
|
||||
assignedRoles = map[string]map[Role]bool{}
|
||||
rolesByServicePerson[service.ID] = assignedRoles
|
||||
}
|
||||
|
||||
for _, role := range AllRoles {
|
||||
required := service.RequiredCount(role)
|
||||
if required <= 0 {
|
||||
continue
|
||||
}
|
||||
existingForRole := 0
|
||||
if roleCounts[service.ID] != nil {
|
||||
existingForRole = roleCounts[service.ID][role]
|
||||
}
|
||||
if existingForRole >= required {
|
||||
continue
|
||||
}
|
||||
for i := existingForRole; i < required; i++ {
|
||||
result := p.bestCandidate(service, role, activePeople, absencesByPerson,
|
||||
totalByPerson, monthByPerson, dayServicesByPerson, churchByPerson,
|
||||
lastDateByPerson, assignedRoles)
|
||||
if result.person == nil {
|
||||
unfilled = append(unfilled, UnfilledSlot{
|
||||
Service: service,
|
||||
ChurchName: churchNames[service.ChurchID],
|
||||
Role: role,
|
||||
Reason: result.reason,
|
||||
})
|
||||
continue
|
||||
}
|
||||
person := *result.person
|
||||
assignment := Assignment{
|
||||
ID: newID(),
|
||||
ServiceID: service.ID,
|
||||
PersonID: person.ID,
|
||||
Role: role,
|
||||
CreatedAt: now(),
|
||||
}
|
||||
newAssignments = append(newAssignments, assignment)
|
||||
working = append(working, assignment)
|
||||
|
||||
if roleCounts[service.ID] == nil {
|
||||
roleCounts[service.ID] = map[Role]int{}
|
||||
}
|
||||
roleCounts[service.ID][role]++
|
||||
if assignedRoles[person.ID] == nil {
|
||||
assignedRoles[person.ID] = map[Role]bool{}
|
||||
}
|
||||
assignedRoles[person.ID][role] = true
|
||||
applyToCounts(assignment, service)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
filled := len(newAssignments)
|
||||
var message string
|
||||
switch {
|
||||
case filled == 0 && len(unfilled) == 0:
|
||||
message = "Alle Dienste im Zeitraum sind bereits vollständig besetzt."
|
||||
case len(unfilled) == 0:
|
||||
suffix := "e"
|
||||
if filled == 1 {
|
||||
suffix = ""
|
||||
}
|
||||
message = fmt.Sprintf("%d Dienst%s erfolgreich besetzt. Alle Lücken geschlossen.", filled, suffix)
|
||||
default:
|
||||
suffix := "e"
|
||||
if filled == 1 {
|
||||
suffix = ""
|
||||
}
|
||||
gapSuffix := "n"
|
||||
if len(unfilled) == 1 {
|
||||
gapSuffix = ""
|
||||
}
|
||||
message = fmt.Sprintf("%d Dienst%s besetzt, %d Lücke%s bleiben offen.", filled, suffix, len(unfilled), gapSuffix)
|
||||
}
|
||||
|
||||
if p.Options.ReplaceExisting {
|
||||
var locked []Assignment
|
||||
for _, a := range working {
|
||||
if a.Locked {
|
||||
locked = append(locked, a)
|
||||
}
|
||||
}
|
||||
return PlanResult{Assignments: append(locked, newAssignments...), Unfilled: unfilled, FilledCount: filled, Message: message}
|
||||
}
|
||||
return PlanResult{Assignments: working, Unfilled: unfilled, FilledCount: filled, Message: message}
|
||||
}
|
||||
|
||||
func (p ServicePlanner) bestCandidate(
|
||||
service ServiceOccurrence,
|
||||
role Role,
|
||||
people []Person,
|
||||
absencesByPerson map[string][]Absence,
|
||||
totalByPerson map[string]int,
|
||||
monthByPerson map[string]int,
|
||||
dayServicesByPerson map[string]map[string]bool,
|
||||
churchByPerson map[string]map[string]int,
|
||||
lastDateByPerson map[string]time.Time,
|
||||
assignedRolesByPerson map[string]map[Role]bool,
|
||||
) candidateResult {
|
||||
blockedReasons := map[string]int{}
|
||||
var eligible []Person
|
||||
|
||||
for _, person := range people {
|
||||
if !person.CanFill(role) {
|
||||
continue
|
||||
}
|
||||
roles := assignedRolesByPerson[person.ID]
|
||||
if roles != nil && roles[role] {
|
||||
blockedReasons["bereits für diesen Dienst eingeteilt"]++
|
||||
continue
|
||||
}
|
||||
if absences, ok := absencesByPerson[person.ID]; ok {
|
||||
blocked := false
|
||||
for _, a := range absences {
|
||||
if a.Overlaps(service.Date) {
|
||||
blocked = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if blocked {
|
||||
blockedReasons["abwesend"]++
|
||||
continue
|
||||
}
|
||||
}
|
||||
if p.Options.RespectPreferredWeekdays && len(person.PreferredWeekdays) > 0 &&
|
||||
!IntContains(person.PreferredWeekdays, Weekday(service.Date)) {
|
||||
blockedReasons["Einsatztag passt nicht"]++
|
||||
continue
|
||||
}
|
||||
month := MonthKey(service.Date)
|
||||
usedThisMonth := monthByPerson[person.ID+"|"+month]
|
||||
if person.MaxPerMonth > 0 && usedThisMonth >= person.MaxPerMonth {
|
||||
blockedReasons["Monatslimit erreicht"]++
|
||||
continue
|
||||
}
|
||||
usedServices := dayServicesByPerson[person.ID+"|"+service.DateKey()]
|
||||
maxPerDay := p.Options.MaxAssignmentsPerDay
|
||||
if len(usedServices) >= maxPerDay && !subsetOfSingle(usedServices, service.ID) {
|
||||
blockedReasons["bereits an diesem Tag"]++
|
||||
continue
|
||||
}
|
||||
eligible = append(eligible, person)
|
||||
}
|
||||
|
||||
minimumTotal := 0
|
||||
if len(eligible) > 0 {
|
||||
minimumTotal = totalByPerson[eligible[0].ID]
|
||||
for _, person := range eligible[1:] {
|
||||
if totalByPerson[person.ID] < minimumTotal {
|
||||
minimumTotal = totalByPerson[person.ID]
|
||||
}
|
||||
}
|
||||
}
|
||||
const fairnessSlack = 1
|
||||
|
||||
var bestPerson *Person
|
||||
bestScore := 0.0
|
||||
haveBest := false
|
||||
|
||||
for i := range eligible {
|
||||
person := eligible[i]
|
||||
roles := assignedRolesByPerson[person.ID]
|
||||
total := totalByPerson[person.ID]
|
||||
withinFairnessReach := total-minimumTotal <= fairnessSlack
|
||||
|
||||
score := 10.0
|
||||
if withinFairnessReach && roles != nil && roles[role.Complementary()] {
|
||||
score += p.Options.WeightDualRolePreference
|
||||
} else if withinFairnessReach && len(service.RolesNeeded()) > 1 {
|
||||
for _, other := range AllRoles {
|
||||
if other != role && service.RequiredCount(other) > 0 && person.CanFill(other) {
|
||||
score += p.Options.WeightDualRolePreference
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if StringContains(person.PreferredChurchIDs, service.ChurchID) {
|
||||
score += p.Options.WeightChurchPreference
|
||||
}
|
||||
if len(person.PreferredChurchIDs) > 0 && !StringContains(person.PreferredChurchIDs, service.ChurchID) {
|
||||
score -= 1.5
|
||||
}
|
||||
if len(person.PreferredServiceTitles) > 0 {
|
||||
title := strings.ToLower(service.Title)
|
||||
for _, preference := range person.PreferredServiceTitles {
|
||||
if preference != "" && strings.Contains(strings.ToLower(title), strings.ToLower(preference)) {
|
||||
score += p.Options.WeightServicePreference
|
||||
}
|
||||
}
|
||||
}
|
||||
if IntContains(person.PreferredWeekdays, Weekday(service.Date)) {
|
||||
score += 3
|
||||
}
|
||||
score -= float64(total) * p.Options.WeightFairness
|
||||
if counts, ok := churchByPerson[person.ID]; ok {
|
||||
score -= float64(counts[service.ChurchID]) * 0.4
|
||||
}
|
||||
if last, ok := lastDateByPerson[person.ID]; ok {
|
||||
gap := DaysBetween(last, service.Date)
|
||||
if gap >= 14 {
|
||||
score += 1.8
|
||||
} else if gap >= 7 {
|
||||
score += 0.8
|
||||
}
|
||||
} else {
|
||||
score += 2.5
|
||||
}
|
||||
score += stableTieBreak(person.ID + "|" + service.ID + "|" + string(role))
|
||||
|
||||
if !haveBest || score > bestScore {
|
||||
bestScore = score
|
||||
cp := person
|
||||
bestPerson = &cp
|
||||
haveBest = true
|
||||
}
|
||||
}
|
||||
|
||||
if bestPerson != nil {
|
||||
return candidateResult{person: bestPerson}
|
||||
}
|
||||
|
||||
reason := "Keine geeignete Person"
|
||||
if len(blockedReasons) == 0 {
|
||||
reason = "Keine geeignete Person mit Rolle " + role.Title()
|
||||
} else {
|
||||
topKey, topCount := "", -1
|
||||
for key, count := range blockedReasons {
|
||||
if count > topCount {
|
||||
topKey, topCount = key, count
|
||||
}
|
||||
}
|
||||
reason = fmt.Sprintf("%s (%d ausgeschlossen)", topKey, topCount)
|
||||
}
|
||||
return candidateResult{reason: reason}
|
||||
}
|
||||
|
||||
func subsetOfSingle(set map[string]bool, value string) bool {
|
||||
if len(set) == 0 {
|
||||
return true
|
||||
}
|
||||
if len(set) > 1 {
|
||||
return false
|
||||
}
|
||||
return set[value]
|
||||
}
|
||||
|
||||
func stableTieBreak(value string) float64 {
|
||||
var hash uint32 = 5381
|
||||
for _, b := range []byte(value) {
|
||||
hash = (hash << 5) + hash + uint32(b)
|
||||
}
|
||||
return float64(hash%997) / 100000
|
||||
}
|
||||
|
||||
// CandidateSuggestions mirrors the macOS detail sheet's suggestion list.
|
||||
func CandidateSuggestions(
|
||||
service ServiceOccurrence,
|
||||
role Role,
|
||||
people []Person,
|
||||
absences []Absence,
|
||||
rangeAssignments []Assignment,
|
||||
services []ServiceOccurrence,
|
||||
serviceAssignments []Assignment,
|
||||
ignorePreferredWeekdays bool,
|
||||
) []CandidateSuggestion {
|
||||
monthKey := MonthKey(service.Date)
|
||||
serviceDateByID := map[string]ServiceOccurrence{}
|
||||
for _, s := range services {
|
||||
serviceDateByID[s.ID] = s
|
||||
}
|
||||
monthlyCounts := map[string]int{}
|
||||
totalCounts := map[string]int{}
|
||||
dayServices := map[string]map[string]bool{}
|
||||
for _, a := range rangeAssignments {
|
||||
s, ok := serviceDateByID[a.ServiceID]
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
monthlyCounts[a.PersonID+"|"+MonthKey(s.Date)]++
|
||||
totalCounts[a.PersonID]++
|
||||
key := a.PersonID + "|" + s.DateKey()
|
||||
if dayServices[key] == nil {
|
||||
dayServices[key] = map[string]bool{}
|
||||
}
|
||||
dayServices[key][a.ServiceID] = true
|
||||
}
|
||||
assignedRoles := map[string]map[Role]bool{}
|
||||
for _, a := range serviceAssignments {
|
||||
if assignedRoles[a.PersonID] == nil {
|
||||
assignedRoles[a.PersonID] = map[Role]bool{}
|
||||
}
|
||||
assignedRoles[a.PersonID][a.Role] = true
|
||||
}
|
||||
|
||||
var eligible []Person
|
||||
for _, person := range people {
|
||||
if person.Active && person.CanFill(role) && !(assignedRoles[person.ID] != nil && assignedRoles[person.ID][role]) {
|
||||
eligible = append(eligible, person)
|
||||
}
|
||||
}
|
||||
minimumTotal := 0
|
||||
if len(eligible) > 0 {
|
||||
minimumTotal = totalCounts[eligible[0].ID]
|
||||
for _, person := range eligible[1:] {
|
||||
if totalCounts[person.ID] < minimumTotal {
|
||||
minimumTotal = totalCounts[person.ID]
|
||||
}
|
||||
}
|
||||
}
|
||||
const fairnessSlack = 1
|
||||
weekday := Weekday(service.Date)
|
||||
|
||||
var suggestions []CandidateSuggestion
|
||||
for _, person := range eligible {
|
||||
var warnings []string
|
||||
blocked := false
|
||||
for _, a := range absences {
|
||||
if a.PersonID == person.ID && a.Overlaps(service.Date) {
|
||||
warnings = append(warnings, "abwesend")
|
||||
blocked = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !ignorePreferredWeekdays && len(person.PreferredWeekdays) > 0 && !IntContains(person.PreferredWeekdays, weekday) {
|
||||
warnings = append(warnings, "Einsatztag passt nicht")
|
||||
blocked = true
|
||||
}
|
||||
if person.MaxPerMonth > 0 && monthlyCounts[person.ID+"|"+monthKey] >= person.MaxPerMonth {
|
||||
warnings = append(warnings, "Monatslimit")
|
||||
blocked = true
|
||||
}
|
||||
used := dayServices[person.ID+"|"+service.DateKey()]
|
||||
if len(used) > 0 && !subsetOfSingle(used, service.ID) {
|
||||
warnings = append(warnings, "bereits an diesem Tag")
|
||||
blocked = true
|
||||
}
|
||||
|
||||
total := totalCounts[person.ID]
|
||||
within := total-minimumTotal <= fairnessSlack
|
||||
score := 0.0
|
||||
preferred := false
|
||||
if within && assignedRoles[person.ID] != nil && assignedRoles[person.ID][role.Complementary()] {
|
||||
score += 14
|
||||
preferred = true
|
||||
} else if within && len(service.RolesNeeded()) > 1 {
|
||||
for _, other := range AllRoles {
|
||||
if other != role && service.RequiredCount(other) > 0 && person.CanFill(other) {
|
||||
score += 14
|
||||
preferred = true
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if StringContains(person.PreferredChurchIDs, service.ChurchID) {
|
||||
score += 8
|
||||
preferred = true
|
||||
}
|
||||
if len(person.PreferredChurchIDs) > 0 && !StringContains(person.PreferredChurchIDs, service.ChurchID) {
|
||||
score -= 2
|
||||
}
|
||||
if IntContains(person.PreferredWeekdays, weekday) {
|
||||
score += 3
|
||||
preferred = true
|
||||
}
|
||||
for _, preference := range person.PreferredServiceTitles {
|
||||
if preference != "" && strings.Contains(strings.ToLower(service.Title), strings.ToLower(preference)) {
|
||||
score += 4
|
||||
preferred = true
|
||||
}
|
||||
}
|
||||
score -= float64(total) * 1.4
|
||||
for _, a := range absences {
|
||||
if a.PersonID == person.ID && a.Overlaps(service.Date) {
|
||||
score -= 100
|
||||
break
|
||||
}
|
||||
}
|
||||
suggestions = append(suggestions, CandidateSuggestion{
|
||||
Person: person, Score: score, Warnings: warnings, Blocked: blocked,
|
||||
Preferred: preferred, TotalAssignments: total,
|
||||
})
|
||||
}
|
||||
|
||||
sort.SliceStable(suggestions, func(i, j int) bool {
|
||||
a, b := suggestions[i], suggestions[j]
|
||||
if a.Blocked != b.Blocked {
|
||||
return !a.Blocked
|
||||
}
|
||||
if a.Score != b.Score {
|
||||
return a.Score > b.Score
|
||||
}
|
||||
return a.Person.LastName < b.Person.LastName
|
||||
})
|
||||
return suggestions
|
||||
}
|
||||
Reference in new issue
Block a user