1. Prototyp

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

No files matched your search

+880
View File
@@ -0,0 +1,880 @@
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 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 .exchange: "Austausch"
case .settings: "Einstellungen"
}
}
var shortTitle: String {
switch self {
case .planning: "Planung"
case .serviceOrder: "Ordnung"
case .team: "Team"
case .statistics: "Statistik"
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 .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 .exchange: 5
case .settings: 6
}
}
}
enum PlanFilter: String, CaseIterable, Identifiable {
case all
case services
case open
var id: String { rawValue }
var title: String {
switch self {
case .all: "Alle Tage"
case .services: "Mit Gottesdiensten"
case .open: "Nur offene"
}
}
}
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
}
struct CandidateSuggestion: Identifiable {
var person: Person
var score: Double
var warnings: [String]
var blocked: Bool
var preferred: Bool
var totalAssignments: Int
var id: String { person.id }
}
@MainActor
final class PlanModel: ObservableObject {
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 importPreview: ImportPreview?
@Published var pdfPreview: PDFPreview?
@Published var databasePath: String
@Published var startupWarning: String?
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()
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 }
}
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 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) -> 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(
replaceExisting: replaceExisting,
respectPreferredWeekdays: db.setting("respectPreferredWeekdays") != "0",
weightFairness: Double(db.setting("fairnessWeight") ?? "") ?? 2.2,
maxAssignmentsPerDay: 1
)
let planner = ServicePlanner(
people: people,
absences: absences,
services: rangeServices,
existingAssignments: existing,
churches: churches,
options: options
)
let result = planner.plan()
if result.filledCount > 0 || replaceExisting {
try db.savePlan(result.assignments, in: range, replaceUnlocked: replaceExisting)
}
loadAll()
planResult = result
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,
options: PlannerOptions(replaceExisting: false, respectPreferredWeekdays: false)
)
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 {
try db.setAssignment(serviceID: serviceID, role: role, personID: personID)
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 dayCounts: [String: Int] = [:]
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
dayCounts["\(assignment.personID)|\(assignedService.dateKey)", default: 0] += 1
}
let assignedToService = Set(assignments.filter { $0.serviceID == service.id }.map(\.personID))
let weekday = DayMath.weekday(service.date)
return people
.filter { $0.active && $0.canFill(role) && !assignedToService.contains($0.id) }
.map { person in
var warnings: [String] = []
var blocked = false
if absences.contains(where: { $0.personID == person.id && $0.overlaps(service.date) }) {
warnings.append("abwesend")
blocked = true
}
if !person.preferredWeekdays.isEmpty && !person.preferredWeekdays.contains(weekday) {
warnings.append("Einsatztag passt nicht")
blocked = true
}
if person.maxPerMonth > 0, monthlyCounts["\(person.id)|\(monthKey)", default: 0] >= person.maxPerMonth {
warnings.append("Monatslimit")
blocked = true
}
if dayCounts["\(person.id)|\(service.dateKey)", default: 0] > 0 {
warnings.append("bereits an diesem Tag")
blocked = true
}
var score = 0.0
var preferred = false
if person.preferredChurchIDs.contains(service.churchID) {
score += 8
preferred = true
}
if !person.preferredChurchIDs.isEmpty && !person.preferredChurchIDs.contains(service.churchID) {
score -= 2
}
if person.preferredWeekdays.contains(weekday) {
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(totalCounts[person.id, default: 0]) * 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,
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()
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() {
let data = PlanPDFRenderer.render(
range: range,
rows: rows,
churches: churches,
people: peopleByID,
generatedAt: Date()
)
pdfPreview = PDFPreview(
data: data,
title: "Lektorenplan \(range.shortTitle)",
filename: "LektorenPlan_\(DayMath.key(range.start))_\(DayMath.key(range.end)).pdf"
)
}
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) {
let pdfData = data ?? PlanPDFRenderer.render(
range: range,
rows: rows,
churches: churches,
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
info.orientation = .landscape
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: - Demo
func resetDemoData() {
do {
try db.resetDemoData()
loadAll()
showToast("Demo-Daten neu aufgebaut.", kind: .success)
} catch {
alertTitle = "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
}
}
}
}