150 lines
6.3 KiB
Swift
150 lines
6.3 KiB
Swift
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
|
|
}
|
|
}
|