1. Version Versendung

This commit is contained in:
concierge committed 2026-11-14 09:33:17 +01:00
1 parent d7113afa5f
commit 781aa20253
31 files changed
+4023 -10

No files matched your search

+361 -2
View File
@@ -9,6 +9,7 @@ enum AppSection: String, CaseIterable, Identifiable, Hashable {
case serviceOrder
case team
case statistics
case dispatch
case exchange
case settings
@@ -20,6 +21,7 @@ enum AppSection: String, CaseIterable, Identifiable, Hashable {
case .serviceOrder: "Gottesdienstordnung"
case .team: "Lektoren & Helfer"
case .statistics: "Statistik"
case .dispatch: "Versendung"
case .exchange: "Austausch"
case .settings: "Einstellungen"
}
@@ -31,6 +33,7 @@ enum AppSection: String, CaseIterable, Identifiable, Hashable {
case .serviceOrder: "Ordnung"
case .team: "Team"
case .statistics: "Statistik"
case .dispatch: "Versendung"
case .exchange: "Austausch"
case .settings: "Einstellungen"
}
@@ -42,6 +45,7 @@ enum AppSection: String, CaseIterable, Identifiable, Hashable {
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"
}
@@ -53,8 +57,9 @@ enum AppSection: String, CaseIterable, Identifiable, Hashable {
case .serviceOrder: 2
case .team: 3
case .statistics: 4
case .exchange: 5
case .settings: 6
case .dispatch: 5
case .exchange: 6
case .settings: 7
}
}
}
@@ -144,8 +149,28 @@ struct CandidateSuggestion: Identifiable {
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
"""
let db: AppDatabase
@Published var section: AppSection = .planning
@@ -183,6 +208,10 @@ final class PlanModel: ObservableObject {
@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
private var toastTask: Task<Void, Never>?
@@ -217,6 +246,7 @@ final class PlanModel: ObservableObject {
self.showOnlySundaysAndFeasts = value == "1"
}
loadAll()
loadDispatch()
if let warning { alertMessage = warning; alertTitle = "Eingeschränkter Betrieb" }
}
@@ -829,6 +859,7 @@ final class PlanModel: ObservableObject {
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"
@@ -922,6 +953,333 @@ final class PlanModel: ObservableObject {
}
}
// 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 result: [DispatchAssignment] = []
for row in rows {
for service in row.services {
for assignment in service.assignments where assignment.personID == personID {
result.append(DispatchAssignment(
id: assignment.id,
date: row.date,
timeMinutes: service.service.timeMinutes,
church: service.church.shortName,
title: service.service.title,
role: assignment.role
))
}
}
}
return result.sorted {
if $0.date != $1.date { return $0.date < $1.date }
return $0.timeMinutes < $1.timeMinutes
}
}
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("dispatch.intro"), !stored.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
dispatchIntro = stored
} else {
dispatchIntro = Self.defaultDispatchIntro
}
dispatchGreeting = db.setting("dispatch.greeting") ?? Self.defaultDispatchGreeting
}
/// Persists the texts and every currently visible preference.
func saveDispatchSettings(showConfirmation: Bool = true) {
db.setSetting("dispatch.intro", value: dispatchIntro)
db.setSetting("dispatch.greeting", 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))
let greeting = resolvedDispatchText(dispatchGreeting)
if !greeting.isEmpty {
parts.append(greeting)
}
return parts.joined(separator: "\n\n")
}
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.role.title) · \($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
}
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])
}
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: "Anhang: \(variant.shortTitle)", 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)
}
}
/// 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(cover) }
}
let variant = recipient.preference.variant
if planCache[variant] == nil {
planCache[variant] = dispatchPlanData(variant: variant)
}
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 {
let base = recipient.person.fullName
.folding(options: .diacriticInsensitive, locale: .current)
.replacingOccurrences(of: " ", with: "-")
.components(separatedBy: CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-_")).inverted)
.joined()
return "LektorenPlan-\(base)-\(variant.rawValue)-\(DayMath.key(range.start)).pdf"
}
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() {
@@ -950,6 +1308,7 @@ final class PlanModel: ObservableObject {
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.",