1. Prototyp

This commit is contained in:
concierge committed 2026-11-07 11:32:18 +01:00
1 parent e723eee440
commit c24bc91768
37 files changed
+11610

No files matched your search

+149
View File
@@ -0,0 +1,149 @@
import Foundation
public enum StatisticsCalculator {
public static func compute(
range: DayRange,
services: [ServiceOccurrence],
assignments: [Assignment],
people: [Person],
churches: [Church],
absences: [Absence] = []
) -> RangeStatistics {
let servicesByID = Dictionary(uniqueKeysWithValues: services.map { ($0.id, $0) })
let peopleByID = Dictionary(uniqueKeysWithValues: people.map { ($0.id, $0) })
let assignmentsByPerson = Dictionary(grouping: assignments, by: \.personID)
let assignmentsByService = Dictionary(grouping: assignments, by: \.serviceID)
var personStats: [PersonStat] = people.map { person in
let own = assignmentsByPerson[person.id] ?? []
var lectors = 0
var helpers = 0
var churchCounts: [String: Int] = [:]
var preferredHits = 0
var sundays = 0
var lastDate: Date?
for assignment in own {
guard let service = servicesByID[assignment.serviceID] else { continue }
if assignment.role == .lector { lectors += 1 } else { helpers += 1 }
churchCounts[service.churchID, default: 0] += 1
if DayMath.isSunday(service.date) { sundays += 1 }
if lastDate == nil || service.date > lastDate! { lastDate = service.date }
if preferenceHit(person: person, service: service) { preferredHits += 1 }
}
return PersonStat(
person: person,
total: own.count,
lectors: lectors,
helpers: helpers,
churchCounts: churchCounts,
preferredHits: preferredHits,
sundayCount: sundays,
lastAssignment: lastDate
)
}
personStats.sort {
if $0.total != $1.total { return $0.total > $1.total }
return $0.person.lastName < $1.person.lastName
}
var churchStats: [ChurchStat] = churches.map { church in
let churchServices = services.filter { $0.churchID == church.id }
let serviceIDs = Set(churchServices.map(\.id))
let churchAssignments = assignments.filter { serviceIDs.contains($0.serviceID) }
let open = churchServices.reduce(0) { partial, service in
partial + max(0, service.requiredSlots - (assignmentsByService[service.id]?.count ?? 0))
}
return ChurchStat(
church: church,
assignments: churchAssignments.count,
services: churchServices.count,
openSlots: open,
personCount: Set(churchAssignments.map(\.personID)).count
)
}
churchStats.sort { $0.church.sortIndex < $1.church.sortIndex }
var monthly: [String: Int] = [:]
for assignment in assignments {
guard let service = servicesByID[assignment.serviceID] else { continue }
monthly[DayMath.monthKey(service.date), default: 0] += 1
}
let sundayServices = services.filter { DayMath.isSunday($0.date) }
let sundayServiceIDs = Set(sundayServices.map(\.id))
let sundayFilled = assignments.filter { sundayServiceIDs.contains($0.serviceID) }.count
let requiredSlots = services.reduce(0) { $0 + $1.requiredSlots }
let openSlots = max(0, requiredSlots - assignments.count)
var preferenceHits = 0
var preferenceEligible = 0
for assignment in assignments {
guard let service = servicesByID[assignment.serviceID],
let person = peopleByID[assignment.personID] else { continue }
if hasAnyPreference(person) {
preferenceEligible += 1
if preferenceHit(person: person, service: service) { preferenceHits += 1 }
}
}
let activePeople = Set(people.filter(\.active).map(\.id))
var absenceDays = 0
for absence in absences where activePeople.contains(absence.personID) {
let clamped = absence.range.clamped(to: range)
if clamped.start <= clamped.end { absenceDays += clamped.dayCount }
}
return RangeStatistics(
range: range,
serviceCount: services.count,
assignmentCount: assignments.count,
openSlots: openSlots,
requiredSlots: requiredSlots,
personStats: personStats,
churchStats: churchStats,
monthlyCounts: monthly,
sundayServiceCount: sundayServices.count,
sundayFilled: sundayFilled,
preferenceHits: preferenceHits,
preferenceEligible: preferenceEligible,
absenceDays: absenceDays
)
}
public static func hasAnyPreference(_ person: Person) -> Bool {
!person.preferredChurchIDs.isEmpty || !person.preferredWeekdays.isEmpty || !person.preferredServiceTitles.isEmpty
}
public static func preferenceHit(person: Person, service: ServiceOccurrence) -> Bool {
if person.preferredChurchIDs.contains(service.churchID) { return true }
if person.preferredWeekdays.contains(DayMath.weekday(service.date)) { return true }
let title = service.title.lowercased()
for preference in person.preferredServiceTitles where !preference.isEmpty {
if title.contains(preference.lowercased()) { return true }
}
return false
}
public static func candidateReasons(
person: Person,
service: ServiceOccurrence,
absences: [Absence],
assignments: [Assignment]
) -> [String] {
var reasons: [String] = []
if !person.active { reasons.append("inaktiv") }
if !person.canFill(.lector) && !person.canFill(.helper) { reasons.append("keine Rolle") }
if absences.contains(where: { $0.personID == person.id && $0.overlaps(service.date) }) {
reasons.append("abwesend")
}
if !person.preferredWeekdays.isEmpty && !person.preferredWeekdays.contains(DayMath.weekday(service.date)) {
reasons.append("Einsatztag passt nicht")
}
if assignments.contains(where: { $0.serviceID == service.id && $0.personID == person.id }) {
reasons.append("bereits eingeteilt")
}
return reasons
}
}