Files
LektorenPlan/Sources/LektorenPlan/PlanModel.swift
T

1504 lines
58 KiB
Swift

import SwiftUI
import AppKit
import UniformTypeIdentifiers
import PDFKit
import LektorenPlanCore
enum AppSection: String, CaseIterable, Identifiable, Hashable {
case planning
case serviceOrder
case team
case statistics
case dispatch
case exchange
case settings
var id: String { rawValue }
var title: String {
switch self {
case .planning: "Kalender & Planung"
case .serviceOrder: "Gottesdienstordnung"
case .team: "Lektoren & Helfer"
case .statistics: "Statistik"
case .dispatch: "Versendung"
case .exchange: "Austausch"
case .settings: "Einstellungen"
}
}
var shortTitle: String {
switch self {
case .planning: "Planung"
case .serviceOrder: "Ordnung"
case .team: "Team"
case .statistics: "Statistik"
case .dispatch: "Versendung"
case .exchange: "Austausch"
case .settings: "Einstellungen"
}
}
var icon: String {
switch self {
case .planning: "calendar"
case .serviceOrder: "building.columns"
case .team: "person.2"
case .statistics: "chart.xyaxis.line"
case .dispatch: "paperplane"
case .exchange: "arrow.left.arrow.right"
case .settings: "gearshape"
}
}
var keyboardNumber: Int {
switch self {
case .planning: 1
case .serviceOrder: 2
case .team: 3
case .statistics: 4
case .dispatch: 5
case .exchange: 6
case .settings: 7
}
}
}
enum PlanFilter: String, CaseIterable, Identifiable {
case all
case services
case open
case beyond
var id: String { rawValue }
var title: String {
switch self {
case .all: "Alle Tage"
case .services: "Mit Gottesdiensten"
case .open: "Nur offene"
case .beyond: "Über Präferenzen"
}
}
}
struct PersonEditorRequest: Identifiable {
let id = UUID()
var person: Person?
var presetRole: Role? = nil
}
struct TemplateEditorRequest: Identifiable {
let id = UUID()
var template: ServiceTemplate?
var churchID: String?
}
struct SpecialServiceRequest: Identifiable {
let id = UUID()
var churchID: String?
var date: Date = DayMath.today()
var service: ServiceOccurrence? = nil
}
struct ServiceDetailRequest: Identifiable {
let id = UUID()
var serviceID: String
}
struct ImportPreview: Identifiable {
let id = UUID()
var exchange: PlanExchange
var data: Data
var sourceName: String
}
struct PDFPreview: Identifiable {
let id = UUID()
var data: Data
var title: String
var filename: String
var formatLabel: String
}
enum PlanPDFVariant {
case full
case compact
var formatLabel: String {
switch self {
case .full: "A4 quer · Kirchenspalten"
case .compact: "A4 hoch · kompakte Liste"
}
}
var filenameComponent: String {
switch self {
case .full: "Plan"
case .compact: "Liste"
}
}
}
struct CandidateSuggestion: Identifiable {
var person: Person
var score: Double
var warnings: [String]
var blocked: Bool
var preferred: Bool
var beyondPreferences: Bool
var totalAssignments: Int
var id: String { person.id }
}
struct DispatchRecipient: Identifiable {
var person: Person
var preference: DispatchPreference
var assignments: [DispatchAssignment]
var id: String { person.id }
var effectiveChannel: DispatchChannel { preference.effectiveChannel(for: person) }
var hasEmail: Bool { !person.email.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
}
@MainActor
final class PlanModel: ObservableObject {
static let defaultDispatchIntro = """
Liebe Lektorinnen und Lektoren, liebe Kommunionhelferinnen und -helfer,
anbei sende ich den Plan für den Zeitraum von {start} bis {end}. Dabei konnten hoffentlich alle Wünsche und Termine berücksichtigt werden.
"""
static let defaultDispatchGreeting = """
Mit freundlichen Grüßen
Ihr Pfarreiteam
"""
/// The editable dispatch wording is stored per local user so several people
/// sharing one installation keep their own style. The unsuffixed keys are
/// the legacy shared value and remain the fallback.
static var dispatchUserIntroKey: String { "dispatch.intro.user.\(dispatchLocalUserKey)" }
static var dispatchUserGreetingKey: String { "dispatch.greeting.user.\(dispatchLocalUserKey)" }
private static var dispatchLocalUserKey: String {
let name = NSUserName().trimmingCharacters(in: .whitespacesAndNewlines)
return name.isEmpty ? "local" : name
}
let db: AppDatabase
@Published var section: AppSection = .planning
@Published var range: DayRange = .quarter(containing: DayMath.today())
@Published var churches: [Church] = []
@Published var people: [Person] = []
@Published var absences: [Absence] = []
@Published var templates: [ServiceTemplate] = []
@Published var exceptions: [ServiceException] = []
@Published var services: [ServiceOccurrence] = []
@Published var assignments: [Assignment] = []
@Published var specialServices: [ServiceOccurrence] = []
@Published var liturgicalDays: [String: LiturgicalDay] = [:]
@Published var peopleByID: [String: Person] = [:]
@Published var churchByID: [String: Church] = [:]
@Published var rows: [DayPlanRow] = []
@Published var stats: RangeStatistics = .empty
@Published var lastSync: Date?
@Published var isSyncing = false
@Published var isPlanning = false
@Published var syncMessage: String = ""
@Published var alertMessage: String?
@Published var alertTitle: String = "Hinweis"
@Published var toast: Toast?
@Published var filter: PlanFilter = .all
@Published var searchText: String = ""
@Published var showOnlySundaysAndFeasts: Bool = false
@Published var personEditor: PersonEditorRequest?
@Published var templateEditor: TemplateEditorRequest?
@Published var specialServiceEditor: SpecialServiceRequest?
@Published var serviceDetail: ServiceDetailRequest?
@Published var planResult: PlanResult?
@Published var planResultUsedBeyond = false
@Published var importPreview: ImportPreview?
@Published var pdfPreview: PDFPreview?
@Published var databasePath: String
@Published var startupWarning: String?
@Published var isResettingData = false
@Published var dispatchPreferences: [String: DispatchPreference] = [:]
@Published var dispatchLog: [DispatchLogEntry] = []
@Published var dispatchIntro: String = PlanModel.defaultDispatchIntro
@Published var dispatchGreeting: String = PlanModel.defaultDispatchGreeting
@Published var dispatchDuplex: Bool = true
private var toastTask: Task<Void, Never>?
init(database: AppDatabase? = nil) {
let resolved: AppDatabase
var warning: String?
if let database {
resolved = database
} else {
do {
resolved = try AppDatabase(path: AppDatabase.defaultPath())
} catch {
let fallback = try! AppDatabase.makeInMemory(seedDemo: true)
resolved = fallback
warning = "Die Datenbank konnte nicht geöffnet werden. Es wird eine temporäre In-Memory-Datenbank verwendet.\n\(error.localizedDescription)"
}
}
self.db = resolved
self.databasePath = resolved.path
self.startupWarning = warning
if let startKey = resolved.setting("rangeStart"),
let endKey = resolved.setting("rangeEnd"),
let start = DayMath.date(fromKey: startKey),
let end = DayMath.date(fromKey: endKey),
end >= start {
self.range = DayRange(start: start, end: end)
} else {
self.range = .quarter(containing: DayMath.today())
}
if let value = resolved.setting("showOnlySundaysAndFeasts") {
self.showOnlySundaysAndFeasts = value == "1"
}
loadAll()
loadDispatch()
if let warning { alertMessage = warning; alertTitle = "Eingeschränkter Betrieb" }
}
// MARK: - Loading
func loadAll() {
do {
ensureLiturgicalCoverage()
churches = try db.churches().sorted { $0.sortIndex < $1.sortIndex }
people = try db.people()
peopleByID = Dictionary(uniqueKeysWithValues: people.map { ($0.id, $0) })
churchByID = Dictionary(uniqueKeysWithValues: churches.map { ($0.id, $0) })
absences = try db.absences()
templates = try db.templates()
exceptions = try db.exceptions()
services = try db.services(in: range)
assignments = try db.assignments(in: range)
specialServices = try db.specialServices()
liturgicalDays = Dictionary(uniqueKeysWithValues: try db.liturgicalDays(in: range).map { ($0.dateKey, $0) })
if let raw = db.setting("lastLiturgicalSync") {
lastSync = ISO8601DateFormatter().date(from: raw)
}
rebuildRows()
stats = StatisticsCalculator.compute(
range: range,
services: services,
assignments: assignments,
people: people,
churches: churches,
absences: absences
)
} catch {
alertTitle = "Daten konnten nicht geladen werden"
alertMessage = error.localizedDescription
}
}
private func ensureLiturgicalCoverage() {
do {
let existing = try db.liturgicalDays(in: range)
let keys = Set(existing.map(\.dateKey))
var missing: [LiturgicalDay] = []
for date in range.days where !keys.contains(DayMath.key(date)) {
missing.append(LiturgicalCalendarEngine.localDay(for: date))
}
if !missing.isEmpty {
try db.upsert(liturgicalDays: missing)
}
} catch {
// Reading the local fallback must never block the rest of the UI.
print("Liturgical coverage failed: \(error)")
}
}
private func rebuildRows() {
let servicesByDay = Dictionary(grouping: services, by: \.dateKey)
let assignmentsByService = Dictionary(grouping: assignments, by: \.serviceID)
rows = range.days.map { date in
let key = DayMath.key(date)
let dayServices = (servicesByDay[key] ?? [])
.sorted { $0.timeMinutes < $1.timeMinutes }
.compactMap { service -> ServiceWithAssignments? in
guard let church = churchByID[service.churchID] else { return nil }
let serviceAssignments = (assignmentsByService[service.id] ?? [])
.sorted { $0.role == .lector && $1.role == .helper }
return ServiceWithAssignments(service: service, church: church, assignments: serviceAssignments)
}
return DayPlanRow(date: date, liturgicalDay: liturgicalDays[key], services: dayServices)
}
}
// MARK: - Range
func setRange(_ newRange: DayRange) {
guard newRange != range else { return }
range = newRange
db.setSetting("rangeStart", value: DayMath.key(newRange.start))
db.setSetting("rangeEnd", value: DayMath.key(newRange.end))
loadAll()
}
func setSundayFilter(_ enabled: Bool) {
showOnlySundaysAndFeasts = enabled
db.setSetting("showOnlySundaysAndFeasts", value: enabled ? "1" : "0")
}
var filteredRows: [DayPlanRow] {
let query = searchText.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
return rows.filter { row in
if showOnlySundaysAndFeasts {
let isSpecialDay = row.liturgicalDay?.isSunday == true || row.liturgicalDay?.isObligation == true || row.liturgicalDay?.isFeast == true
if !isSpecialDay { return false }
}
switch filter {
case .all:
break
case .services:
if !row.hasServices { return false }
case .open:
if row.openSlots == 0 { return false }
case .beyond:
if !row.hasBeyondPreferences { return false }
}
guard !query.isEmpty else { return true }
if row.liturgicalDay?.title.lowercased().contains(query) == true { return true }
if row.liturgicalDay?.readings.shortLabel.lowercased().contains(query) == true { return true }
for service in row.services {
if service.church.name.lowercased().contains(query) { return true }
if let location = service.service.location,
location.lowercased().contains(query) { return true }
if service.service.title.lowercased().contains(query) { return true }
for assignment in service.assignments {
if let person = peopleByID[assignment.personID],
person.fullName.lowercased().contains(query) {
return true
}
}
}
return false
}
}
var openSlotCount: Int { stats.openSlots }
var rangeServiceCount: Int { stats.serviceCount }
var fullyStaffedServiceCount: Int {
rows.reduce(0) { total, row in
total + row.services.filter(\.isFullyStaffed).count
}
}
var lectorCount: Int { people.filter { $0.active && $0.roles.contains(.lector) }.count }
var helperCount: Int { people.filter { $0.active && $0.roles.contains(.helper) }.count }
// MARK: - Planning
func autoPlan(replaceExisting: Bool, allowBeyond: Bool = false) -> PlanResult? {
guard !isPlanning else { return nil }
isPlanning = true
defer { isPlanning = false }
do {
let rangeServices = try db.services(in: range)
let existing = try db.assignments(in: range)
let options = PlannerOptions(
// A follow-up pass keeps the result of the first pass and only
// adds assignments for volunteers who allowed them.
replaceExisting: allowBeyond ? false : replaceExisting,
respectPreferredWeekdays: db.setting("respectPreferredWeekdays") != "0",
allowBeyondPreferences: allowBeyond,
weightFairness: Double(db.setting("fairnessWeight") ?? "") ?? 2.2,
maxAssignmentsPerDay: 1
)
let planner = ServicePlanner(
people: people,
absences: absences,
services: rangeServices,
existingAssignments: existing,
churches: churches,
liturgicalDays: Array(liturgicalDays.values),
options: options
)
let result = planner.plan()
if result.filledCount > 0 || replaceExisting {
try db.savePlan(result.assignments, in: range, replaceUnlocked: allowBeyond ? false : replaceExisting)
}
loadAll()
planResult = result
planResultUsedBeyond = allowBeyond
return result
} catch {
alertTitle = "Planung fehlgeschlagen"
alertMessage = error.localizedDescription
return nil
}
}
func autoFill(serviceID: String) {
do {
guard let service = try db.service(id: serviceID) else { return }
let dayRange = DayRange(start: service.date, end: service.date)
let existing = try db.assignments(in: dayRange)
let servicesOfDay = try db.services(in: dayRange)
let planner = ServicePlanner(
people: people,
absences: absences,
services: [service],
existingAssignments: existing.filter { $0.serviceID == serviceID },
churches: churches,
liturgicalDays: Array(liturgicalDays.values),
options: PlannerOptions(
replaceExisting: false,
respectPreferredWeekdays: true,
allowBeyondPreferences: true
)
)
let result = planner.plan()
_ = servicesOfDay
try db.savePlan(result.assignments, in: dayRange, replaceUnlocked: false)
loadAll()
if result.unfilled.isEmpty {
showToast("Gottesdienst vollständig besetzt.", kind: .success)
} else {
showToast("\(result.unfilled.count) Lücke(n) konnten nicht besetzt werden.", kind: .warning)
}
} catch {
alertTitle = "Planung fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
func assign(serviceID: String, role: Role, personID: String?) {
do {
var beyond = false
if let personID, let person = peopleByID[personID], let service = try db.service(id: serviceID) {
if absences.contains(where: { $0.personID == personID && $0.overlaps(service.date) }) {
alertTitle = "Zuweisung nicht möglich"
alertMessage = "\(person.fullName) ist an diesem Tag als abwesend eingetragen."
return
}
let highFeast = liturgicalDays[service.dateKey]?.isHighFeast ?? false
let fits = person.matchesWeekdayPreference(
weekday: DayMath.weekday(service.date),
timeMinutes: service.timeMinutes,
highFeast: highFeast
)
beyond = !fits
if !beyond, person.maxPerMonth > 0 {
let monthAssignments = try db.assignments(in: DayRange.month(containing: service.date))
let used = monthAssignments.filter {
$0.personID == personID && $0.serviceID != serviceID
}.count
beyond = used >= person.maxPerMonth
}
}
try db.setAssignment(
serviceID: serviceID, role: role, personID: personID,
beyondPreferences: beyond
)
loadAll()
if let personID, let person = peopleByID[personID] {
showToast("\(person.fullName) als \(role.title) eingetragen.", kind: .success)
} else {
showToast("Dienst freigegeben.", kind: .info)
}
} catch {
alertTitle = "Zuweisung fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
func toggleAssignmentLock(_ assignment: Assignment) {
do {
try db.toggleAssignmentLock(id: assignment.id)
loadAll()
} catch {
alertTitle = "Sperre konnte nicht geändert werden"
alertMessage = error.localizedDescription
}
}
func candidateSuggestions(
for service: ServiceOccurrence,
role: Role
) -> [CandidateSuggestion] {
let rangeAssignments = assignments
let monthKey = DayMath.monthKey(service.date)
let serviceDateByID = Dictionary(uniqueKeysWithValues: services.map { ($0.id, $0) })
var monthlyCounts: [String: Int] = [:]
var totalCounts: [String: Int] = [:]
var dayServices: [String: Set<String>] = [:]
for assignment in rangeAssignments {
guard let assignedService = serviceDateByID[assignment.serviceID] else { continue }
monthlyCounts["\(assignment.personID)|\(DayMath.monthKey(assignedService.date))", default: 0] += 1
totalCounts[assignment.personID, default: 0] += 1
dayServices["\(assignment.personID)|\(assignedService.dateKey)", default: []].insert(assignment.serviceID)
}
// Lector and helper do not exclude each other: a person may be suggested
// for the complementary role even when already serving this service.
// Read the service assignments directly so this also works when the
// service is outside the currently loaded range.
let serviceAssignments = (try? db.assignments(serviceIDs: [service.id]))
?? assignments.filter { $0.serviceID == service.id }
var assignedRolesByPerson: [String: Set<Role>] = [:]
for assignment in serviceAssignments {
assignedRolesByPerson[assignment.personID, default: []].insert(assignment.role)
}
let weekday = DayMath.weekday(service.date)
let highFeast = liturgicalDays[service.dateKey]?.isHighFeast ?? false
let eligiblePeople = people.filter { person in
guard person.active, person.canFill(role) else { return false }
return !(assignedRolesByPerson[person.id]?.contains(role) ?? false)
}
// Only prefer a dual-role assignment while the person is not already
// noticeably ahead of others. Otherwise fairness wins.
let minimumTotal = eligiblePeople.map { totalCounts[$0.id, default: 0] }.min() ?? 0
let fairnessSlack = 1
return eligiblePeople
.map { person in
var warnings: [String] = []
var blocked = false
var beyond = false
if absences.contains(where: { $0.personID == person.id && $0.overlaps(service.date) }) {
warnings.append("abwesend")
blocked = true
}
let weekdayMatch = person.matchesWeekdayPreference(
weekday: weekday,
timeMinutes: service.timeMinutes,
highFeast: highFeast
)
if !weekdayMatch {
// Manual assignments may always override preferences, but
// the UI asks for confirmation before doing so.
warnings.append("Einsatztag oder Uhrzeit passt nicht")
beyond = true
}
if person.maxPerMonth > 0, monthlyCounts["\(person.id)|\(monthKey)", default: 0] >= person.maxPerMonth {
warnings.append("Monatslimit")
beyond = true
}
let servicesThisDay = dayServices["\(person.id)|\(service.dateKey)", default: []]
if !servicesThisDay.isEmpty, !servicesThisDay.isSubset(of: [service.id]) {
// Only explicit absences remain hard blocks for manual assignments.
warnings.append("bereits an diesem Tag")
}
let total = totalCounts[person.id, default: 0]
let withinFairnessReach = total - minimumTotal <= fairnessSlack
var score = 0.0
var preferred = false
if withinFairnessReach, assignedRolesByPerson[person.id]?.contains(role.complementary) == true {
score += 14
preferred = true
} else if withinFairnessReach,
service.rolesNeeded.count > 1,
person.roles.contains(where: { $0 != role && service.requiredCount(for: $0) > 0 }) {
score += 14
preferred = true
}
if person.preferredChurchIDs.contains(service.churchID) {
score += 8
preferred = true
}
if !person.preferredChurchIDs.isEmpty && !person.preferredChurchIDs.contains(service.churchID) {
score -= 2
}
if weekdayMatch, !person.preferredWeekdays.isEmpty {
score += 3
preferred = true
}
for preference in person.preferredServiceTitles where !preference.isEmpty {
if service.title.lowercased().contains(preference.lowercased()) {
score += 4
preferred = true
}
}
score -= Double(total) * 1.4
if absences.contains(where: { $0.personID == person.id && $0.overlaps(service.date) }) {
score -= 100
}
return CandidateSuggestion(
person: person,
score: score,
warnings: warnings,
blocked: blocked,
preferred: preferred,
beyondPreferences: beyond,
totalAssignments: totalCounts[person.id, default: 0]
)
}
.sorted {
if $0.blocked != $1.blocked { return !$0.blocked }
if $0.score != $1.score { return $0.score > $1.score }
return $0.person.lastName < $1.person.lastName
}
}
func serviceWithAssignments(id: String) -> ServiceWithAssignments? {
for row in rows {
if let match = row.services.first(where: { $0.service.id == id }) { return match }
}
// The service may be outside the current range while its detail sheet is open.
guard let service = try? db.service(id: id), let church = churchByID[service.churchID] else { return nil }
let serviceAssignments = (try? db.assignments(serviceIDs: [id])) ?? []
return ServiceWithAssignments(service: service, church: church, assignments: serviceAssignments)
}
func nextOpenServices(limit: Int = 8) -> [ServiceWithAssignments] {
rows
.flatMap(\.services)
.filter { !$0.isFullyStaffed }
.sorted { $0.service.date < $1.service.date }
.prefix(limit)
.map { $0 }
}
// MARK: - Liturgical calendar
func syncLiturgy(years: [Int]? = nil) async {
guard !isSyncing else { return }
isSyncing = true
defer { isSyncing = false }
let targetYears = years ?? Array(Set(range.days.map { DayMath.year($0) })).sorted()
var updated = 0
var errors: [String] = []
let api = LiturgicalCalendarAPI()
for year in targetYears {
syncMessage = "Lade liturgischen Kalender \(year)…"
do {
let days = try await api.fetch(year: year)
try db.replaceLiturgicalYear(year, with: days)
updated += days.count
} catch {
errors.append("\(year): \(error.localizedDescription)")
}
}
if updated > 0 {
let now = Date()
lastSync = now
db.setSetting("lastLiturgicalSync", value: ISO8601DateFormatter().string(from: now))
ensureLiturgicalCoverage()
loadAll()
showToast("Liturgischer Kalender aktualisiert · \(updated) Tage.", kind: .success)
}
syncMessage = ""
if !errors.isEmpty {
alertTitle = errors.count == targetYears.count ? "Kalender nicht erreichbar" : "Kalender teilweise aktualisiert"
alertMessage = errors.joined(separator: "\n") + "\n\nDie vorhandenen Offline-Daten bleiben erhalten. Quelle: www.eucharistiefeier.de"
}
}
func syncIfNeeded() {
// Screenshot runs should stay deterministic and offline.
guard ProcessInfo.processInfo.environment["LP_SNAPSHOT"] == nil else { return }
guard db.setting("autoSyncLiturgy") == "1" else { return }
if let lastSync, Date().timeIntervalSince(lastSync) < 24 * 3600 { return }
Task { await syncLiturgy(years: [DayMath.year(range.start)]) }
}
static var sourceLabel: String { "Daten von www.eucharistiefeier.de" }
// MARK: - People
func savePerson(_ person: Person) {
do {
try db.upsert(person)
loadAll()
showToast("\(person.fullName) gespeichert.", kind: .success)
} catch {
alertTitle = "Person konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
func deletePerson(_ person: Person) {
do {
try db.deletePerson(id: person.id)
loadAll()
showToast("\(person.fullName) gelöscht.", kind: .info)
} catch {
alertTitle = "Person konnte nicht gelöscht werden"
alertMessage = error.localizedDescription
}
}
func absences(for personID: String) -> [Absence] {
absences.filter { $0.personID == personID }.sorted { $0.start < $1.start }
}
func saveAbsence(_ absence: Absence) {
do {
try db.upsert(absence)
loadAll()
} catch {
alertTitle = "Abwesenheit konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
func deleteAbsence(_ absence: Absence) {
do {
try db.deleteAbsence(id: absence.id)
loadAll()
} catch {
alertTitle = "Abwesenheit konnte nicht gelöscht werden"
alertMessage = error.localizedDescription
}
}
func currentAbsence(for person: Person) -> Absence? {
let today = DayMath.today()
return absences.first { $0.personID == person.id && $0.range.contains(today) }
}
func assignmentCount(for personID: String) -> Int {
stats.personStats.first { $0.person.id == personID }?.total ?? 0
}
// MARK: - Service order
func templates(for churchID: String) -> [ServiceTemplate] {
templates.filter { $0.churchID == churchID }.sorted {
if $0.weekday != $1.weekday { return $0.weekday < $1.weekday }
return $0.timeMinutes < $1.timeMinutes
}
}
func saveTemplate(_ template: ServiceTemplate) {
do {
try db.upsert(template)
let created = try db.generateServices(in: range)
loadAll()
showToast("Gottesdienstordnung gespeichert. \(created) neue Termine erzeugt.", kind: .success)
} catch {
alertTitle = "Gottesdienstordnung konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
func deleteTemplate(_ template: ServiceTemplate) {
do {
try db.deleteTemplate(id: template.id)
loadAll()
showToast("Vorlage gelöscht. Bereits erzeugte Termine bleiben erhalten.", kind: .info)
} catch {
alertTitle = "Vorlage konnte nicht gelöscht werden"
alertMessage = error.localizedDescription
}
}
func generateServices() {
do {
let created = try db.generateServices(in: range)
loadAll()
showToast(created > 0 ? "\(created) Gottesdienste erzeugt." : "Keine neuen Gottesdienste im Zeitraum.", kind: created > 0 ? .success : .info)
} catch {
alertTitle = "Gottesdienste konnten nicht erzeugt werden"
alertMessage = error.localizedDescription
}
}
func saveSpecialService(_ service: ServiceOccurrence) {
do {
try db.upsert(service)
loadAll()
showToast("Sondergottesdienst gespeichert.", kind: .success)
} catch {
alertTitle = "Sondergottesdienst konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
func deleteService(_ service: ServiceOccurrence) {
do {
try db.deleteService(id: service.id)
loadAll()
serviceDetail = nil
showToast("Gottesdienst gelöscht.", kind: .info)
} catch {
alertTitle = "Gottesdienst konnte nicht gelöscht werden"
alertMessage = error.localizedDescription
}
}
var serviceTitles: [String] {
Array(Set(templates.map(\.title))).sorted()
}
func upcomingSpecials() -> [ServiceOccurrence] {
let cutoff = DayMath.adding(days: -31, to: DayMath.today())
return specialServices
.filter { $0.date >= cutoff }
.sorted { $0.date < $1.date }
}
// MARK: - Exchange
func exportData(scope: ExchangeScope) throws -> (data: Data, filename: String) {
let exchange = try db.exportPlan(range: range, scope: scope)
let encoder = JSONEncoder()
encoder.outputFormatting = [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes]
encoder.dateEncodingStrategy = .iso8601
let data = try encoder.encode(exchange)
let suffix: String
if scope == .resources {
suffix = "Ressourcen_\(DayMath.key(DayMath.today()))"
} else {
suffix = "Plan_\(DayMath.key(range.start))_\(DayMath.key(range.end))"
}
return (data, "LektorenPlan_\(suffix).json")
}
func exportInteractive(scope: ExchangeScope) {
do {
let result = try exportData(scope: scope)
let panel = NSSavePanel()
panel.title = scope == .resources ? "Ressourcen exportieren" : "Planungsabschnitt exportieren"
panel.nameFieldStringValue = result.filename
panel.allowedContentTypes = [.json]
panel.canCreateDirectories = true
if panel.runModal() == .OK, let url = panel.url {
try result.data.write(to: url, options: .atomic)
showToast("Export gespeichert: \(url.lastPathComponent)", kind: .success)
}
} catch {
alertTitle = "Export fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
func importInteractive() {
let panel = NSOpenPanel()
panel.title = "LektorenPlan-Datei importieren"
panel.allowsMultipleSelection = false
panel.canChooseDirectories = false
panel.allowedContentTypes = [.json]
if panel.runModal() == .OK, let url = panel.url {
prepareImport(url: url)
}
}
func prepareImport(url: URL) {
do {
let accessing = url.startAccessingSecurityScopedResource()
defer { if accessing { url.stopAccessingSecurityScopedResource() } }
let data = try Data(contentsOf: url)
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
if let exchange = try? decoder.decode(PlanExchange.self, from: data) {
importPreview = ImportPreview(exchange: exchange, data: data, sourceName: url.lastPathComponent)
return
}
if let resources = try? decoder.decode(ResourceBundle.self, from: data) {
let exchange = PlanExchange(scope: .resources, range: range, resources: resources)
importPreview = ImportPreview(exchange: exchange, data: data, sourceName: url.lastPathComponent)
return
}
alertTitle = "Datei nicht erkannt"
alertMessage = "Die Datei enthält kein gültiges LektorenPlan-Austauschformat."
} catch {
alertTitle = "Import fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
func applyImport(_ preview: ImportPreview) {
do {
let summary = try db.applyPlanExchange(preview.exchange)
importPreview = nil
loadAll()
loadDispatch()
showToast("Import abgeschlossen: \(summary.services) Gottesdienste, \(summary.assignments) Einsätze, \(summary.people) Personen.", kind: .success)
} catch {
alertTitle = "Import fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
// MARK: - PDF & print
func createPDFPreview(variant: PlanPDFVariant = .full) {
let data: Data
switch variant {
case .full:
data = PlanPDFRenderer.render(
range: range,
rows: rows,
churches: churches,
people: peopleByID,
generatedAt: Date()
)
case .compact:
data = CompactPlanPDFRenderer.render(
range: range,
rows: rows,
people: peopleByID,
generatedAt: Date()
)
}
pdfPreview = PDFPreview(
data: data,
title: variant == .compact
? "Gottesdienstliste \(range.shortTitle)"
: "Lektorenplan \(range.shortTitle)",
filename: "LektorenPlan_\(variant.filenameComponent)_\(DayMath.key(range.start))_\(DayMath.key(range.end)).pdf",
formatLabel: variant.formatLabel
)
}
func savePDF(data: Data, suggestedName: String) {
let panel = NSSavePanel()
panel.title = "PDF sichern"
panel.nameFieldStringValue = suggestedName
panel.allowedContentTypes = [.pdf]
if panel.runModal() == .OK, let url = panel.url {
do {
try data.write(to: url, options: .atomic)
showToast("PDF gespeichert: \(url.lastPathComponent)", kind: .success)
} catch {
alertTitle = "PDF konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
}
func printPDF(data: Data? = nil, variant: PlanPDFVariant = .full) {
let pdfData = data ?? {
switch variant {
case .full:
return PlanPDFRenderer.render(
range: range,
rows: rows,
churches: churches,
people: peopleByID,
generatedAt: Date()
)
case .compact:
return CompactPlanPDFRenderer.render(
range: range,
rows: rows,
people: peopleByID,
generatedAt: Date()
)
}
}()
guard let document = PDFDocument(data: pdfData) else {
alertTitle = "Drucken nicht möglich"
alertMessage = "Das PDF konnte nicht erzeugt werden."
return
}
let info = NSPrintInfo.shared.copy() as? NSPrintInfo ?? NSPrintInfo.shared
let bounds = document.page(at: 0)?.bounds(for: .mediaBox) ?? .zero
info.orientation = bounds.width > bounds.height ? .landscape : .portrait
info.topMargin = 0
info.bottomMargin = 0
info.leftMargin = 0
info.rightMargin = 0
if let operation = document.printOperation(for: info, scalingMode: .pageScaleToFit, autoRotate: true) {
operation.showsPrintPanel = true
operation.showsProgressPanel = true
operation.run()
}
}
// MARK: - Dispatch
/// Recipients for the current planning period, including their effective
/// channel and personal assignment overview.
var dispatchRecipients: [DispatchRecipient] {
people
.filter(\.active)
.map { person in
dispatchRecipientsWithAssignments(for: person)
}
}
private func dispatchRecipientsWithAssignments(for person: Person) -> DispatchRecipient {
var preference = dispatchPreferences[person.id]
?? DispatchPreference(channel: person.email.isEmpty ? .print : .email)
if preference.channel == .email && person.email.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
preference.channel = .print
}
return DispatchRecipient(
person: person,
preference: preference,
assignments: dispatchAssignments(for: person.id)
)
}
func dispatchPreference(for person: Person) -> DispatchPreference {
dispatchRecipientsWithAssignments(for: person).preference
}
func setDispatchChannel(_ channel: DispatchChannel, for person: Person) {
var preference = dispatchPreference(for: person)
preference.channel = channel
dispatchPreferences[person.id] = preference
}
func setDispatchVariant(_ variant: PlanListVariant, for person: Person) {
var preference = dispatchPreference(for: person)
preference.variant = variant
dispatchPreferences[person.id] = preference
}
func setDispatchCover(_ cover: Bool, for person: Person) {
var preference = dispatchPreference(for: person)
preference.cover = cover
dispatchPreferences[person.id] = preference
}
func setDispatchChannelForAll(_ channel: DispatchChannel) {
for recipient in dispatchRecipients {
setDispatchChannel(channel, for: recipient.person)
}
}
func dispatchAssignments(for personID: String) -> [DispatchAssignment] {
var grouped: [String: DispatchAssignment] = [:]
var order: [String] = []
for row in rows {
for service in row.services {
for assignment in service.assignments where assignment.personID == personID {
// One person can serve as lector and helper in the same
// service. Combine both assignments into one overview row
// and one calendar event.
if var existing = grouped[service.id] {
if !existing.roles.contains(assignment.role) {
existing.roles.append(assignment.role)
grouped[service.id] = existing
}
} else {
grouped[service.id] = DispatchAssignment(
id: service.id,
date: row.date,
timeMinutes: service.service.timeMinutes,
church: service.church.shortName,
place: service.service.placeName(church: service.church),
title: service.service.title,
roles: [assignment.role]
)
order.append(service.id)
}
}
}
}
return order.compactMap { grouped[$0] }.sorted {
if $0.date != $1.date { return $0.date < $1.date }
return $0.timeMinutes < $1.timeMinutes
}
}
/// Builds calendar events for one recipient. Service times are wall-clock
/// times in the parish, so they stay floating local times in the `.ics`.
func dispatchCalendarEvents(_ assignments: [DispatchAssignment]) -> [CalendarEvent] {
assignments.map { assignment in
let start = DayMath.calendar.date(
bySettingHour: assignment.timeMinutes / 60,
minute: assignment.timeMinutes % 60,
second: 0,
of: assignment.date
) ?? assignment.date
return CalendarEvent(
uid: assignment.id,
start: start,
durationMinutes: 60,
summary: assignment.title,
location: assignment.place,
description: "Dienst: \(assignment.roleLabel)"
)
}
}
func loadDispatch() {
do {
dispatchPreferences = try db.dispatchPreferences()
dispatchLog = try db.dispatchLog()
} catch {
alertTitle = "Versendung konnte nicht geladen werden"
alertMessage = error.localizedDescription
}
if let stored = db.setting(Self.dispatchUserIntroKey), !stored.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
dispatchIntro = stored
} else if let stored = db.setting("dispatch.intro"), !stored.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
dispatchIntro = stored
} else {
dispatchIntro = Self.defaultDispatchIntro
}
dispatchGreeting = db.setting(Self.dispatchUserGreetingKey)
?? db.setting("dispatch.greeting")
?? Self.defaultDispatchGreeting
}
/// Persists the texts and every currently visible preference.
func saveDispatchSettings(showConfirmation: Bool = true) {
db.setSetting(Self.dispatchUserIntroKey, value: dispatchIntro)
db.setSetting(Self.dispatchUserGreetingKey, value: dispatchGreeting)
for recipient in dispatchRecipients {
db.saveDispatchPreference(recipient.preference, personID: recipient.id)
}
refreshDispatchLog()
if showConfirmation {
showToast("Versendung gespeichert.", kind: .success)
}
}
func resolvedDispatchText(_ text: String) -> String {
text
.replacingOccurrences(of: "{start}", with: DayMath.mediumString(range.start))
.replacingOccurrences(of: "{end}", with: DayMath.mediumString(range.end))
.trimmingCharacters(in: .whitespacesAndNewlines)
}
func dispatchSubject() -> String {
"Gottesdienstplan \(range.shortTitle) · LektorenPlan"
}
func dispatchEmailBody(for recipient: DispatchRecipient) -> String {
var parts: [String] = [resolvedDispatchText(dispatchIntro)]
parts.append("Ihre Einsätze im Zeitraum:\n\n" + dispatchAssignmentLines(recipient.assignments))
parts.append(Self.dispatchAttachmentHint)
let greeting = resolvedDispatchText(dispatchGreeting)
if !greeting.isEmpty {
parts.append(greeting)
}
return parts.joined(separator: "\n\n")
}
static let dispatchAttachmentHint = "Im Anhang finden Sie den Plan als PDF sowie eine Kalenderdatei (.ics), "
+ "die Sie in Ihren Kalender importieren können."
func dispatchAssignmentLines(_ assignments: [DispatchAssignment]) -> String {
guard !assignments.isEmpty else {
return "Für Sie sind in diesem Zeitraum keine Einsätze eingetragen."
}
return assignments
.map { "\($0.dateLabel) · \($0.timeLabel) · \($0.church) · \($0.roleLabel) · \($0.title)" }
.joined(separator: "\n")
}
/// Opens one Mail compose window per e-mail recipient, with the personal
/// text and the selected plan PDF attached.
func openDispatchEmails() {
let recipients = dispatchRecipients.filter { $0.effectiveChannel == .email }
guard !recipients.isEmpty else {
showToast("Keine Empfänger mit E-Mail-Adresse ausgewählt.", kind: .info)
return
}
saveDispatchSettings(showConfirmation: false)
let batchID = UUID().uuidString
let createdAt = Date()
let directory = dispatchTempDirectory()
var planCache: [PlanListVariant: Data] = [:]
var entries: [DispatchLogEntry] = []
var opened = 0
var failed = 0
var firstError = ""
for (index, recipient) in recipients.enumerated() {
let email = recipient.person.email.trimmingCharacters(in: .whitespacesAndNewlines)
func failure(_ reason: String) {
failed += 1
if firstError.isEmpty { firstError = reason }
entries.append(DispatchLogEntry(
batchID: batchID, rangeStart: range.start, rangeEnd: range.end,
personID: recipient.id, personName: recipient.person.fullName,
channel: .email, variant: recipient.preference.variant,
email: email, status: .failed, detail: reason, createdAt: createdAt
))
}
guard email.contains("@") else {
failure("Keine gültige E-Mail-Adresse")
continue
}
guard let service = NSSharingService(named: .composeEmail) else {
failure("Kein Mailprogramm verfügbar")
continue
}
let variant = recipient.preference.variant
if planCache[variant] == nil {
planCache[variant] = dispatchPlanData(variant: variant)
}
guard let planData = planCache[variant], !planData.isEmpty else {
failure("PDF konnte nicht erzeugt werden")
continue
}
let fileURL = directory.appendingPathComponent(dispatchFilename(for: recipient, variant: variant))
do {
try planData.write(to: fileURL, options: .atomic)
} catch {
failure("PDF konnte nicht gespeichert werden: \(error.localizedDescription)")
continue
}
let calendarURL = directory.appendingPathComponent(dispatchCalendarFilename(for: recipient))
let calendar = CalendarExport.ics(
calendarName: "Gottesdienstplan \(range.shortTitle)",
events: dispatchCalendarEvents(recipient.assignments)
)
do {
try Data(calendar.utf8).write(to: calendarURL, options: .atomic)
} catch {
failure("Kalenderdatei konnte nicht gespeichert werden: \(error.localizedDescription)")
continue
}
service.recipients = [email]
service.subject = dispatchSubject()
let body = dispatchEmailBody(for: recipient)
DispatchQueue.main.asyncAfter(deadline: .now() + Double(index) * 0.4) {
service.perform(withItems: [body, fileURL, calendarURL])
}
opened += 1
entries.append(DispatchLogEntry(
batchID: batchID, rangeStart: range.start, rangeEnd: range.end,
personID: recipient.id, personName: recipient.person.fullName,
channel: .email, variant: variant, email: email,
status: .mail, detail: "Anhänge: \(variant.shortTitle), Kalender (.ics)", createdAt: createdAt
))
}
persistDispatchLog(entries)
if failed == 0 {
showToast("\(opened) E-Mail-Entwürfe im Mailprogramm geöffnet.", kind: .success)
} else {
showToast("\(opened) Entwürfe geöffnet, \(failed) fehlgeschlagen. \(firstError)", kind: .info)
}
}
/// Saves one recipient's personal calendar file via a save panel. The file
/// contains only that person's assignments, like the e-mail attachment.
func exportDispatchCalendar(for recipient: DispatchRecipient) {
let calendar = CalendarExport.ics(
calendarName: "Gottesdienstplan \(range.shortTitle)",
events: dispatchCalendarEvents(recipient.assignments)
)
let panel = NSSavePanel()
panel.title = "Kalenderdatei sichern"
panel.nameFieldStringValue = dispatchCalendarFilename(for: recipient)
panel.allowedContentTypes = [UTType(filenameExtension: "ics") ?? .data]
panel.canCreateDirectories = true
guard panel.runModal() == .OK, let url = panel.url else { return }
do {
try Data(calendar.utf8).write(to: url, options: .atomic)
showToast("Kalenderdatei gespeichert: \(url.lastPathComponent)", kind: .success)
} catch {
alertTitle = "Kalenderdatei konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
/// Builds one printable PDF: for each print recipient an optional cover
/// sheet followed by the selected plan variant.
func createDispatchPrintPDF() {
let recipients = dispatchRecipients.filter { $0.effectiveChannel == .print }
guard !recipients.isEmpty else {
showToast("Keine Empfänger für den Ausdruck ausgewählt.", kind: .info)
return
}
saveDispatchSettings(showConfirmation: false)
var planCache: [PlanListVariant: Data] = [:]
var documents: [Data] = []
for recipient in recipients {
if recipient.preference.cover {
let cover = DispatchCoverPDFRenderer.render(DispatchCoverData(
range: range,
person: recipient.person,
intro: resolvedDispatchText(dispatchIntro),
greeting: resolvedDispatchText(dispatchGreeting),
assignments: recipient.assignments,
generatedAt: Date()
))
if !cover.isEmpty {
documents.append(dispatchDuplex ? PDFMerger.paddedToEvenPages(cover) : cover)
}
}
let variant = recipient.preference.variant
if planCache[variant] == nil {
let plan = dispatchPlanData(variant: variant)
planCache[variant] = dispatchDuplex ? PDFMerger.paddedToEvenPages(plan) : plan
}
if let planData = planCache[variant], !planData.isEmpty {
documents.append(planData)
}
}
let merged = PDFMerger.merge(documents)
guard !merged.isEmpty else {
alertTitle = "Versand-PDF nicht möglich"
alertMessage = "Die PDF-Dokumente konnten nicht zusammengeführt werden."
return
}
let batchID = UUID().uuidString
let createdAt = Date()
let entries = recipients.map { recipient in
DispatchLogEntry(
batchID: batchID, rangeStart: range.start, rangeEnd: range.end,
personID: recipient.id, personName: recipient.person.fullName,
channel: .print, variant: recipient.preference.variant,
cover: recipient.preference.cover, email: recipient.person.email,
status: .pdf,
detail: recipient.preference.cover ? "Mit Vorblatt" : "Ohne Vorblatt",
createdAt: createdAt
)
}
persistDispatchLog(entries)
pdfPreview = PDFPreview(
data: merged,
title: "Versand-PDF \(range.shortTitle)",
filename: "LektorenPlan_Versand_\(DayMath.key(range.start))_\(DayMath.key(range.end)).pdf",
formatLabel: "Sammel-PDF · \(recipients.count) Empfänger"
)
showToast("Versand-PDF für \(recipients.count) Empfänger erzeugt.", kind: .success)
}
var dispatchLastBatch: [DispatchLogEntry] {
guard let first = dispatchLog.first else { return [] }
return dispatchLog.prefix { $0.batchID == first.batchID }.map { $0 }
}
private func persistDispatchLog(_ entries: [DispatchLogEntry]) {
guard !entries.isEmpty else { return }
do {
try db.appendDispatchLog(entries)
} catch {
alertTitle = "Protokoll konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
refreshDispatchLog()
}
private func refreshDispatchLog() {
dispatchLog = (try? db.dispatchLog()) ?? dispatchLog
}
private func dispatchPlanData(variant: PlanListVariant) -> Data {
switch variant {
case .full:
return PlanPDFRenderer.render(
range: range, rows: rows, churches: churches,
people: peopleByID, generatedAt: Date()
)
case .compact:
return CompactPlanPDFRenderer.render(
range: range, rows: rows, people: peopleByID, generatedAt: Date()
)
}
}
private func dispatchFilename(for recipient: DispatchRecipient, variant: PlanListVariant) -> String {
"LektorenPlan-\(dispatchPersonFileComponent(recipient))-\(variant.rawValue)-\(DayMath.key(range.start)).pdf"
}
/// The calendar file is generated per person, so its name carries the same
/// person component as the PDF to avoid overwriting files in the shared
/// temporary dispatch directory.
private func dispatchCalendarFilename(for recipient: DispatchRecipient) -> String {
"LektorenPlan-\(dispatchPersonFileComponent(recipient))-Kalender-\(DayMath.key(range.start)).ics"
}
private func dispatchPersonFileComponent(_ recipient: DispatchRecipient) -> String {
recipient.person.fullName
.folding(options: .diacriticInsensitive, locale: .current)
.replacingOccurrences(of: " ", with: "-")
.components(separatedBy: CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-_")).inverted)
.joined()
}
private func dispatchTempDirectory() -> URL {
let manager = FileManager.default
let directory = manager.temporaryDirectory.appendingPathComponent("LektorenPlanVersand", isDirectory: true)
try? manager.createDirectory(at: directory, withIntermediateDirectories: true)
return directory
}
// MARK: - Demo
func resetDemoData() {
rebuildContent(deleteOnly: false)
}
func deleteAllData() {
rebuildContent(deleteOnly: true)
}
private func rebuildContent(deleteOnly: Bool) {
guard !isResettingData else { return }
isResettingData = true
let database = db
Task {
do {
try await Task.detached(priority: .userInitiated) {
if deleteOnly {
try database.deleteAllData()
} else {
try database.resetDemoData()
}
}.value
range = .quarter(containing: DayMath.today())
db.setSetting("rangeStart", value: DayMath.key(range.start))
db.setSetting("rangeEnd", value: DayMath.key(range.end))
loadAll()
loadDispatch()
isResettingData = false
showToast(
deleteOnly ? "Alle Daten wurden gelöscht." : "Demo-Daten neu aufgebaut.",
kind: .success
)
} catch {
isResettingData = false
alertTitle = deleteOnly
? "Daten konnten nicht gelöscht werden"
: "Demo-Daten konnten nicht zurückgesetzt werden"
alertMessage = error.localizedDescription
}
}
}
func openDatabaseFolder() {
guard db.path != ":memory:" else { return }
NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: db.path)])
}
var databaseSizeLabel: String {
let bytes = db.databaseSizeBytes()
return ByteCountFormatter.string(fromByteCount: Int64(bytes), countStyle: .file)
}
// MARK: - Toast
func showToast(_ message: String, kind: ToastKind = .info) {
toastTask?.cancel()
let newToast = Toast(message: message, kind: kind)
withAnimation(.spring(response: 0.32, dampingFraction: 0.86)) {
toast = newToast
}
toastTask = Task { @MainActor [weak self] in
try? await Task.sleep(nanoseconds: 3_400_000_000)
guard !Task.isCancelled else { return }
guard self?.toast?.id == newToast.id else { return }
withAnimation(.easeOut(duration: 0.2)) {
self?.toast = nil
}
}
}
}