1. Prototyp
This commit is contained in:
1 parent
e723eee440
commit
c24bc91768
37 files changed
+11610
No files matched your search
@@ -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
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user