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