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? 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] = [:] 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] = [:] 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 } } } }