1. Prototyp

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

No files matched your search

@@ -0,0 +1,454 @@
import SwiftUI
import LektorenPlanCore
/// Hand-drawn, reduced line illustrations of the four church buildings.
/// The drawings deliberately avoid text; the name is revealed on hover by the caller.
struct ChurchGlyph: View {
var symbol: ChurchSymbol
var tint: Color
var lineWidth: CGFloat = 1.4
var showGround: Bool = true
var body: some View {
Canvas { context, size in
let scale = min(size.width / 120, size.height / 86)
let offset = CGPoint(
x: (size.width - 120 * scale) / 2,
y: (size.height - 86 * scale) / 2
)
let transform = CGAffineTransform(translationX: offset.x, y: offset.y)
.scaledBy(x: scale, y: scale)
func path(_ build: (inout Path) -> Void) -> Path {
var p = Path()
build(&p)
return p.applying(transform)
}
switch symbol {
case .basilica:
drawBasilica(context: &context, strokeColor: tint, fillColor: tint.opacity(0.055), path: path)
case .gothic:
drawGothic(context: &context, strokeColor: tint, fillColor: tint.opacity(0.055), path: path)
case .modern:
drawModern(context: &context, strokeColor: tint, fillColor: tint.opacity(0.055), path: path)
case .rotunda:
drawRotunda(context: &context, strokeColor: tint, fillColor: tint.opacity(0.055), path: path)
case .roundTower:
drawRoundTower(context: &context, strokeColor: tint, fillColor: tint.opacity(0.055), path: path)
case .chapel:
drawChapel(context: &context, strokeColor: tint, fillColor: tint.opacity(0.055), path: path)
}
if showGround {
let ground = path { p in
p.move(to: CGPoint(x: 8, y: 76))
p.addLine(to: CGPoint(x: 112, y: 76))
}
context.stroke(ground, with: .color(tint.opacity(0.35)), style: StrokeStyle(lineWidth: 0.8, dash: [2, 3]))
}
}
.accessibilityLabel(symbol.caption)
}
private func drawBasilica(
context: inout GraphicsContext,
strokeColor: Color,
fillColor: Color,
path: ((inout Path) -> Void) -> Path
) {
let stroke = GraphicsContext.Shading.color(strokeColor)
let fill = GraphicsContext.Shading.color(fillColor)
let nave = path { p in
p.move(to: CGPoint(x: 42, y: 42))
p.addLine(to: CGPoint(x: 60, y: 28))
p.addLine(to: CGPoint(x: 78, y: 42))
p.addLine(to: CGPoint(x: 78, y: 75))
p.addLine(to: CGPoint(x: 42, y: 75))
p.closeSubpath()
}
context.fill(nave, with: fill)
context.stroke(nave, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let roof = path { p in
p.move(to: CGPoint(x: 39, y: 43))
p.addLine(to: CGPoint(x: 60, y: 26))
p.addLine(to: CGPoint(x: 81, y: 43))
}
context.stroke(roof, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let aisleLeft = path { p in
p.move(to: CGPoint(x: 27, y: 55))
p.addLine(to: CGPoint(x: 27, y: 75))
p.addLine(to: CGPoint(x: 42, y: 75))
p.addLine(to: CGPoint(x: 42, y: 50))
p.addLine(to: CGPoint(x: 32, y: 47))
}
let aisleRight = path { p in
p.move(to: CGPoint(x: 78, y: 50))
p.addLine(to: CGPoint(x: 78, y: 75))
p.addLine(to: CGPoint(x: 93, y: 75))
p.addLine(to: CGPoint(x: 93, y: 55))
p.addLine(to: CGPoint(x: 83, y: 59))
}
context.stroke(aisleLeft, with: stroke, style: StrokeStyle(lineWidth: lineWidth * 0.85, lineJoin: .round))
context.stroke(aisleRight, with: stroke, style: StrokeStyle(lineWidth: lineWidth * 0.85, lineJoin: .round))
let tower = path { p in
p.move(to: CGPoint(x: 88, y: 26))
p.addLine(to: CGPoint(x: 99, y: 26))
p.addLine(to: CGPoint(x: 99, y: 75))
p.addLine(to: CGPoint(x: 88, y: 75))
p.closeSubpath()
}
context.fill(tower, with: fill)
context.stroke(tower, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let spire = path { p in
p.move(to: CGPoint(x: 86, y: 27))
p.addLine(to: CGPoint(x: 93.5, y: 12))
p.addLine(to: CGPoint(x: 101, y: 27))
}
context.stroke(spire, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let door = path { p in
p.move(to: CGPoint(x: 55, y: 75))
p.addLine(to: CGPoint(x: 55, y: 62))
p.addQuadCurve(to: CGPoint(x: 65, y: 62), control: CGPoint(x: 60, y: 54))
p.addLine(to: CGPoint(x: 65, y: 75))
}
context.stroke(door, with: stroke, style: StrokeStyle(lineWidth: lineWidth * 0.8))
for x in [48.0, 72.0] {
let window = path { p in
p.move(to: CGPoint(x: x, y: 68))
p.addLine(to: CGPoint(x: x, y: 58))
p.addQuadCurve(to: CGPoint(x: x + 6, y: 58), control: CGPoint(x: x + 3, y: 53))
p.addLine(to: CGPoint(x: x + 6, y: 68))
}
context.stroke(window, with: .color(strokeColor.opacity(0.65)), style: StrokeStyle(lineWidth: 0.8))
}
let cross = path { p in
p.move(to: CGPoint(x: 93.5, y: 12))
p.addLine(to: CGPoint(x: 93.5, y: 4))
p.move(to: CGPoint(x: 90.5, y: 7))
p.addLine(to: CGPoint(x: 96.5, y: 7))
}
context.stroke(cross, with: stroke, style: StrokeStyle(lineWidth: lineWidth * 0.85, lineCap: .round))
}
private func drawGothic(
context: inout GraphicsContext,
strokeColor: Color,
fillColor: Color,
path: ((inout Path) -> Void) -> Path
) {
let stroke = GraphicsContext.Shading.color(strokeColor)
let fill = GraphicsContext.Shading.color(fillColor)
let body = path { p in
p.move(to: CGPoint(x: 36, y: 75))
p.addLine(to: CGPoint(x: 36, y: 44))
p.addQuadCurve(to: CGPoint(x: 60, y: 35), control: CGPoint(x: 46, y: 37))
p.addQuadCurve(to: CGPoint(x: 84, y: 44), control: CGPoint(x: 74, y: 37))
p.addLine(to: CGPoint(x: 84, y: 75))
p.closeSubpath()
}
context.fill(body, with: fill)
context.stroke(body, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let spire = path { p in
p.move(to: CGPoint(x: 31, y: 45))
p.addLine(to: CGPoint(x: 60, y: 8))
p.addLine(to: CGPoint(x: 89, y: 45))
}
context.stroke(spire, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let tower = path { p in
p.move(to: CGPoint(x: 88, y: 29))
p.addLine(to: CGPoint(x: 101, y: 29))
p.addLine(to: CGPoint(x: 101, y: 75))
p.addLine(to: CGPoint(x: 88, y: 75))
}
context.stroke(tower, with: stroke, style: StrokeStyle(lineWidth: lineWidth * 0.9))
let towerSpire = path { p in
p.move(to: CGPoint(x: 85, y: 30))
p.addLine(to: CGPoint(x: 94.5, y: 10))
p.addLine(to: CGPoint(x: 104, y: 30))
}
context.stroke(towerSpire, with: stroke, style: StrokeStyle(lineWidth: lineWidth * 0.9, lineJoin: .round))
let door = path { p in
p.move(to: CGPoint(x: 54, y: 75))
p.addLine(to: CGPoint(x: 54, y: 57))
p.addQuadCurve(to: CGPoint(x: 66, y: 57), control: CGPoint(x: 60, y: 48))
p.addLine(to: CGPoint(x: 66, y: 75))
}
context.stroke(door, with: stroke, style: StrokeStyle(lineWidth: lineWidth * 0.85))
let rose = path { p in
p.addEllipse(in: CGRect(x: 50, y: 44, width: 20, height: 20))
}
context.stroke(rose, with: .color(strokeColor.opacity(0.8)), style: StrokeStyle(lineWidth: 0.9))
for angle in stride(from: 0.0, to: 360.0, by: 60.0) {
let rad = angle * .pi / 180
let line = path { p in
p.move(to: CGPoint(x: 60, y: 54))
p.addLine(to: CGPoint(x: 60 + cos(rad) * 9, y: 54 + sin(rad) * 9))
}
context.stroke(line, with: .color(strokeColor.opacity(0.55)), style: StrokeStyle(lineWidth: 0.6))
}
let cross = path { p in
p.move(to: CGPoint(x: 60, y: 8))
p.addLine(to: CGPoint(x: 60, y: 1))
p.move(to: CGPoint(x: 57, y: 4))
p.addLine(to: CGPoint(x: 63, y: 4))
}
context.stroke(cross, with: stroke, style: StrokeStyle(lineWidth: 0.9, lineCap: .round))
}
private func drawModern(
context: inout GraphicsContext,
strokeColor: Color,
fillColor: Color,
path: ((inout Path) -> Void) -> Path
) {
let stroke = GraphicsContext.Shading.color(strokeColor)
let fill = GraphicsContext.Shading.color(fillColor)
let body = path { p in
p.move(to: CGPoint(x: 30, y: 75))
p.addLine(to: CGPoint(x: 34, y: 43))
p.addLine(to: CGPoint(x: 63, y: 31))
p.addLine(to: CGPoint(x: 87, y: 46))
p.addLine(to: CGPoint(x: 86, y: 75))
p.closeSubpath()
}
context.fill(body, with: fill)
context.stroke(body, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let roof = path { p in
p.move(to: CGPoint(x: 28, y: 45))
p.addLine(to: CGPoint(x: 63, y: 28))
p.addLine(to: CGPoint(x: 89, y: 46))
}
context.stroke(roof, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let tower = path { p in
p.move(to: CGPoint(x: 91, y: 24))
p.addLine(to: CGPoint(x: 103, y: 24))
p.addLine(to: CGPoint(x: 103, y: 75))
p.addLine(to: CGPoint(x: 91, y: 75))
p.closeSubpath()
}
context.fill(tower, with: fill)
context.stroke(tower, with: stroke, style: StrokeStyle(lineWidth: lineWidth))
let slit = path { p in
p.move(to: CGPoint(x: 96.5, y: 34))
p.addLine(to: CGPoint(x: 96.5, y: 62))
p.move(to: CGPoint(x: 98.5, y: 34))
p.addLine(to: CGPoint(x: 98.5, y: 62))
}
context.stroke(slit, with: .color(strokeColor.opacity(0.7)), style: StrokeStyle(lineWidth: 0.7))
let cross = path { p in
p.move(to: CGPoint(x: 97, y: 24))
p.addLine(to: CGPoint(x: 97, y: 12))
p.move(to: CGPoint(x: 92, y: 17))
p.addLine(to: CGPoint(x: 102, y: 17))
}
context.stroke(cross, with: stroke, style: StrokeStyle(lineWidth: 1.0, lineCap: .round))
let glass = path { p in
p.move(to: CGPoint(x: 38, y: 72))
p.addLine(to: CGPoint(x: 38, y: 50))
p.addLine(to: CGPoint(x: 58, y: 43))
p.addLine(to: CGPoint(x: 58, y: 72))
p.closeSubpath()
}
context.stroke(glass, with: .color(strokeColor.opacity(0.65)), style: StrokeStyle(lineWidth: 0.8))
for i in 0..<3 {
let x = 40.0 + Double(i) * 6
let line = path { p in
p.move(to: CGPoint(x: x, y: 70))
p.addLine(to: CGPoint(x: x + 2.5, y: 47))
}
context.stroke(line, with: .color(strokeColor.opacity(0.35)), style: StrokeStyle(lineWidth: 0.5))
}
let entrance = path { p in
p.move(to: CGPoint(x: 66, y: 75))
p.addLine(to: CGPoint(x: 66, y: 56))
p.addLine(to: CGPoint(x: 82, y: 51))
p.addLine(to: CGPoint(x: 82, y: 75))
}
context.stroke(entrance, with: .color(strokeColor.opacity(0.65)), style: StrokeStyle(lineWidth: 0.8))
}
private func drawRotunda(
context: inout GraphicsContext,
strokeColor: Color,
fillColor: Color,
path: ((inout Path) -> Void) -> Path
) {
let stroke = GraphicsContext.Shading.color(strokeColor)
let fill = GraphicsContext.Shading.color(fillColor)
let base = path { p in
p.move(to: CGPoint(x: 28, y: 75))
p.addLine(to: CGPoint(x: 32, y: 53))
p.addQuadCurve(to: CGPoint(x: 88, y: 53), control: CGPoint(x: 60, y: 39))
p.addLine(to: CGPoint(x: 92, y: 75))
p.closeSubpath()
}
context.fill(base, with: fill)
context.stroke(base, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let dome = path { p in
p.move(to: CGPoint(x: 32, y: 53))
p.addQuadCurve(to: CGPoint(x: 88, y: 53), control: CGPoint(x: 60, y: 26))
}
context.stroke(dome, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let crown = path { p in
p.move(to: CGPoint(x: 56, y: 36))
p.addLine(to: CGPoint(x: 64, y: 36))
p.addLine(to: CGPoint(x: 64, y: 31))
p.addLine(to: CGPoint(x: 56, y: 31))
p.closeSubpath()
}
context.stroke(crown, with: .color(strokeColor.opacity(0.8)), style: StrokeStyle(lineWidth: 0.8))
let cross = path { p in
p.move(to: CGPoint(x: 60, y: 31))
p.addLine(to: CGPoint(x: 60, y: 20))
p.move(to: CGPoint(x: 55.5, y: 24))
p.addLine(to: CGPoint(x: 64.5, y: 24))
}
context.stroke(cross, with: stroke, style: StrokeStyle(lineWidth: 1.0, lineCap: .round))
for x in [38.0, 47.0, 73.0, 82.0] {
let window = path { p in
p.move(to: CGPoint(x: x, y: 70))
p.addLine(to: CGPoint(x: x, y: 58))
}
context.stroke(window, with: .color(strokeColor.opacity(0.55)), style: StrokeStyle(lineWidth: 0.8))
}
let door = path { p in
p.move(to: CGPoint(x: 55, y: 75))
p.addLine(to: CGPoint(x: 55, y: 61))
p.addQuadCurve(to: CGPoint(x: 65, y: 61), control: CGPoint(x: 60, y: 55))
p.addLine(to: CGPoint(x: 65, y: 75))
}
context.stroke(door, with: stroke, style: StrokeStyle(lineWidth: lineWidth * 0.85))
}
private func drawRoundTower(
context: inout GraphicsContext,
strokeColor: Color,
fillColor: Color,
path: ((inout Path) -> Void) -> Path
) {
let stroke = GraphicsContext.Shading.color(strokeColor)
let fill = GraphicsContext.Shading.color(fillColor)
let body = path { p in
p.move(to: CGPoint(x: 35, y: 75))
p.addLine(to: CGPoint(x: 35, y: 35))
p.addLine(to: CGPoint(x: 78, y: 35))
p.addLine(to: CGPoint(x: 78, y: 75))
}
context.stroke(body, with: stroke, style: StrokeStyle(lineWidth: lineWidth))
let roof = path { p in
p.move(to: CGPoint(x: 30, y: 36))
p.addLine(to: CGPoint(x: 56.5, y: 12))
p.addLine(to: CGPoint(x: 83, y: 36))
}
context.stroke(roof, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let tower = path { p in
p.addEllipse(in: CGRect(x: 84, y: 35, width: 20, height: 40))
}
context.fill(tower, with: fill)
context.stroke(tower, with: stroke, style: StrokeStyle(lineWidth: lineWidth))
let cap = path { p in
p.move(to: CGPoint(x: 82, y: 35))
p.addQuadCurve(to: CGPoint(x: 106, y: 35), control: CGPoint(x: 94, y: 20))
}
context.stroke(cap, with: stroke, style: StrokeStyle(lineWidth: lineWidth))
let cross = path { p in
p.move(to: CGPoint(x: 94, y: 24))
p.addLine(to: CGPoint(x: 94, y: 14))
p.move(to: CGPoint(x: 90, y: 18))
p.addLine(to: CGPoint(x: 98, y: 18))
}
context.stroke(cross, with: stroke, style: StrokeStyle(lineWidth: 0.9, lineCap: .round))
let window = path { p in
p.move(to: CGPoint(x: 51, y: 70))
p.addLine(to: CGPoint(x: 51, y: 48))
p.addQuadCurve(to: CGPoint(x: 61, y: 48), control: CGPoint(x: 56, y: 42))
p.addLine(to: CGPoint(x: 61, y: 70))
}
context.stroke(window, with: .color(strokeColor.opacity(0.65)), style: StrokeStyle(lineWidth: 0.8))
}
private func drawChapel(
context: inout GraphicsContext,
strokeColor: Color,
fillColor: Color,
path: ((inout Path) -> Void) -> Path
) {
let stroke = GraphicsContext.Shading.color(strokeColor)
let fill = GraphicsContext.Shading.color(fillColor)
let body = path { p in
p.move(to: CGPoint(x: 40, y: 75))
p.addLine(to: CGPoint(x: 40, y: 46))
p.addLine(to: CGPoint(x: 78, y: 46))
p.addLine(to: CGPoint(x: 78, y: 75))
p.closeSubpath()
}
context.fill(body, with: fill)
context.stroke(body, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let roof = path { p in
p.move(to: CGPoint(x: 35, y: 47))
p.addLine(to: CGPoint(x: 59, y: 24))
p.addLine(to: CGPoint(x: 83, y: 47))
}
context.stroke(roof, with: stroke, style: StrokeStyle(lineWidth: lineWidth, lineJoin: .round))
let cross = path { p in
p.move(to: CGPoint(x: 59, y: 24))
p.addLine(to: CGPoint(x: 59, y: 13))
p.move(to: CGPoint(x: 55, y: 17))
p.addLine(to: CGPoint(x: 63, y: 17))
}
context.stroke(cross, with: stroke, style: StrokeStyle(lineWidth: 1.0, lineCap: .round))
let door = path { p in
p.move(to: CGPoint(x: 55, y: 75))
p.addLine(to: CGPoint(x: 55, y: 60))
p.addQuadCurve(to: CGPoint(x: 65, y: 60), control: CGPoint(x: 60, y: 53))
p.addLine(to: CGPoint(x: 65, y: 75))
}
context.stroke(door, with: stroke, style: StrokeStyle(lineWidth: 0.85))
let window = path { p in
p.addEllipse(in: CGRect(x: 45, y: 55, width: 7, height: 11))
p.addEllipse(in: CGRect(x: 67, y: 55, width: 7, height: 11))
}
context.stroke(window, with: .color(strokeColor.opacity(0.6)), style: StrokeStyle(lineWidth: 0.7))
}
}
struct ChurchMonogram: View {
var church: Church
var size: CGFloat = 34
var body: some View {
ZStack {
RoundedRectangle(cornerRadius: size * 0.28, style: .continuous)
.fill(LP.churchColor(church.colorHex).opacity(0.10))
ChurchGlyph(symbol: church.symbol, tint: LP.churchColor(church.colorHex), lineWidth: 1.6, showGround: false)
.padding(size * 0.16)
}
.frame(width: size, height: size)
.overlay(
RoundedRectangle(cornerRadius: size * 0.28, style: .continuous)
.strokeBorder(LP.churchColor(church.colorHex).opacity(0.22), lineWidth: 0.8)
)
}
}
@@ -0,0 +1,396 @@
import SwiftUI
import LektorenPlanCore
struct TimelineRangePicker: View {
@EnvironmentObject private var model: PlanModel
@State private var draftStart = DayMath.today()
@State private var draftEnd = DayMath.today()
@State private var initialized = false
@State private var dragOrigin: DayRange?
private let minDays = 7
var body: some View {
let bounds = timelineBounds
VStack(spacing: 12) {
header(bounds: bounds)
timeline(bounds: bounds)
.frame(height: 64)
footer
}
.padding(.horizontal, 18)
.padding(.vertical, 14)
.background(
RoundedRectangle(cornerRadius: 16, style: .continuous)
.fill(LP.card)
.shadow(color: .black.opacity(0.035), radius: 10, y: 4)
)
.overlay(
RoundedRectangle(cornerRadius: 16, style: .continuous)
.strokeBorder(LP.line.opacity(0.55), lineWidth: 1)
)
.onAppear {
guard !initialized else { return }
draftStart = model.range.start
draftEnd = model.range.end
initialized = true
}
.onChange(of: model.range) { _, newValue in
draftStart = newValue.start
draftEnd = newValue.end
}
}
private var timelineBounds: DayRange {
let currentYear = DayMath.year(DayMath.today())
let firstYear = min(currentYear - 1, DayMath.year(draftStart) - 1)
let lastYear = max(currentYear + 2, DayMath.year(draftEnd) + 1)
let start = DayMath.date(fromKey: DayMath.key(year: firstYear, month: 1, day: 1)) ?? DayMath.today()
let end = DayMath.date(fromKey: DayMath.key(year: lastYear, month: 12, day: 31)) ?? DayMath.today()
return DayRange(start: start, end: end)
}
private func header(bounds: DayRange) -> some View {
HStack(alignment: .center, spacing: 12) {
HStack(spacing: 7) {
Image(systemName: "calendar.badge.clock")
.font(.system(size: 11, weight: .semibold))
.foregroundStyle(LP.accent)
Text("PLANUNGSZEITRAUM")
.font(.system(size: 9.5, weight: .bold, design: .rounded))
.tracking(1.2)
.foregroundStyle(LP.inkTertiary)
}
Text(rangeTitle)
.font(LP.serifSubhead)
.foregroundStyle(LP.ink)
.lineLimit(1)
Spacer(minLength: 8)
presetChip("Dieses Quartal") {
model.setRange(.quarter(containing: DayMath.today()))
}
presetChip("Osterzeit") {
let year = DayMath.year(DayMath.today())
let easter = LiturgicalCalendarEngine.easterSunday(year: year)
model.setRange(DayRange(start: easter, end: LiturgicalCalendarEngine.pentecost(year: year)))
}
presetChip("Weihnachtszeit") {
let year = DayMath.year(DayMath.today())
let christmas = DayMath.date(fromKey: DayMath.key(year: year, month: 12, day: 24)) ?? DayMath.today()
let baptism = LiturgicalCalendarEngine.baptismOfTheLord(year: year + 1)
model.setRange(DayRange(start: christmas, end: baptism))
}
Menu {
Section("Quartale") {
ForEach(nextQuarters(4), id: \.id) { item in
Button(item.label) { model.setRange(item.range) }
}
}
Section("Kirchenjahr") {
Button("Aktuelles Kirchenjahr") { model.setRange(currentChurchYear) }
Button("Osterzeit \(DayMath.year(DayMath.today()))") {
let y = DayMath.year(DayMath.today())
model.setRange(DayRange(
start: LiturgicalCalendarEngine.easterSunday(year: y),
end: LiturgicalCalendarEngine.pentecost(year: y)
))
}
Button("Adventszeit") {
let y = DayMath.year(DayMath.today())
let advent = LiturgicalCalendarEngine.adventStart(year: y)
model.setRange(DayRange(start: advent, end: DayMath.adding(days: -1, to: DayMath.date(fromKey: DayMath.key(year: y, month: 12, day: 25)) ?? advent)))
}
}
Section("Weitere") {
Button("Nächste 90 Tage") { model.setRange(.days(90)) }
Button("Rest des Jahres") {
model.setRange(DayRange(start: DayMath.today(), end: DayMath.endOfYear(DayMath.today())))
}
Button("Gesamtes Kalenderfenster") { model.setRange(bounds) }
}
} label: {
HStack(spacing: 4) {
Image(systemName: "bookmark")
Text("Zeitmarken")
}
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.inkSecondary)
}
.menuStyle(.borderlessButton)
.fixedSize()
}
}
private func timeline(bounds: DayRange) -> some View {
GeometryReader { geo in
let width = geo.size.width
let y: CGFloat = 34
let totalDays = CGFloat(max(1, bounds.dayCount - 1))
let xStart = x(for: draftStart, bounds: bounds, width: width)
let xEnd = x(for: draftEnd, bounds: bounds, width: width)
let spans = seasonSpans(bounds: bounds)
ZStack(alignment: .topLeading) {
// Season background
ForEach(Array(spans.enumerated()), id: \.offset) { _, span in
let x1 = x(for: span.range.start, bounds: bounds, width: width)
let x2 = x(for: span.range.end, bounds: bounds, width: width)
Rectangle()
.fill(Color(hex: span.season.colorHex).opacity(0.11))
.frame(width: max(1, x2 - x1), height: 18)
.offset(x: x1, y: y - 9)
}
// Base line
RoundedRectangle(cornerRadius: 2)
.fill(LP.line.opacity(0.65))
.frame(width: width, height: 2)
.offset(y: y - 1)
// Selected interval
RoundedRectangle(cornerRadius: 4)
.fill(
LinearGradient(colors: [LP.accent.opacity(0.20), LP.gold.opacity(0.22)],
startPoint: .leading, endPoint: .trailing)
)
.frame(width: max(4, xEnd - xStart), height: 22)
.offset(x: xStart, y: y - 11)
.overlay(
RoundedRectangle(cornerRadius: 4)
.strokeBorder(LP.accent.opacity(0.45), lineWidth: 1)
.frame(width: max(4, xEnd - xStart), height: 22)
.offset(x: xStart, y: y - 11)
)
// Quarter ticks and year labels
ForEach(Array(quarterTicks(bounds: bounds).enumerated()), id: \.offset) { _, tick in
let tickX = x(for: tick.date, bounds: bounds, width: width)
Rectangle()
.fill(tick.isYear ? LP.inkTertiary.opacity(0.45) : LP.line.opacity(0.9))
.frame(width: 1, height: tick.isYear ? 30 : 20)
.offset(x: tickX, y: y - (tick.isYear ? 15 : 10))
if tick.isYear {
Text(String(DayMath.year(tick.date)))
.font(.system(size: 8.5, weight: .semibold, design: .rounded))
.foregroundStyle(LP.inkTertiary)
.offset(x: tickX + 4, y: 3)
}
}
// Month labels around selection
if width > 500 {
Text(DayMath.mediumString(draftStart))
.font(.system(size: 9, weight: .semibold, design: .rounded))
.foregroundStyle(LP.accent)
.offset(x: min(max(0, xStart - 26), width - 100), y: y + 18)
Text(DayMath.mediumString(draftEnd))
.font(.system(size: 9, weight: .semibold, design: .rounded))
.foregroundStyle(LP.gold)
.offset(x: min(max(0, xEnd - 26), width - 100), y: y + 18)
}
// Left handle
handle(color: LP.accent, help: "Beginn: \(DayMath.longString(draftStart))\nZiehen zum Ändern")
.position(x: xStart, y: y)
.gesture(dragGesture(handle: .start, bounds: bounds, width: width, totalDays: totalDays))
// Right handle
handle(color: LP.gold, help: "Ende: \(DayMath.longString(draftEnd))\nZiehen zum Ändern")
.position(x: xEnd, y: y)
.gesture(dragGesture(handle: .end, bounds: bounds, width: width, totalDays: totalDays))
}
}
}
private var footer: some View {
HStack(spacing: 14) {
HStack(spacing: 5) {
Circle().fill(LP.accent).frame(width: 6, height: 6)
Text(DayMath.mediumString(draftStart))
}
HStack(spacing: 5) {
Circle().fill(LP.gold).frame(width: 6, height: 6)
Text(DayMath.mediumString(draftEnd))
}
Hairline().frame(width: 18)
Text("\(draftRange.dayCount) Tage")
.foregroundStyle(LP.inkSecondary)
Text("·")
.foregroundStyle(LP.inkTertiary)
Text("\(model.stats.serviceCount) Gottesdienste")
.foregroundStyle(LP.inkSecondary)
Text("·")
.foregroundStyle(LP.inkTertiary)
Text("\(Int(model.stats.coverageRate * 100)) % besetzt")
.foregroundStyle(model.stats.openSlots == 0 ? LP.success : LP.open)
Spacer()
Text("Ziehen oder Zeitmarke wählen")
.foregroundStyle(LP.inkTertiary)
}
.font(.system(size: 9.5, weight: .medium, design: .rounded))
}
private var draftRange: DayRange {
DayRange(start: draftStart, end: draftEnd)
}
private var rangeTitle: String {
"\(DayMath.mediumString(draftStart)) – \(DayMath.mediumString(draftEnd))"
}
private func presetChip(_ title: String, action: @escaping () -> Void) -> some View {
Button(action: action) {
Text(title)
.font(.system(size: 10, weight: .medium))
.foregroundStyle(LP.inkSecondary)
.padding(.horizontal, 9)
.padding(.vertical, 4)
.background(Capsule().fill(LP.cardMuted))
.overlay(Capsule().strokeBorder(LP.line.opacity(0.7), lineWidth: 0.7))
}
.buttonStyle(.plain)
}
private func handle(color: Color, help: String) -> some View {
VStack(spacing: 0) {
Circle()
.fill(color)
.frame(width: 9, height: 9)
.overlay(Circle().strokeBorder(.white.opacity(0.8), lineWidth: 1.4))
RoundedRectangle(cornerRadius: 3)
.fill(color)
.frame(width: 5, height: 24)
.overlay(
VStack(spacing: 2) {
ForEach(0..<3, id: \.self) { _ in
Capsule().fill(.white.opacity(0.65)).frame(width: 1.5, height: 2)
}
}
)
Circle()
.fill(color)
.frame(width: 5, height: 5)
.opacity(0.5)
}
.shadow(color: color.opacity(0.35), radius: 4, y: 2)
.help(help)
}
private enum DragHandle { case start, end }
private func dragGesture(handle: DragHandle, bounds: DayRange, width: CGFloat, totalDays: CGFloat) -> some Gesture {
DragGesture(minimumDistance: 0)
.onChanged { value in
if dragOrigin == nil {
dragOrigin = DayRange(start: draftStart, end: draftEnd)
}
guard let origin = dragOrigin else { return }
let dayDelta = Int((value.translation.width / max(1, width)) * totalDays)
if handle == .start {
let maxStart = DayMath.adding(days: -(minDays - 1), to: origin.end)
var newStart = DayMath.adding(days: dayDelta, to: origin.start)
if newStart < bounds.start { newStart = bounds.start }
if newStart > maxStart { newStart = maxStart }
draftStart = DayMath.normalize(newStart)
} else {
let minEnd = DayMath.adding(days: minDays - 1, to: origin.start)
var newEnd = DayMath.adding(days: dayDelta, to: origin.end)
if newEnd > bounds.end { newEnd = bounds.end }
if newEnd < minEnd { newEnd = minEnd }
draftEnd = DayMath.normalize(newEnd)
}
}
.onEnded { _ in
dragOrigin = nil
model.setRange(draftRange)
}
}
private func x(for date: Date, bounds: DayRange, width: CGFloat) -> CGFloat {
let day = DayMath.daysBetween(bounds.start, date)
let fraction = CGFloat(day) / CGFloat(max(1, bounds.dayCount - 1))
return min(width, max(0, fraction * width))
}
private struct SeasonSpan {
var range: DayRange
var season: LiturgicalSeason
}
private func seasonSpans(bounds: DayRange) -> [SeasonSpan] {
var spans: [SeasonSpan] = []
var currentSeason: LiturgicalSeason?
var spanStart: Date?
var previous: Date?
for day in bounds.days {
let season = LiturgicalCalendarEngine.season(for: day)
if season != currentSeason {
if let currentSeason, let spanStart, let previous {
spans.append(SeasonSpan(range: DayRange(start: spanStart, end: previous), season: currentSeason))
}
currentSeason = season
spanStart = day
}
previous = day
}
if let currentSeason, let spanStart, let previous {
spans.append(SeasonSpan(range: DayRange(start: spanStart, end: previous), season: currentSeason))
}
return spans
}
private struct QuarterTick {
var date: Date
var isYear: Bool
}
private func quarterTicks(bounds: DayRange) -> [QuarterTick] {
var ticks: [QuarterTick] = []
var year = DayMath.year(bounds.start)
while year <= DayMath.year(bounds.end) {
for month in [1, 4, 7, 10] {
if let date = DayMath.date(fromKey: DayMath.key(year: year, month: month, day: 1)),
bounds.contains(date) {
ticks.append(QuarterTick(date: date, isYear: month == 1))
}
}
year += 1
}
return ticks
}
private struct QuarterPreset: Identifiable {
var id: String { label }
var label: String
var range: DayRange
}
private func nextQuarters(_ count: Int) -> [QuarterPreset] {
let today = DayMath.today()
return (0..<count).map { offset in
let base = DayMath.adding(months: offset * 3, to: today)
let range = DayRange.quarter(containing: base)
let q = DayMath.quarter(range.start)
return QuarterPreset(label: "Q\(q) \(DayMath.year(range.start))", range: range)
}
}
private var currentChurchYear: DayRange {
let today = DayMath.today()
let y = DayMath.year(today)
let thisAdvent = LiturgicalCalendarEngine.adventStart(year: y)
if today < thisAdvent {
return DayRange(
start: LiturgicalCalendarEngine.adventStart(year: y - 1),
end: LiturgicalCalendarEngine.christKing(year: y)
)
}
return DayRange(
start: thisAdvent,
end: LiturgicalCalendarEngine.christKing(year: y + 1)
)
}
}
@@ -0,0 +1,80 @@
import SwiftUI
import AppKit
import LektorenPlanCore
@main
struct LektorenPlanApp: App {
@StateObject private var model = PlanModel()
var body: some Scene {
WindowGroup("LektorenPlan") {
RootView()
.environmentObject(model)
.task {
await SnapshotCapture.runIfRequested(model: model)
}
}
.windowStyle(.hiddenTitleBar)
.defaultSize(width: 1480, height: 930)
.windowResizability(.contentMinSize)
.commands {
AppCommands(model: model)
}
}
}
struct AppCommands: Commands {
let model: PlanModel
var body: some Commands {
CommandGroup(replacing: .newItem) {}
CommandGroup(after: .saveItem) {
Divider()
Button("Planungsabschnitt exportieren…") {
model.exportInteractive(scope: .plan)
}
.keyboardShortcut("e", modifiers: [.command, .shift])
Button("Ressourcen exportieren…") {
model.exportInteractive(scope: .resources)
}
Button("Importieren…") {
model.importInteractive()
}
.keyboardShortcut("i", modifiers: [.command, .shift])
Divider()
Button("PDF-Vorschau…") {
model.createPDFPreview()
}
.keyboardShortcut("p", modifiers: [.command, .shift])
Button("Drucken…") {
model.printPDF()
}
.keyboardShortcut("p", modifiers: .command)
}
CommandMenu("Planung") {
Button("Offene Dienste besetzen") {
_ = model.autoPlan(replaceExisting: false)
}
.keyboardShortcut("r", modifiers: .command)
Button("Liturgischen Kalender aktualisieren") {
Task { await model.syncLiturgy() }
}
.keyboardShortcut("u", modifiers: [.command, .shift])
Divider()
Button("Gottesdienste für Zeitraum erzeugen") {
model.generateServices()
}
}
CommandMenu("Ansicht") {
ForEach(AppSection.allCases) { section in
Button(section.title) {
model.section = section
}
.keyboardShortcut(KeyEquivalent(Character(String(section.keyboardNumber))), modifiers: .command)
}
}
}
}
@@ -0,0 +1,525 @@
import AppKit
import CoreGraphics
import LektorenPlanCore
/// Renders a printable plan for a range. The output is A4 landscape and paginates
/// automatically, repeating the header and column titles on every page.
enum PlanPDFRenderer {
private static let pageWidth: CGFloat = 842
private static let pageHeight: CGFloat = 595
private static let margin: CGFloat = 24
private static let headerHeight: CGFloat = 76
private static let columnHeaderHeight: CGFloat = 26
private static let footerHeight: CGFloat = 20
private static let dateWidth: CGFloat = 50
private static let liturgyWidth: CGFloat = 164
private static let columnGap: CGFloat = 4
// MARK: - Colours
private static let ink = NSColor(calibratedRed: 0.12, green: 0.135, blue: 0.155, alpha: 1)
private static let secondaryInk = NSColor(calibratedRed: 0.38, green: 0.385, blue: 0.39, alpha: 1)
private static let tertiaryInk = NSColor(calibratedRed: 0.52, green: 0.51, blue: 0.49, alpha: 1)
private static let lineColor = NSColor(calibratedRed: 0.845, green: 0.825, blue: 0.79, alpha: 1)
private static let accent = NSColor(calibratedRed: 0.18, green: 0.36, blue: 0.34, alpha: 1)
private static let gold = NSColor(calibratedRed: 0.72, green: 0.53, blue: 0.23, alpha: 1)
private static let burgundy = NSColor(calibratedRed: 0.49, green: 0.24, blue: 0.29, alpha: 1)
private static let sundayWash = NSColor(calibratedRed: 0.985, green: 0.955, blue: 0.885, alpha: 1)
private static let feastWash = NSColor(calibratedRed: 0.998, green: 0.955, blue: 0.79, alpha: 1)
private static let openColor = NSColor(calibratedRed: 0.70, green: 0.42, blue: 0.13, alpha: 1)
// MARK: - Fonts
private static func serif(_ size: CGFloat, bold: Bool = false) -> NSFont {
let name = bold ? "NewYork-Semibold" : "NewYork-Regular"
return NSFont(name: name, size: size) ?? NSFont.systemFont(ofSize: size, weight: bold ? .semibold : .regular)
}
private static func sans(_ size: CGFloat, weight: NSFont.Weight = .regular) -> NSFont {
NSFont.systemFont(ofSize: size, weight: weight)
}
// MARK: - Render
static func render(
range: DayRange,
rows: [DayPlanRow],
churches: [Church],
people: [String: Person],
generatedAt: Date
) -> Data {
let data = NSMutableData()
var mediaBox = CGRect(x: 0, y: 0, width: pageWidth, height: pageHeight)
guard let consumer = CGDataConsumer(data: data as CFMutableData),
let context = CGContext(consumer: consumer, mediaBox: &mediaBox, nil)
else {
return Data()
}
storedContext = context
defer { storedContext = nil }
let sortedRows = rows.sorted { $0.date < $1.date }
let churchWidth = (pageWidth - margin * 2 - dateWidth - liturgyWidth - columnGap * 5) / 4
let contentTop = margin + headerHeight + columnHeaderHeight + 4
let contentBottom = pageHeight - margin - footerHeight
var pageIndex = 0
func beginPage() {
context.beginPDFPage(nil)
context.saveGState()
// Use a top-left origin for the whole page. This keeps the row layout
// (header at the top, rows flowing downwards) straightforward.
context.translateBy(x: 0, y: pageHeight)
context.scaleBy(x: 1, y: -1)
NSGraphicsContext.saveGraphicsState()
NSGraphicsContext.current = NSGraphicsContext(cgContext: context, flipped: true)
}
func endPage() {
drawFooter(pageIndex: pageIndex, range: range)
NSGraphicsContext.restoreGraphicsState()
context.restoreGState()
context.endPDFPage()
pageIndex += 1
}
beginPage()
drawHeader(range: range, generatedAt: generatedAt)
drawColumnHeader(churches: churches, churchWidth: churchWidth)
var cursorY = contentTop
for (index, row) in sortedRows.enumerated() {
let height = rowHeight(row: row, churchWidth: churchWidth, people: people)
if cursorY + height > contentBottom {
endPage()
beginPage()
drawHeader(range: range, generatedAt: generatedAt, continuation: true)
drawColumnHeader(churches: churches, churchWidth: churchWidth)
cursorY = contentTop
}
drawRow(
row: row,
y: cursorY,
height: height,
churches: churches,
churchWidth: churchWidth,
people: people
)
cursorY += height
// A light separator is enough; keep the page airy.
if index < sortedRows.count - 1 {
context.setStrokeColor(lineColor.withAlphaComponent(0.55).cgColor)
context.setLineWidth(0.5)
context.move(to: CGPoint(x: margin, y: cursorY))
context.addLine(to: CGPoint(x: pageWidth - margin, y: cursorY))
context.strokePath()
}
}
if sortedRows.isEmpty {
let text = "Für den gewählten Zeitraum sind keine Gottesdienste hinterlegt."
drawText(
text,
in: CGRect(x: margin, y: contentTop + 12, width: pageWidth - margin * 2, height: 30),
font: serif(15),
color: secondaryInk
)
}
endPage()
context.closePDF()
return data as Data
}
// MARK: - Page furniture
private static func drawHeader(range: DayRange, generatedAt: Date, continuation: Bool = false) {
let top = margin
drawText(
"LEKTORENPLAN · PFARREIENGEMEINSCHAFT BAD GODESBERG",
in: CGRect(x: margin, y: top, width: 420, height: 12),
font: sans(7.5, weight: .bold),
color: accent
)
drawText(
continuation ? "Gottesdienstplan · Fortsetzung" : "Gottesdienstplan",
in: CGRect(x: margin, y: top + 13, width: 500, height: 24),
font: serif(21, bold: true),
color: ink
)
drawText(
range.longTitle,
in: CGRect(x: margin, y: top + 40, width: 460, height: 14),
font: sans(10.5),
color: secondaryInk
)
let rightX = pageWidth - margin - 230
drawText(
"Erstellt am \(DayMath.mediumString(generatedAt))",
in: CGRect(x: rightX, y: top, width: 230, height: 12),
font: sans(8.5),
color: tertiaryInk,
alignment: .right
)
drawText(
"Liturgischer Kalender: Erzbistum Köln",
in: CGRect(x: rightX, y: top + 15, width: 230, height: 12),
font: sans(8),
color: tertiaryInk,
alignment: .right
)
drawText(
"Daten von www.eucharistiefeier.de",
in: CGRect(x: rightX, y: top + 28, width: 230, height: 12),
font: sans(7.5),
color: tertiaryInk,
alignment: .right
)
contextLine(y: top + headerHeight - 6)
}
private static func drawColumnHeader(churches: [Church], churchWidth: CGFloat) {
let y = margin + headerHeight
let height = columnHeaderHeight
let background = CGRect(x: margin, y: y, width: pageWidth - margin * 2, height: height)
contextFill(background, color: NSColor(calibratedWhite: 0.96, alpha: 1))
var x = margin + 6
drawText("TAG", in: CGRect(x: x, y: y + 8, width: dateWidth - 6, height: 10),
font: sans(6.5, weight: .bold), color: tertiaryInk)
x += dateWidth
drawText("LITURGIE & LESUNGEN", in: CGRect(x: x, y: y + 8, width: liturgyWidth, height: 10),
font: sans(6.5, weight: .bold), color: tertiaryInk)
x += liturgyWidth + columnGap
for church in churches.prefix(4) {
let color = NSColor(hexString: church.colorHex) ?? accent
drawText(
church.name,
in: CGRect(x: x + 5, y: y + 4, width: churchWidth - 10, height: 12),
font: serif(9.5, bold: true),
color: color
)
drawText(
church.address,
in: CGRect(x: x + 5, y: y + 15, width: churchWidth - 10, height: 8),
font: sans(6, weight: .regular),
color: tertiaryInk
)
x += churchWidth + columnGap
}
contextLine(y: y + height)
}
private static func drawFooter(pageIndex: Int, range: DayRange) {
let y = pageHeight - margin - footerHeight
contextLine(y: y + 6)
drawText(
"LektorenPlan · \(range.shortTitle)",
in: CGRect(x: margin, y: y + 10, width: 300, height: 12),
font: sans(7),
color: tertiaryInk
)
drawText(
"Seite \(pageIndex + 1)",
in: CGRect(x: pageWidth - margin - 90, y: y + 10, width: 90, height: 12),
font: sans(7),
color: tertiaryInk,
alignment: .right
)
}
// MARK: - Rows
private static func rowHeight(
row: DayPlanRow,
churchWidth: CGFloat,
people: [String: Person]
) -> CGFloat {
var tallest: CGFloat = 46
if let day = row.liturgicalDay {
var liturgyHeight: CGFloat = 14
liturgyHeight += measuredHeight(day.displayTitle, font: serif(10, bold: true), width: liturgyWidth - 8, maxLines: 3)
if !day.readings.isEmpty {
liturgyHeight += measuredHeight(day.readings.shortLabel, font: sans(7), width: liturgyWidth - 8, maxLines: 3) + 2
}
tallest = max(tallest, liturgyHeight + 8)
}
for church in row.services.map(\.church).uniqued(by: \.id) {
let services = row.services.filter { $0.church.id == church.id }
var height: CGFloat = 5
for service in services {
height += 12
for role in Role.allCases where service.service.requiredCount(for: role) > 0 {
height += 9
}
height += 3
}
tallest = max(tallest, height + 4)
}
return min(tallest, 150)
}
private static func drawRow(
row: DayPlanRow,
y: CGFloat,
height: CGFloat,
churches: [Church],
churchWidth: CGFloat,
people: [String: Person]
) {
let isSunday = row.liturgicalDay?.isSunday == true || DayMath.isSunday(row.date)
let isFeast = row.liturgicalDay?.isHighFeast == true
let isHoliday = row.liturgicalDay?.isObligation == true && !isSunday
let rowRect = CGRect(x: margin, y: y, width: pageWidth - margin * 2, height: height)
if isFeast {
contextFill(rowRect, color: feastWash)
} else if isSunday || isHoliday {
contextFill(rowRect, color: sundayWash)
}
var x = margin
// Date cell
let weekday = DayMath.shortWeekdayName(row.date).uppercased()
drawText(
weekday,
in: CGRect(x: x + 6, y: y + 6, width: dateWidth - 6, height: 9),
font: sans(6.5, weight: .bold),
color: isSunday ? burgundy : tertiaryInk
)
drawText(
"\(DayMath.dayNumber(row.date)).",
in: CGRect(x: x + 6, y: y + 14, width: dateWidth - 6, height: 18),
font: serif(15, bold: true),
color: isFeast ? gold : (isSunday ? burgundy : ink)
)
drawText(
DayMath.shortMonthName(row.date),
in: CGRect(x: x + 6, y: y + 31, width: dateWidth - 6, height: 9),
font: sans(6.5),
color: tertiaryInk
)
if isSunday {
drawText("SONNTAG", in: CGRect(x: x + 6, y: y + 41, width: dateWidth, height: 8),
font: sans(5.5, weight: .bold), color: burgundy.withAlphaComponent(0.85))
}
x += dateWidth
// Liturgy cell
var textY = y + 5
if let day = row.liturgicalDay {
let badge: String?
if day.isHighFeast {
badge = "HOCHFEST"
} else if day.rank == .feast {
badge = "FEST"
} else if day.rank == .obligatoryMemorial {
badge = "GEDENKTAG"
} else if day.isObligation && !day.isSunday {
badge = "GEBOTEN"
} else {
badge = nil
}
if let badge {
let color = day.isHighFeast ? gold : (day.rank == .feast ? burgundy : accent)
drawBadge(badge, x: x + 4, y: textY, color: color)
textY += 12
}
let titleHeight = drawText(
day.displayTitle,
in: CGRect(x: x + 4, y: textY, width: liturgyWidth - 8, height: height - 20),
font: serif(9.5, bold: day.isFeast),
color: isFeast ? ink : (isSunday ? burgundy : ink),
maxLines: 3
)
textY += titleHeight + 2
if !day.readings.isEmpty {
drawText(
day.readings.shortLabel,
in: CGRect(x: x + 4, y: textY, width: liturgyWidth - 8, height: height - (textY - y) - 4),
font: sans(6.5),
color: secondaryInk,
maxLines: 3
)
}
}
x += liturgyWidth + columnGap
// Church columns
for church in churches.prefix(4) {
let services = row.services.filter { $0.church.id == church.id }
var serviceY = y + 4
for service in services {
let color = NSColor(hexString: church.colorHex) ?? accent
drawText(
"\(service.service.timeLabel) \(service.service.title)",
in: CGRect(x: x + 5, y: serviceY, width: churchWidth - 10, height: 11),
font: sans(7, weight: .semibold),
color: color,
maxLines: 1
)
serviceY += 11
for role in Role.allCases where service.service.requiredCount(for: role) > 0 {
let names = service.assignments(for: role).compactMap { people[$0.personID]?.fullName }
let prefix = role == .lector ? "L" : "K"
let value = names.isEmpty ? "offen" : names.joined(separator: ", ")
drawText(
"\(prefix): \(value)",
in: CGRect(x: x + 7, y: serviceY, width: churchWidth - 12, height: 9),
font: sans(6.5, weight: names.isEmpty ? .semibold : .regular),
color: names.isEmpty ? openColor : secondaryInk,
maxLines: 2
)
serviceY += 9
}
serviceY += 3
if serviceY > y + height - 6 { break }
}
// Church column separator
context.setStrokeColor(lineColor.withAlphaComponent(0.4).cgColor)
context.setLineWidth(0.4)
context.move(to: CGPoint(x: x, y: y + 3))
context.addLine(to: CGPoint(x: x, y: y + height - 3))
context.strokePath()
x += churchWidth + columnGap
}
}
// MARK: - Drawing helpers
private static func drawBadge(_ text: String, x: CGFloat, y: CGFloat, color: NSColor) {
let font = sans(6, weight: .bold)
let attributes: [NSAttributedString.Key: Any] = [
.font: font,
.foregroundColor: NSColor.white
]
let size = (text as NSString).size(withAttributes: attributes)
let rect = CGRect(x: x, y: y, width: size.width + 8, height: 9)
let path = NSBezierPath(roundedRect: rect, xRadius: 3, yRadius: 3)
color.setFill()
path.fill()
(text as NSString).draw(
at: CGPoint(x: rect.minX + 4, y: rect.minY + 1.2),
withAttributes: attributes
)
}
@discardableResult
private static func drawText(
_ text: String,
in rect: CGRect,
font: NSFont,
color: NSColor,
alignment: NSTextAlignment = .left,
maxLines: Int = 1
) -> CGFloat {
guard !text.isEmpty else { return 0 }
let paragraph = NSMutableParagraphStyle()
paragraph.alignment = alignment
paragraph.lineBreakMode = maxLines > 1 ? .byWordWrapping : .byTruncatingTail
paragraph.lineSpacing = 0.5
let attributes: [NSAttributedString.Key: Any] = [
.font: font,
.foregroundColor: color,
.paragraphStyle: paragraph
]
let attributed = NSAttributedString(string: text, attributes: attributes)
let measured = attributed.boundingRect(
with: CGSize(width: rect.width, height: .greatestFiniteMagnitude),
options: [.usesLineFragmentOrigin, .usesFontLeading]
)
let lineHeight = font.pointSize * 1.22
let maxHeight = lineHeight * CGFloat(maxLines)
let drawHeight = min(measured.height, maxHeight)
attributed.draw(
with: CGRect(x: rect.minX, y: rect.minY, width: rect.width, height: max(drawHeight, lineHeight)),
options: [.usesLineFragmentOrigin, .usesFontLeading]
)
return min(measured.height, maxHeight)
}
private static func measuredHeight(
_ text: String,
font: NSFont,
width: CGFloat,
maxLines: Int
) -> CGFloat {
let attributes: [NSAttributedString.Key: Any] = [.font: font]
let measured = (text as NSString).boundingRect(
with: CGSize(width: width, height: .greatestFiniteMagnitude),
options: [.usesLineFragmentOrigin, .usesFontLeading],
attributes: attributes
)
return min(measured.height, font.pointSize * 1.22 * CGFloat(maxLines))
}
private static func contextLine(y: CGFloat) {
context.setStrokeColor(lineColor.withAlphaComponent(0.75).cgColor)
context.setLineWidth(0.7)
context.move(to: CGPoint(x: margin, y: y))
context.addLine(to: CGPoint(x: pageWidth - margin, y: y))
context.strokePath()
}
private static func contextFill(_ rect: CGRect, color: NSColor) {
context.setFillColor(color.cgColor)
context.fill(rect)
}
/// The drawing context is stored in a task-local-ish static for the duration of a render.
/// PDF rendering is synchronous on the main thread, so this is safe in practice.
nonisolated(unsafe) private static var storedContext: CGContext?
private static var context: CGContext {
storedContext ?? CGContext(data: nil, width: 1, height: 1, bitsPerComponent: 8,
bytesPerRow: 0, space: CGColorSpaceCreateDeviceRGB(),
bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!
}
}
private extension DayRange {
var longTitle: String {
"\(DayMath.longString(start)) bis \(DayMath.longString(end)) · \(dayCount) Tage"
}
}
private extension Array {
func uniqued<Key: Hashable>(by key: (Element) -> Key) -> [Element] {
var seen: Set<Key> = []
return filter { element in
let value = key(element)
if seen.contains(value) { return false }
seen.insert(value)
return true
}
}
}
private extension NSColor {
convenience init?(hexString: String) {
let cleaned = hexString.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
guard cleaned.count == 6, let value = UInt64(cleaned, radix: 16) else { return nil }
self.init(
calibratedRed: CGFloat((value >> 16) & 0xFF) / 255,
green: CGFloat((value >> 8) & 0xFF) / 255,
blue: CGFloat(value & 0xFF) / 255,
alpha: 1
)
}
}
+880
View File
@@ -0,0 +1,880 @@
import SwiftUI
import AppKit
import UniformTypeIdentifiers
import PDFKit
import LektorenPlanCore
enum AppSection: String, CaseIterable, Identifiable, Hashable {
case planning
case serviceOrder
case team
case statistics
case exchange
case settings
var id: String { rawValue }
var title: String {
switch self {
case .planning: "Kalender & Planung"
case .serviceOrder: "Gottesdienstordnung"
case .team: "Lektoren & Helfer"
case .statistics: "Statistik"
case .exchange: "Austausch"
case .settings: "Einstellungen"
}
}
var shortTitle: String {
switch self {
case .planning: "Planung"
case .serviceOrder: "Ordnung"
case .team: "Team"
case .statistics: "Statistik"
case .exchange: "Austausch"
case .settings: "Einstellungen"
}
}
var icon: String {
switch self {
case .planning: "calendar"
case .serviceOrder: "building.columns"
case .team: "person.2"
case .statistics: "chart.xyaxis.line"
case .exchange: "arrow.left.arrow.right"
case .settings: "gearshape"
}
}
var keyboardNumber: Int {
switch self {
case .planning: 1
case .serviceOrder: 2
case .team: 3
case .statistics: 4
case .exchange: 5
case .settings: 6
}
}
}
enum PlanFilter: String, CaseIterable, Identifiable {
case all
case services
case open
var id: String { rawValue }
var title: String {
switch self {
case .all: "Alle Tage"
case .services: "Mit Gottesdiensten"
case .open: "Nur offene"
}
}
}
struct PersonEditorRequest: Identifiable {
let id = UUID()
var person: Person?
var presetRole: Role? = nil
}
struct TemplateEditorRequest: Identifiable {
let id = UUID()
var template: ServiceTemplate?
var churchID: String?
}
struct SpecialServiceRequest: Identifiable {
let id = UUID()
var churchID: String?
var date: Date = DayMath.today()
var service: ServiceOccurrence? = nil
}
struct ServiceDetailRequest: Identifiable {
let id = UUID()
var serviceID: String
}
struct ImportPreview: Identifiable {
let id = UUID()
var exchange: PlanExchange
var data: Data
var sourceName: String
}
struct PDFPreview: Identifiable {
let id = UUID()
var data: Data
var title: String
var filename: String
}
struct CandidateSuggestion: Identifiable {
var person: Person
var score: Double
var warnings: [String]
var blocked: Bool
var preferred: Bool
var totalAssignments: Int
var id: String { person.id }
}
@MainActor
final class PlanModel: ObservableObject {
let db: AppDatabase
@Published var section: AppSection = .planning
@Published var range: DayRange = .quarter(containing: DayMath.today())
@Published var churches: [Church] = []
@Published var people: [Person] = []
@Published var absences: [Absence] = []
@Published var templates: [ServiceTemplate] = []
@Published var exceptions: [ServiceException] = []
@Published var services: [ServiceOccurrence] = []
@Published var assignments: [Assignment] = []
@Published var specialServices: [ServiceOccurrence] = []
@Published var liturgicalDays: [String: LiturgicalDay] = [:]
@Published var peopleByID: [String: Person] = [:]
@Published var churchByID: [String: Church] = [:]
@Published var rows: [DayPlanRow] = []
@Published var stats: RangeStatistics = .empty
@Published var lastSync: Date?
@Published var isSyncing = false
@Published var isPlanning = false
@Published var syncMessage: String = ""
@Published var alertMessage: String?
@Published var alertTitle: String = "Hinweis"
@Published var toast: Toast?
@Published var filter: PlanFilter = .all
@Published var searchText: String = ""
@Published var showOnlySundaysAndFeasts: Bool = false
@Published var personEditor: PersonEditorRequest?
@Published var templateEditor: TemplateEditorRequest?
@Published var specialServiceEditor: SpecialServiceRequest?
@Published var serviceDetail: ServiceDetailRequest?
@Published var planResult: PlanResult?
@Published var importPreview: ImportPreview?
@Published var pdfPreview: PDFPreview?
@Published var databasePath: String
@Published var startupWarning: String?
private var toastTask: Task<Void, Never>?
init(database: AppDatabase? = nil) {
let resolved: AppDatabase
var warning: String?
if let database {
resolved = database
} else {
do {
resolved = try AppDatabase(path: AppDatabase.defaultPath())
} catch {
let fallback = try! AppDatabase.makeInMemory(seedDemo: true)
resolved = fallback
warning = "Die Datenbank konnte nicht geöffnet werden. Es wird eine temporäre In-Memory-Datenbank verwendet.\n\(error.localizedDescription)"
}
}
self.db = resolved
self.databasePath = resolved.path
self.startupWarning = warning
if let startKey = resolved.setting("rangeStart"),
let endKey = resolved.setting("rangeEnd"),
let start = DayMath.date(fromKey: startKey),
let end = DayMath.date(fromKey: endKey),
end >= start {
self.range = DayRange(start: start, end: end)
} else {
self.range = .quarter(containing: DayMath.today())
}
if let value = resolved.setting("showOnlySundaysAndFeasts") {
self.showOnlySundaysAndFeasts = value == "1"
}
loadAll()
if let warning { alertMessage = warning; alertTitle = "Eingeschränkter Betrieb" }
}
// MARK: - Loading
func loadAll() {
do {
ensureLiturgicalCoverage()
churches = try db.churches().sorted { $0.sortIndex < $1.sortIndex }
people = try db.people()
peopleByID = Dictionary(uniqueKeysWithValues: people.map { ($0.id, $0) })
churchByID = Dictionary(uniqueKeysWithValues: churches.map { ($0.id, $0) })
absences = try db.absences()
templates = try db.templates()
exceptions = try db.exceptions()
services = try db.services(in: range)
assignments = try db.assignments(in: range)
specialServices = try db.specialServices()
liturgicalDays = Dictionary(uniqueKeysWithValues: try db.liturgicalDays(in: range).map { ($0.dateKey, $0) })
if let raw = db.setting("lastLiturgicalSync") {
lastSync = ISO8601DateFormatter().date(from: raw)
}
rebuildRows()
stats = StatisticsCalculator.compute(
range: range,
services: services,
assignments: assignments,
people: people,
churches: churches,
absences: absences
)
} catch {
alertTitle = "Daten konnten nicht geladen werden"
alertMessage = error.localizedDescription
}
}
private func ensureLiturgicalCoverage() {
do {
let existing = try db.liturgicalDays(in: range)
let keys = Set(existing.map(\.dateKey))
var missing: [LiturgicalDay] = []
for date in range.days where !keys.contains(DayMath.key(date)) {
missing.append(LiturgicalCalendarEngine.localDay(for: date))
}
if !missing.isEmpty {
try db.upsert(liturgicalDays: missing)
}
} catch {
// Reading the local fallback must never block the rest of the UI.
print("Liturgical coverage failed: \(error)")
}
}
private func rebuildRows() {
let servicesByDay = Dictionary(grouping: services, by: \.dateKey)
let assignmentsByService = Dictionary(grouping: assignments, by: \.serviceID)
rows = range.days.map { date in
let key = DayMath.key(date)
let dayServices = (servicesByDay[key] ?? [])
.sorted { $0.timeMinutes < $1.timeMinutes }
.compactMap { service -> ServiceWithAssignments? in
guard let church = churchByID[service.churchID] else { return nil }
let serviceAssignments = (assignmentsByService[service.id] ?? [])
.sorted { $0.role == .lector && $1.role == .helper }
return ServiceWithAssignments(service: service, church: church, assignments: serviceAssignments)
}
return DayPlanRow(date: date, liturgicalDay: liturgicalDays[key], services: dayServices)
}
}
// MARK: - Range
func setRange(_ newRange: DayRange) {
guard newRange != range else { return }
range = newRange
db.setSetting("rangeStart", value: DayMath.key(newRange.start))
db.setSetting("rangeEnd", value: DayMath.key(newRange.end))
loadAll()
}
func setSundayFilter(_ enabled: Bool) {
showOnlySundaysAndFeasts = enabled
db.setSetting("showOnlySundaysAndFeasts", value: enabled ? "1" : "0")
}
var filteredRows: [DayPlanRow] {
let query = searchText.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
return rows.filter { row in
if showOnlySundaysAndFeasts {
let isSpecialDay = row.liturgicalDay?.isSunday == true || row.liturgicalDay?.isObligation == true || row.liturgicalDay?.isFeast == true
if !isSpecialDay { return false }
}
switch filter {
case .all:
break
case .services:
if !row.hasServices { return false }
case .open:
if row.openSlots == 0 { return false }
}
guard !query.isEmpty else { return true }
if row.liturgicalDay?.title.lowercased().contains(query) == true { return true }
if row.liturgicalDay?.readings.shortLabel.lowercased().contains(query) == true { return true }
for service in row.services {
if service.church.name.lowercased().contains(query) { return true }
if service.service.title.lowercased().contains(query) { return true }
for assignment in service.assignments {
if let person = peopleByID[assignment.personID],
person.fullName.lowercased().contains(query) {
return true
}
}
}
return false
}
}
var openSlotCount: Int { stats.openSlots }
var rangeServiceCount: Int { stats.serviceCount }
var fullyStaffedServiceCount: Int {
rows.reduce(0) { total, row in
total + row.services.filter(\.isFullyStaffed).count
}
}
var lectorCount: Int { people.filter { $0.active && $0.roles.contains(.lector) }.count }
var helperCount: Int { people.filter { $0.active && $0.roles.contains(.helper) }.count }
// MARK: - Planning
func autoPlan(replaceExisting: Bool) -> PlanResult? {
guard !isPlanning else { return nil }
isPlanning = true
defer { isPlanning = false }
do {
let rangeServices = try db.services(in: range)
let existing = try db.assignments(in: range)
let options = PlannerOptions(
replaceExisting: replaceExisting,
respectPreferredWeekdays: db.setting("respectPreferredWeekdays") != "0",
weightFairness: Double(db.setting("fairnessWeight") ?? "") ?? 2.2,
maxAssignmentsPerDay: 1
)
let planner = ServicePlanner(
people: people,
absences: absences,
services: rangeServices,
existingAssignments: existing,
churches: churches,
options: options
)
let result = planner.plan()
if result.filledCount > 0 || replaceExisting {
try db.savePlan(result.assignments, in: range, replaceUnlocked: replaceExisting)
}
loadAll()
planResult = result
return result
} catch {
alertTitle = "Planung fehlgeschlagen"
alertMessage = error.localizedDescription
return nil
}
}
func autoFill(serviceID: String) {
do {
guard let service = try db.service(id: serviceID) else { return }
let dayRange = DayRange(start: service.date, end: service.date)
let existing = try db.assignments(in: dayRange)
let servicesOfDay = try db.services(in: dayRange)
let planner = ServicePlanner(
people: people,
absences: absences,
services: [service],
existingAssignments: existing.filter { $0.serviceID == serviceID },
churches: churches,
options: PlannerOptions(replaceExisting: false, respectPreferredWeekdays: false)
)
let result = planner.plan()
_ = servicesOfDay
try db.savePlan(result.assignments, in: dayRange, replaceUnlocked: false)
loadAll()
if result.unfilled.isEmpty {
showToast("Gottesdienst vollständig besetzt.", kind: .success)
} else {
showToast("\(result.unfilled.count) Lücke(n) konnten nicht besetzt werden.", kind: .warning)
}
} catch {
alertTitle = "Planung fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
func assign(serviceID: String, role: Role, personID: String?) {
do {
try db.setAssignment(serviceID: serviceID, role: role, personID: personID)
loadAll()
if let personID, let person = peopleByID[personID] {
showToast("\(person.fullName) als \(role.title) eingetragen.", kind: .success)
} else {
showToast("Dienst freigegeben.", kind: .info)
}
} catch {
alertTitle = "Zuweisung fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
func toggleAssignmentLock(_ assignment: Assignment) {
do {
try db.toggleAssignmentLock(id: assignment.id)
loadAll()
} catch {
alertTitle = "Sperre konnte nicht geändert werden"
alertMessage = error.localizedDescription
}
}
func candidateSuggestions(for service: ServiceOccurrence, role: Role) -> [CandidateSuggestion] {
let rangeAssignments = assignments
let monthKey = DayMath.monthKey(service.date)
let serviceDateByID = Dictionary(uniqueKeysWithValues: services.map { ($0.id, $0) })
var monthlyCounts: [String: Int] = [:]
var totalCounts: [String: Int] = [:]
var dayCounts: [String: Int] = [:]
for assignment in rangeAssignments {
guard let assignedService = serviceDateByID[assignment.serviceID] else { continue }
monthlyCounts["\(assignment.personID)|\(DayMath.monthKey(assignedService.date))", default: 0] += 1
totalCounts[assignment.personID, default: 0] += 1
dayCounts["\(assignment.personID)|\(assignedService.dateKey)", default: 0] += 1
}
let assignedToService = Set(assignments.filter { $0.serviceID == service.id }.map(\.personID))
let weekday = DayMath.weekday(service.date)
return people
.filter { $0.active && $0.canFill(role) && !assignedToService.contains($0.id) }
.map { person in
var warnings: [String] = []
var blocked = false
if absences.contains(where: { $0.personID == person.id && $0.overlaps(service.date) }) {
warnings.append("abwesend")
blocked = true
}
if !person.preferredWeekdays.isEmpty && !person.preferredWeekdays.contains(weekday) {
warnings.append("Einsatztag passt nicht")
blocked = true
}
if person.maxPerMonth > 0, monthlyCounts["\(person.id)|\(monthKey)", default: 0] >= person.maxPerMonth {
warnings.append("Monatslimit")
blocked = true
}
if dayCounts["\(person.id)|\(service.dateKey)", default: 0] > 0 {
warnings.append("bereits an diesem Tag")
blocked = true
}
var score = 0.0
var preferred = false
if person.preferredChurchIDs.contains(service.churchID) {
score += 8
preferred = true
}
if !person.preferredChurchIDs.isEmpty && !person.preferredChurchIDs.contains(service.churchID) {
score -= 2
}
if person.preferredWeekdays.contains(weekday) {
score += 3
preferred = true
}
for preference in person.preferredServiceTitles where !preference.isEmpty {
if service.title.lowercased().contains(preference.lowercased()) {
score += 4
preferred = true
}
}
score -= Double(totalCounts[person.id, default: 0]) * 1.4
if absences.contains(where: { $0.personID == person.id && $0.overlaps(service.date) }) {
score -= 100
}
return CandidateSuggestion(
person: person,
score: score,
warnings: warnings,
blocked: blocked,
preferred: preferred,
totalAssignments: totalCounts[person.id, default: 0]
)
}
.sorted {
if $0.blocked != $1.blocked { return !$0.blocked }
if $0.score != $1.score { return $0.score > $1.score }
return $0.person.lastName < $1.person.lastName
}
}
func serviceWithAssignments(id: String) -> ServiceWithAssignments? {
for row in rows {
if let match = row.services.first(where: { $0.service.id == id }) { return match }
}
// The service may be outside the current range while its detail sheet is open.
guard let service = try? db.service(id: id), let church = churchByID[service.churchID] else { return nil }
let serviceAssignments = (try? db.assignments(serviceIDs: [id])) ?? []
return ServiceWithAssignments(service: service, church: church, assignments: serviceAssignments)
}
func nextOpenServices(limit: Int = 8) -> [ServiceWithAssignments] {
rows
.flatMap(\.services)
.filter { !$0.isFullyStaffed }
.sorted { $0.service.date < $1.service.date }
.prefix(limit)
.map { $0 }
}
// MARK: - Liturgical calendar
func syncLiturgy(years: [Int]? = nil) async {
guard !isSyncing else { return }
isSyncing = true
defer { isSyncing = false }
let targetYears = years ?? Array(Set(range.days.map { DayMath.year($0) })).sorted()
var updated = 0
var errors: [String] = []
let api = LiturgicalCalendarAPI()
for year in targetYears {
syncMessage = "Lade liturgischen Kalender \(year)…"
do {
let days = try await api.fetch(year: year)
try db.replaceLiturgicalYear(year, with: days)
updated += days.count
} catch {
errors.append("\(year): \(error.localizedDescription)")
}
}
if updated > 0 {
let now = Date()
lastSync = now
db.setSetting("lastLiturgicalSync", value: ISO8601DateFormatter().string(from: now))
ensureLiturgicalCoverage()
loadAll()
showToast("Liturgischer Kalender aktualisiert · \(updated) Tage.", kind: .success)
}
syncMessage = ""
if !errors.isEmpty {
alertTitle = errors.count == targetYears.count ? "Kalender nicht erreichbar" : "Kalender teilweise aktualisiert"
alertMessage = errors.joined(separator: "\n") + "\n\nDie vorhandenen Offline-Daten bleiben erhalten. Quelle: www.eucharistiefeier.de"
}
}
func syncIfNeeded() {
// Screenshot runs should stay deterministic and offline.
guard ProcessInfo.processInfo.environment["LP_SNAPSHOT"] == nil else { return }
guard db.setting("autoSyncLiturgy") == "1" else { return }
if let lastSync, Date().timeIntervalSince(lastSync) < 24 * 3600 { return }
Task { await syncLiturgy(years: [DayMath.year(range.start)]) }
}
static var sourceLabel: String { "Daten von www.eucharistiefeier.de" }
// MARK: - People
func savePerson(_ person: Person) {
do {
try db.upsert(person)
loadAll()
showToast("\(person.fullName) gespeichert.", kind: .success)
} catch {
alertTitle = "Person konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
func deletePerson(_ person: Person) {
do {
try db.deletePerson(id: person.id)
loadAll()
showToast("\(person.fullName) gelöscht.", kind: .info)
} catch {
alertTitle = "Person konnte nicht gelöscht werden"
alertMessage = error.localizedDescription
}
}
func absences(for personID: String) -> [Absence] {
absences.filter { $0.personID == personID }.sorted { $0.start < $1.start }
}
func saveAbsence(_ absence: Absence) {
do {
try db.upsert(absence)
loadAll()
} catch {
alertTitle = "Abwesenheit konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
func deleteAbsence(_ absence: Absence) {
do {
try db.deleteAbsence(id: absence.id)
loadAll()
} catch {
alertTitle = "Abwesenheit konnte nicht gelöscht werden"
alertMessage = error.localizedDescription
}
}
func currentAbsence(for person: Person) -> Absence? {
let today = DayMath.today()
return absences.first { $0.personID == person.id && $0.range.contains(today) }
}
func assignmentCount(for personID: String) -> Int {
stats.personStats.first { $0.person.id == personID }?.total ?? 0
}
// MARK: - Service order
func templates(for churchID: String) -> [ServiceTemplate] {
templates.filter { $0.churchID == churchID }.sorted {
if $0.weekday != $1.weekday { return $0.weekday < $1.weekday }
return $0.timeMinutes < $1.timeMinutes
}
}
func saveTemplate(_ template: ServiceTemplate) {
do {
try db.upsert(template)
let created = try db.generateServices(in: range)
loadAll()
showToast("Gottesdienstordnung gespeichert. \(created) neue Termine erzeugt.", kind: .success)
} catch {
alertTitle = "Gottesdienstordnung konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
func deleteTemplate(_ template: ServiceTemplate) {
do {
try db.deleteTemplate(id: template.id)
loadAll()
showToast("Vorlage gelöscht. Bereits erzeugte Termine bleiben erhalten.", kind: .info)
} catch {
alertTitle = "Vorlage konnte nicht gelöscht werden"
alertMessage = error.localizedDescription
}
}
func generateServices() {
do {
let created = try db.generateServices(in: range)
loadAll()
showToast(created > 0 ? "\(created) Gottesdienste erzeugt." : "Keine neuen Gottesdienste im Zeitraum.", kind: created > 0 ? .success : .info)
} catch {
alertTitle = "Gottesdienste konnten nicht erzeugt werden"
alertMessage = error.localizedDescription
}
}
func saveSpecialService(_ service: ServiceOccurrence) {
do {
try db.upsert(service)
loadAll()
showToast("Sondergottesdienst gespeichert.", kind: .success)
} catch {
alertTitle = "Sondergottesdienst konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
func deleteService(_ service: ServiceOccurrence) {
do {
try db.deleteService(id: service.id)
loadAll()
serviceDetail = nil
showToast("Gottesdienst gelöscht.", kind: .info)
} catch {
alertTitle = "Gottesdienst konnte nicht gelöscht werden"
alertMessage = error.localizedDescription
}
}
var serviceTitles: [String] {
Array(Set(templates.map(\.title))).sorted()
}
func upcomingSpecials() -> [ServiceOccurrence] {
let cutoff = DayMath.adding(days: -31, to: DayMath.today())
return specialServices
.filter { $0.date >= cutoff }
.sorted { $0.date < $1.date }
}
// MARK: - Exchange
func exportData(scope: ExchangeScope) throws -> (data: Data, filename: String) {
let exchange = try db.exportPlan(range: range, scope: scope)
let encoder = JSONEncoder()
encoder.outputFormatting = [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes]
encoder.dateEncodingStrategy = .iso8601
let data = try encoder.encode(exchange)
let suffix: String
if scope == .resources {
suffix = "Ressourcen_\(DayMath.key(DayMath.today()))"
} else {
suffix = "Plan_\(DayMath.key(range.start))_\(DayMath.key(range.end))"
}
return (data, "LektorenPlan_\(suffix).json")
}
func exportInteractive(scope: ExchangeScope) {
do {
let result = try exportData(scope: scope)
let panel = NSSavePanel()
panel.title = scope == .resources ? "Ressourcen exportieren" : "Planungsabschnitt exportieren"
panel.nameFieldStringValue = result.filename
panel.allowedContentTypes = [.json]
panel.canCreateDirectories = true
if panel.runModal() == .OK, let url = panel.url {
try result.data.write(to: url, options: .atomic)
showToast("Export gespeichert: \(url.lastPathComponent)", kind: .success)
}
} catch {
alertTitle = "Export fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
func importInteractive() {
let panel = NSOpenPanel()
panel.title = "LektorenPlan-Datei importieren"
panel.allowsMultipleSelection = false
panel.canChooseDirectories = false
panel.allowedContentTypes = [.json]
if panel.runModal() == .OK, let url = panel.url {
prepareImport(url: url)
}
}
func prepareImport(url: URL) {
do {
let accessing = url.startAccessingSecurityScopedResource()
defer { if accessing { url.stopAccessingSecurityScopedResource() } }
let data = try Data(contentsOf: url)
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
if let exchange = try? decoder.decode(PlanExchange.self, from: data) {
importPreview = ImportPreview(exchange: exchange, data: data, sourceName: url.lastPathComponent)
return
}
if let resources = try? decoder.decode(ResourceBundle.self, from: data) {
let exchange = PlanExchange(scope: .resources, range: range, resources: resources)
importPreview = ImportPreview(exchange: exchange, data: data, sourceName: url.lastPathComponent)
return
}
alertTitle = "Datei nicht erkannt"
alertMessage = "Die Datei enthält kein gültiges LektorenPlan-Austauschformat."
} catch {
alertTitle = "Import fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
func applyImport(_ preview: ImportPreview) {
do {
let summary = try db.applyPlanExchange(preview.exchange)
importPreview = nil
loadAll()
showToast("Import abgeschlossen: \(summary.services) Gottesdienste, \(summary.assignments) Einsätze, \(summary.people) Personen.", kind: .success)
} catch {
alertTitle = "Import fehlgeschlagen"
alertMessage = error.localizedDescription
}
}
// MARK: - PDF & print
func createPDFPreview() {
let data = PlanPDFRenderer.render(
range: range,
rows: rows,
churches: churches,
people: peopleByID,
generatedAt: Date()
)
pdfPreview = PDFPreview(
data: data,
title: "Lektorenplan \(range.shortTitle)",
filename: "LektorenPlan_\(DayMath.key(range.start))_\(DayMath.key(range.end)).pdf"
)
}
func savePDF(data: Data, suggestedName: String) {
let panel = NSSavePanel()
panel.title = "PDF sichern"
panel.nameFieldStringValue = suggestedName
panel.allowedContentTypes = [.pdf]
if panel.runModal() == .OK, let url = panel.url {
do {
try data.write(to: url, options: .atomic)
showToast("PDF gespeichert: \(url.lastPathComponent)", kind: .success)
} catch {
alertTitle = "PDF konnte nicht gespeichert werden"
alertMessage = error.localizedDescription
}
}
}
func printPDF(data: Data? = nil) {
let pdfData = data ?? PlanPDFRenderer.render(
range: range,
rows: rows,
churches: churches,
people: peopleByID,
generatedAt: Date()
)
guard let document = PDFDocument(data: pdfData) else {
alertTitle = "Drucken nicht möglich"
alertMessage = "Das PDF konnte nicht erzeugt werden."
return
}
let info = NSPrintInfo.shared.copy() as? NSPrintInfo ?? NSPrintInfo.shared
info.orientation = .landscape
info.topMargin = 0
info.bottomMargin = 0
info.leftMargin = 0
info.rightMargin = 0
if let operation = document.printOperation(for: info, scalingMode: .pageScaleToFit, autoRotate: true) {
operation.showsPrintPanel = true
operation.showsProgressPanel = true
operation.run()
}
}
// MARK: - Demo
func resetDemoData() {
do {
try db.resetDemoData()
loadAll()
showToast("Demo-Daten neu aufgebaut.", kind: .success)
} catch {
alertTitle = "Demo-Daten konnten nicht zurückgesetzt werden"
alertMessage = error.localizedDescription
}
}
func openDatabaseFolder() {
guard db.path != ":memory:" else { return }
NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: db.path)])
}
var databaseSizeLabel: String {
let bytes = db.databaseSizeBytes()
return ByteCountFormatter.string(fromByteCount: Int64(bytes), countStyle: .file)
}
// MARK: - Toast
func showToast(_ message: String, kind: ToastKind = .info) {
toastTask?.cancel()
let newToast = Toast(message: message, kind: kind)
withAnimation(.spring(response: 0.32, dampingFraction: 0.86)) {
toast = newToast
}
toastTask = Task { @MainActor [weak self] in
try? await Task.sleep(nanoseconds: 3_400_000_000)
guard !Task.isCancelled else { return }
guard self?.toast?.id == newToast.id else { return }
withAnimation(.easeOut(duration: 0.2)) {
self?.toast = nil
}
}
}
}
+236
View File
@@ -0,0 +1,236 @@
import SwiftUI
import LektorenPlanCore
struct RootView: View {
@EnvironmentObject private var model: PlanModel
var body: some View {
ZStack(alignment: .bottom) {
AppBackground()
NavigationSplitView {
SidebarView()
.navigationSplitViewColumnWidth(min: 214, ideal: 228, max: 252)
} detail: {
detail
}
.navigationSplitViewStyle(.balanced)
if let toast = model.toast {
ToastView(toast: toast)
.transition(.move(edge: .bottom).combined(with: .opacity))
.zIndex(50)
}
}
.frame(minWidth: 1120, minHeight: 740)
.task {
model.syncIfNeeded()
}
.alert(
model.alertTitle,
isPresented: Binding(
get: { model.alertMessage != nil },
set: { if !$0 { model.alertMessage = nil } }
)
) {
Button("OK", role: .cancel) { model.alertMessage = nil }
} message: {
Text(model.alertMessage ?? "")
}
.sheet(item: $model.personEditor) { request in
PersonEditorSheet(request: request)
.environmentObject(model)
}
.sheet(item: $model.templateEditor) { request in
TemplateEditorSheet(request: request)
.environmentObject(model)
}
.sheet(item: $model.specialServiceEditor) { request in
SpecialServiceSheet(request: request)
.environmentObject(model)
}
.sheet(item: $model.serviceDetail) { request in
ServiceDetailSheet(serviceID: request.serviceID)
.environmentObject(model)
}
.sheet(item: $model.importPreview) { preview in
ImportPreviewSheet(preview: preview)
.environmentObject(model)
}
.sheet(item: $model.pdfPreview) { preview in
PDFPreviewSheet(preview: preview)
.environmentObject(model)
}
.sheet(isPresented: Binding(
get: { model.planResult != nil },
set: { if !$0 { model.planResult = nil } }
)) {
PlanResultSheet()
.environmentObject(model)
}
}
@ViewBuilder
private var detail: some View {
switch model.section {
case .planning:
PlanningView()
.transition(.opacity)
case .serviceOrder:
ServiceOrderView()
.transition(.opacity)
case .team:
TeamView()
.transition(.opacity)
case .statistics:
StatisticsView()
.transition(.opacity)
case .exchange:
ExchangeView()
.transition(.opacity)
case .settings:
SettingsView()
.transition(.opacity)
}
}
}
private struct SidebarView: View {
@EnvironmentObject private var model: PlanModel
private var selection: Binding<AppSection?> {
Binding(
get: { model.section },
set: { value in
if let value { model.section = value }
}
)
}
var body: some View {
VStack(spacing: 0) {
branding
List(selection: selection) {
Section {
sidebarRow(.planning, badge: model.stats.openSlots > 0 ? "\(model.stats.openSlots)" : nil)
sidebarRow(.serviceOrder)
sidebarRow(.team, badge: "\(model.people.filter(\.active).count)")
sidebarRow(.statistics)
} header: {
sidebarHeader("Planung")
}
Section {
sidebarRow(.exchange)
sidebarRow(.settings)
} header: {
sidebarHeader("Organisation")
}
}
.listStyle(.sidebar)
.scrollContentBackground(.hidden)
.background(Color.clear)
footer
}
.background(
LinearGradient(colors: [LP.paper.opacity(0.72), LP.paperDeep.opacity(0.85)],
startPoint: .top, endPoint: .bottom)
)
}
private var branding: some View {
VStack(alignment: .leading, spacing: 10) {
HStack(spacing: 9) {
ZStack {
Circle()
.fill(LP.accent.opacity(0.09))
ChurchGlyph(symbol: .basilica, tint: LP.accent, lineWidth: 1.3, showGround: false)
.padding(5)
}
.frame(width: 38, height: 38)
.overlay(Circle().strokeBorder(LP.accent.opacity(0.18), lineWidth: 0.8))
VStack(alignment: .leading, spacing: 0) {
Text("LektorenPlan")
.font(.system(size: 18, weight: .semibold, design: .serif))
.foregroundStyle(LP.ink)
Text("Bad Godesberg")
.font(.system(size: 9, weight: .semibold, design: .rounded))
.tracking(0.8)
.foregroundStyle(LP.inkTertiary)
}
}
Text("GOTTESDIENSTE · DIENSTE · KALENDER")
.font(.system(size: 7.5, weight: .bold, design: .rounded))
.tracking(1.0)
.foregroundStyle(LP.inkTertiary.opacity(0.85))
}
.padding(.horizontal, 16)
.padding(.top, 38)
.padding(.bottom, 14)
}
private func sidebarHeader(_ title: String) -> some View {
Text(title.uppercased())
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.tracking(1.1)
.foregroundStyle(LP.inkTertiary)
}
private func sidebarRow(_ section: AppSection, badge: String? = nil) -> some View {
HStack(spacing: 9) {
Image(systemName: section.icon)
.font(.system(size: 12, weight: .medium))
.foregroundStyle(model.section == section ? LP.accent : LP.inkSecondary)
.frame(width: 18)
Text(section.title)
.font(.system(size: 12, weight: model.section == section ? .semibold : .regular))
.foregroundStyle(model.section == section ? LP.ink : LP.inkSecondary)
Spacer(minLength: 4)
if let badge {
Text(badge)
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.foregroundStyle(model.section == section ? LP.accent : LP.inkTertiary)
.padding(.horizontal, 5)
.padding(.vertical, 1.5)
.background(Capsule().fill(model.section == section ? LP.accent.opacity(0.12) : LP.cardMuted))
}
}
.tag(section)
.padding(.vertical, 2)
}
private var footer: some View {
VStack(alignment: .leading, spacing: 9) {
Hairline()
HStack(spacing: 6) {
Image(systemName: "calendar")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
Text(model.range.shortTitle)
.font(.system(size: 9.5, weight: .medium, design: .rounded))
.foregroundStyle(LP.inkSecondary)
.lineLimit(1)
}
HStack(spacing: 6) {
Circle()
.fill(model.lastSync == nil ? LP.open : LP.success)
.frame(width: 5, height: 5)
Text(model.lastSync == nil ? "Offline-Kalender aktiv" : "Kalender aktualisiert")
.font(.system(size: 8.5, weight: .medium))
.foregroundStyle(LP.inkTertiary)
}
Link(destination: URL(string: "https://www.eucharistiefeier.de")!) {
Text("Daten: www.eucharistiefeier.de")
.font(.system(size: 8, weight: .medium))
.foregroundStyle(LP.inkTertiary.opacity(0.85))
.underline()
}
Text("Prototyp 0.1 · Erzbistum Köln")
.font(.system(size: 7.5, weight: .regular))
.foregroundStyle(LP.inkTertiary.opacity(0.7))
}
.padding(.horizontal, 16)
.padding(.bottom, 14)
}
}
+123
View File
@@ -0,0 +1,123 @@
import SwiftUI
import AppKit
import LektorenPlanCore
/// Development helper: renders a view into a PNG (and optionally the plan PDF) so the
/// UI can be reviewed without screen-recording permissions.
/// Enabled only through the LP_SNAPSHOT / LP_PDF environment variables.
enum SnapshotCapture {
@MainActor
static func runIfRequested(model: PlanModel) async {
let environment = ProcessInfo.processInfo.environment
let wantsSnapshot = environment["LP_SNAPSHOT"] != nil
let wantsPDF = environment["LP_PDF"] != nil
guard wantsSnapshot || wantsPDF else { return }
try? await Task.sleep(nanoseconds: 1_500_000_000)
if let pdfPath = environment["LP_PDF"] {
let data = PlanPDFRenderer.render(
range: model.range,
rows: model.rows,
churches: model.churches,
people: model.peopleByID,
generatedAt: Date()
)
try? data.write(to: URL(fileURLWithPath: pdfPath))
}
guard wantsSnapshot, let path = snapshotPath else {
NSApplication.shared.terminate(nil)
return
}
let width = Double(environment["LP_SNAPSHOT_WIDTH"] ?? "") ?? 1440
let height = Double(environment["LP_SNAPSHOT_HEIGHT"] ?? "") ?? 869
let size = CGSize(width: width, height: height)
let content = SnapshotContent(view: environment["LP_SNAPSHOT_VIEW"])
.environmentObject(model)
.frame(width: size.width, height: size.height)
let hosting = NSHostingView(rootView: content)
hosting.frame = CGRect(origin: .zero, size: size)
let window = NSWindow(
contentRect: CGRect(origin: .zero, size: size),
styleMask: [.borderless],
backing: .buffered,
defer: false
)
window.contentView = hosting
window.orderFrontRegardless()
hosting.layoutSubtreeIfNeeded()
window.displayIfNeeded()
// Lazy containers and AppKit-backed controls need a run-loop cycle before capture.
try? await Task.sleep(nanoseconds: 800_000_000)
hosting.layoutSubtreeIfNeeded()
window.displayIfNeeded()
guard let rep = hosting.bitmapImageRepForCachingDisplay(in: hosting.bounds) else {
NSApplication.shared.terminate(nil)
return
}
hosting.cacheDisplay(in: hosting.bounds, to: rep)
if let png = rep.representation(using: .png, properties: [:]) {
try? png.write(to: URL(fileURLWithPath: path))
}
NSApplication.shared.terminate(nil)
}
private static var snapshotPath: String? {
ProcessInfo.processInfo.environment["LP_SNAPSHOT"]
}
}
private struct SnapshotContent: View {
@EnvironmentObject private var model: PlanModel
var view: String?
var body: some View {
switch view {
case "team":
screen { TeamView() }
case "order":
screen { ServiceOrderView() }
case "statistics":
screen { StatisticsView() }
case "exchange":
screen { ExchangeView() }
case "settings":
screen { SettingsView() }
case "person":
PersonEditorSheet(request: PersonEditorRequest(person: model.people.first))
case "detail":
if let serviceID = model.rows
.flatMap(\.services)
.first(where: { !$0.isFullyStaffed })?.service.id {
ServiceDetailSheet(serviceID: serviceID)
}
case "template":
if let template = model.templates.first {
TemplateEditorSheet(request: TemplateEditorRequest(template: template, churchID: template.churchID))
}
case "special":
SpecialServiceSheet(request: SpecialServiceRequest(
churchID: model.churches.first?.id,
date: DayMath.today()
))
case "root":
RootView()
default:
screen { PlanningView() }
}
}
@ViewBuilder
private func screen<Content: View>(@ViewBuilder _ content: () -> Content) -> some View {
ZStack {
AppBackground()
content()
}
}
}
+581
View File
@@ -0,0 +1,581 @@
import SwiftUI
import AppKit
import LektorenPlanCore
enum LP {
static func dynamic(light: NSColor, dark: NSColor) -> Color {
Color(nsColor: NSColor(name: nil) { appearance in
appearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua ? dark : light
})
}
static let paper = dynamic(
light: NSColor(calibratedRed: 0.973, green: 0.957, blue: 0.925, alpha: 1),
dark: NSColor(calibratedRed: 0.075, green: 0.078, blue: 0.086, alpha: 1)
)
static let paperDeep = dynamic(
light: NSColor(calibratedRed: 0.945, green: 0.924, blue: 0.882, alpha: 1),
dark: NSColor(calibratedRed: 0.055, green: 0.058, blue: 0.065, alpha: 1)
)
static let card = dynamic(
light: NSColor(calibratedWhite: 1.0, alpha: 1),
dark: NSColor(calibratedRed: 0.125, green: 0.129, blue: 0.141, alpha: 1)
)
static let cardMuted = dynamic(
light: NSColor(calibratedRed: 0.985, green: 0.975, blue: 0.955, alpha: 1),
dark: NSColor(calibratedRed: 0.155, green: 0.159, blue: 0.172, alpha: 1)
)
static let ink = dynamic(
light: NSColor(calibratedRed: 0.12, green: 0.135, blue: 0.155, alpha: 1),
dark: NSColor(calibratedRed: 0.93, green: 0.92, blue: 0.90, alpha: 1)
)
static let inkSecondary = dynamic(
light: NSColor(calibratedRed: 0.36, green: 0.37, blue: 0.38, alpha: 1),
dark: NSColor(calibratedRed: 0.68, green: 0.68, blue: 0.68, alpha: 1)
)
static let inkTertiary = dynamic(
light: NSColor(calibratedRed: 0.52, green: 0.51, blue: 0.49, alpha: 1),
dark: NSColor(calibratedRed: 0.48, green: 0.48, blue: 0.48, alpha: 1)
)
static let line = dynamic(
light: NSColor(calibratedRed: 0.86, green: 0.835, blue: 0.79, alpha: 1),
dark: NSColor(calibratedRed: 0.24, green: 0.245, blue: 0.26, alpha: 1)
)
static let accent = Color(hex: "#2E5B57")
static let accentSoft = dynamic(
light: NSColor(calibratedRed: 0.88, green: 0.925, blue: 0.905, alpha: 1),
dark: NSColor(calibratedRed: 0.13, green: 0.21, blue: 0.20, alpha: 1)
)
static let gold = Color(hex: "#B7863B")
static let goldSoft = dynamic(
light: NSColor(calibratedRed: 0.976, green: 0.925, blue: 0.80, alpha: 1),
dark: NSColor(calibratedRed: 0.24, green: 0.20, blue: 0.105, alpha: 1)
)
static let burgundy = Color(hex: "#7E3D4A")
static let burgundySoft = dynamic(
light: NSColor(calibratedRed: 0.966, green: 0.90, blue: 0.90, alpha: 1),
dark: NSColor(calibratedRed: 0.245, green: 0.13, blue: 0.15, alpha: 1)
)
static let sundayWash = dynamic(
light: NSColor(calibratedRed: 0.985, green: 0.955, blue: 0.885, alpha: 1),
dark: NSColor(calibratedRed: 0.18, green: 0.155, blue: 0.105, alpha: 1)
)
static let feastWash = dynamic(
light: NSColor(calibratedRed: 0.998, green: 0.955, blue: 0.79, alpha: 1),
dark: NSColor(calibratedRed: 0.23, green: 0.185, blue: 0.085, alpha: 1)
)
static let open = Color(hex: "#B26A22")
static let openSoft = dynamic(
light: NSColor(calibratedRed: 0.99, green: 0.93, blue: 0.84, alpha: 1),
dark: NSColor(calibratedRed: 0.24, green: 0.17, blue: 0.075, alpha: 1)
)
static let success = Color(hex: "#3F7A55")
static let successSoft = dynamic(
light: NSColor(calibratedRed: 0.89, green: 0.945, blue: 0.90, alpha: 1),
dark: NSColor(calibratedRed: 0.10, green: 0.22, blue: 0.14, alpha: 1)
)
static let danger = Color(hex: "#A5453F")
static let numberFont = Font.system(size: 13, weight: .semibold, design: .rounded)
static let labelFont = Font.system(size: 11, weight: .semibold, design: .rounded)
static let serifTitle = Font.system(size: 30, weight: .semibold, design: .serif)
static let serifHeadline = Font.system(size: 19, weight: .semibold, design: .serif)
static let serifSubhead = Font.system(size: 15, weight: .medium, design: .serif)
static func churchColor(_ hex: String) -> Color {
Color(hex: hex)
}
static func liturgicalColor(_ color: LiturgicalColor) -> Color {
switch color {
case .white, .gold: return Color(hex: "#C2A14D")
case .red: return Color(hex: "#A5453F")
case .green: return Color(hex: "#4F7D5A")
case .violet: return Color(hex: "#6E4B8E")
case .rose: return Color(hex: "#C07A8B")
case .black: return Color(hex: "#4A4440")
}
}
}
extension Color {
init(hex: String) {
let cleaned = hex.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
var value: UInt64 = 0
Scanner(string: cleaned).scanHexInt64(&value)
let r, g, b, a: UInt64
switch cleaned.count {
case 8:
r = (value >> 24) & 0xFF
g = (value >> 16) & 0xFF
b = (value >> 8) & 0xFF
a = value & 0xFF
case 6:
r = (value >> 16) & 0xFF
g = (value >> 8) & 0xFF
b = value & 0xFF
a = 255
default:
r = 120; g = 120; b = 120; a = 255
}
self.init(.sRGB, red: Double(r) / 255, green: Double(g) / 255, blue: Double(b) / 255, opacity: Double(a) / 255)
}
}
// MARK: - Surfaces
struct SurfaceCard<Content: View>: View {
var padding: CGFloat
var radius: CGFloat
var background: Color
var bordered: Bool
@ViewBuilder var content: Content
init(
padding: CGFloat = 18,
radius: CGFloat = 16,
background: Color = LP.card,
bordered: Bool = true,
@ViewBuilder content: () -> Content
) {
self.padding = padding
self.radius = radius
self.background = background
self.bordered = bordered
self.content = content()
}
var body: some View {
content
.padding(padding)
.background(
RoundedRectangle(cornerRadius: radius, style: .continuous)
.fill(background)
.shadow(color: .black.opacity(0.035), radius: 10, x: 0, y: 4)
)
.overlay(
RoundedRectangle(cornerRadius: radius, style: .continuous)
.strokeBorder(bordered ? LP.line.opacity(0.55) : .clear, lineWidth: 1)
)
}
}
struct AppBackground: View {
var body: some View {
ZStack {
LinearGradient(
colors: [LP.paper, LP.paperDeep, LP.paper],
startPoint: .topLeading,
endPoint: .bottomTrailing
)
RadialGradient(
colors: [LP.gold.opacity(0.055), .clear],
center: .topTrailing,
startRadius: 20,
endRadius: 620
)
RadialGradient(
colors: [LP.accent.opacity(0.045), .clear],
center: .bottomLeading,
startRadius: 20,
endRadius: 700
)
}
.ignoresSafeArea()
}
}
// MARK: - Badges
struct TinyBadge: View {
var text: String
var color: Color
var filled: Bool = false
var body: some View {
Text(text)
.font(.system(size: 9.5, weight: .bold, design: .rounded))
.tracking(0.4)
.foregroundStyle(filled ? Color.white : color)
.padding(.horizontal, 7)
.padding(.vertical, 3)
.background(
Capsule().fill(filled ? color : color.opacity(0.12))
)
.overlay(
Capsule().strokeBorder(filled ? .clear : color.opacity(0.20), lineWidth: 0.8)
)
}
}
struct RankBadge: View {
var day: LiturgicalDay
var body: some View {
if day.isHighFeast {
TinyBadge(text: "HOCHFEST", color: LP.gold, filled: true)
} else if day.rank == .feast {
TinyBadge(text: "FEST", color: LP.burgundy, filled: true)
} else if day.rank == .obligatoryMemorial {
TinyBadge(text: "GEDENKTAG", color: LP.accent)
} else if day.isObligation && !day.isSunday {
TinyBadge(text: "GEBOTEN", color: LP.burgundy)
}
}
}
struct RoleBadge: View {
var role: Role
var compact: Bool = false
var body: some View {
HStack(spacing: 4) {
Image(systemName: role.symbolName)
.font(.system(size: compact ? 8 : 9, weight: .semibold))
if !compact {
Text(role.title)
.font(.system(size: 9.5, weight: .semibold))
}
}
.foregroundStyle(role == .lector ? LP.accent : LP.burgundy)
.padding(.horizontal, compact ? 5 : 6)
.padding(.vertical, 2.5)
.background(
Capsule().fill(role == .lector ? LP.accent.opacity(0.09) : LP.burgundy.opacity(0.09))
)
}
}
struct Avatar: View {
var initials: String
var color: Color
var size: CGFloat = 26
var body: some View {
Text(initials)
.font(.system(size: size * 0.34, weight: .bold, design: .rounded))
.foregroundStyle(.white)
.frame(width: size, height: size)
.background(
Circle().fill(
LinearGradient(colors: [color.opacity(0.9), color.opacity(0.65)],
startPoint: .topLeading, endPoint: .bottomTrailing)
)
)
.overlay(Circle().strokeBorder(.white.opacity(0.28), lineWidth: 0.7))
}
}
struct PersonMiniChip: View {
var person: Person
var role: Role
var color: Color
var body: some View {
HStack(spacing: 4) {
Avatar(initials: person.initials, color: color, size: 18)
Text(person.firstNameWithInitial)
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.ink)
.lineLimit(1)
}
.padding(.horizontal, 4)
.padding(.vertical, 2)
.background(
Capsule().fill(LP.cardMuted)
)
.overlay(
Capsule().strokeBorder(LP.line.opacity(0.5), lineWidth: 0.6)
)
.help("\(person.fullName) · \(role.title)\n\(person.preferredChurchIDs.isEmpty ? "Alle Orte" : "Bevorzugte Orte") · max. \(person.maxPerMonth) Einsätze/Monat")
}
}
// MARK: - Buttons
struct PrimaryActionButton: View {
var title: String
var icon: String
var action: () -> Void
var disabled: Bool = false
var body: some View {
Button(action: action) {
HStack(spacing: 7) {
Image(systemName: icon)
.font(.system(size: 11, weight: .bold))
Text(title)
.font(.system(size: 12, weight: .semibold))
}
.foregroundStyle(.white)
.padding(.horizontal, 14)
.padding(.vertical, 8)
.background(
RoundedRectangle(cornerRadius: 9, style: .continuous)
.fill(LinearGradient(colors: [LP.accent, LP.accent.opacity(0.82)],
startPoint: .top, endPoint: .bottom))
.shadow(color: LP.accent.opacity(0.20), radius: 5, y: 2)
)
}
.buttonStyle(.plain)
.disabled(disabled)
.opacity(disabled ? 0.45 : 1)
}
}
struct SecondaryActionButton: View {
var title: String
var icon: String
var action: () -> Void
var disabled: Bool = false
var tint: Color = LP.ink
var body: some View {
Button(action: action) {
HStack(spacing: 6) {
Image(systemName: icon)
.font(.system(size: 10.5, weight: .semibold))
Text(title)
.font(.system(size: 11.5, weight: .medium))
}
.foregroundStyle(tint)
.padding(.horizontal, 12)
.padding(.vertical, 7)
.background(
RoundedRectangle(cornerRadius: 8, style: .continuous)
.fill(LP.card)
)
.overlay(
RoundedRectangle(cornerRadius: 8, style: .continuous)
.strokeBorder(LP.line.opacity(0.8), lineWidth: 1)
)
}
.buttonStyle(.plain)
.disabled(disabled)
.opacity(disabled ? 0.45 : 1)
}
}
struct IconActionButton: View {
var icon: String
var help: String
var action: () -> Void
var tint: Color = LP.inkSecondary
var body: some View {
Button(action: action) {
Image(systemName: icon)
.font(.system(size: 12, weight: .semibold))
.foregroundStyle(tint)
.frame(width: 28, height: 28)
.background(Circle().fill(LP.card))
.overlay(Circle().strokeBorder(LP.line.opacity(0.7), lineWidth: 0.8))
}
.buttonStyle(.plain)
.help(help)
}
}
// MARK: - Headers
struct PageHeader<Trailing: View>: View {
var eyebrow: String
var title: String
var subtitle: String
@ViewBuilder var trailing: Trailing
init(eyebrow: String, title: String, subtitle: String, @ViewBuilder trailing: () -> Trailing) {
self.eyebrow = eyebrow
self.title = title
self.subtitle = subtitle
self.trailing = trailing()
}
var body: some View {
HStack(alignment: .bottom, spacing: 22) {
VStack(alignment: .leading, spacing: 5) {
Text(eyebrow.uppercased())
.font(.system(size: 9.5, weight: .bold, design: .rounded))
.tracking(1.5)
.foregroundStyle(LP.accent)
Text(title)
.font(LP.serifTitle)
.foregroundStyle(LP.ink)
Text(subtitle)
.font(.system(size: 12, weight: .regular))
.foregroundStyle(LP.inkSecondary)
}
Spacer(minLength: 16)
trailing
}
}
}
extension PageHeader where Trailing == EmptyView {
init(eyebrow: String, title: String, subtitle: String) {
self.init(eyebrow: eyebrow, title: title, subtitle: subtitle) { EmptyView() }
}
}
struct SectionLabel: View {
var title: String
var trailing: String? = nil
var body: some View {
HStack(alignment: .firstTextBaseline) {
Text(title)
.font(.system(size: 10, weight: .bold, design: .rounded))
.tracking(1.3)
.foregroundStyle(LP.inkTertiary)
Spacer()
if let trailing {
Text(trailing)
.font(.system(size: 10, weight: .medium))
.foregroundStyle(LP.inkTertiary)
}
}
}
}
struct StatPill: View {
var icon: String
var value: String
var label: String
var tint: Color = LP.accent
var body: some View {
HStack(spacing: 9) {
Image(systemName: icon)
.font(.system(size: 12, weight: .semibold))
.foregroundStyle(tint)
.frame(width: 26, height: 26)
.background(Circle().fill(tint.opacity(0.10)))
VStack(alignment: .leading, spacing: 1) {
Text(value)
.font(.system(size: 17, weight: .bold, design: .rounded))
.foregroundStyle(LP.ink)
Text(label)
.font(.system(size: 9.5, weight: .medium))
.foregroundStyle(LP.inkTertiary)
}
}
}
}
struct EmptyStateView: View {
var icon: String
var title: String
var message: String
var actionTitle: String? = nil
var action: (() -> Void)? = nil
var body: some View {
VStack(spacing: 12) {
Image(systemName: icon)
.font(.system(size: 30, weight: .light))
.foregroundStyle(LP.inkTertiary)
Text(title)
.font(LP.serifHeadline)
.foregroundStyle(LP.ink)
Text(message)
.font(.system(size: 12))
.foregroundStyle(LP.inkSecondary)
.multilineTextAlignment(.center)
.frame(maxWidth: 360)
if let actionTitle, let action {
PrimaryActionButton(title: actionTitle, icon: "plus", action: action)
.padding(.top, 4)
}
}
.frame(maxWidth: .infinity)
.padding(.vertical, 44)
}
}
// MARK: - Toast
struct ToastView: View {
var toast: Toast
@Environment(\.colorScheme) private var scheme
var body: some View {
HStack(spacing: 10) {
Image(systemName: toast.kind.icon)
.font(.system(size: 13, weight: .semibold))
.foregroundStyle(toast.kind.color)
Text(toast.message)
.font(.system(size: 12, weight: .medium))
.foregroundStyle(LP.ink)
.lineLimit(3)
}
.padding(.horizontal, 16)
.padding(.vertical, 11)
.background(
Capsule()
.fill(.regularMaterial)
.shadow(color: .black.opacity(0.16), radius: 16, y: 8)
)
.overlay(Capsule().strokeBorder(LP.line.opacity(0.6), lineWidth: 0.8))
.padding(.bottom, 24)
}
}
enum ToastKind {
case success, info, warning, error
var icon: String {
switch self {
case .success: "checkmark.circle.fill"
case .info: "info.circle.fill"
case .warning: "exclamationmark.triangle.fill"
case .error: "xmark.octagon.fill"
}
}
var color: Color {
switch self {
case .success: LP.success
case .info: LP.accent
case .warning: LP.open
case .error: LP.danger
}
}
}
struct Toast: Identifiable, Equatable {
var id = UUID()
var message: String
var kind: ToastKind
static func == (lhs: Toast, rhs: Toast) -> Bool { lhs.id == rhs.id }
}
// MARK: - Misc
struct Hairline: View {
var body: some View {
Rectangle().fill(LP.line.opacity(0.6)).frame(height: 1)
}
}
struct KeyboardShortcutHint: View {
var keys: String
var body: some View {
Text(keys)
.font(.system(size: 9, weight: .semibold, design: .rounded))
.foregroundStyle(LP.inkTertiary)
.padding(.horizontal, 5)
.padding(.vertical, 2)
.background(RoundedRectangle(cornerRadius: 4).fill(LP.cardMuted))
.overlay(RoundedRectangle(cornerRadius: 4).strokeBorder(LP.line.opacity(0.7), lineWidth: 0.6))
}
}
struct FlowingSubhead: View {
var text: String
var body: some View {
Text(text)
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.inkTertiary)
}
}
@@ -0,0 +1,283 @@
import SwiftUI
import UniformTypeIdentifiers
import LektorenPlanCore
struct ExchangeView: View {
@EnvironmentObject private var model: PlanModel
@State private var isDropTarget = false
var body: some View {
VStack(spacing: 14) {
PageHeader(
eyebrow: "Austausch",
title: "Daten teilen & übernehmen",
subtitle: "Planungsabschnitte oder Ressourcen zwischen Installationen austauschen – als offenes JSON-Format."
) {
HStack(spacing: 8) {
SecondaryActionButton(title: "Importieren", icon: "square.and.arrow.down") {
model.importInteractive()
}
PrimaryActionButton(title: "Plan exportieren", icon: "square.and.arrow.up") {
model.exportInteractive(scope: .plan)
}
}
}
ScrollView {
VStack(alignment: .leading, spacing: 14) {
currentRangeBanner
HStack(alignment: .top, spacing: 14) {
exportPlanCard
exportResourcesCard
}
importCard
formatInfo
}
.padding(.bottom, 16)
}
}
.padding(.horizontal, 22)
.padding(.top, 30)
.padding(.bottom, 18)
}
private var currentRangeBanner: some View {
SurfaceCard(padding: 13, radius: 14, background: LP.card.opacity(0.9)) {
HStack(spacing: 12) {
Image(systemName: "calendar")
.font(.system(size: 13, weight: .semibold))
.foregroundStyle(LP.accent)
.frame(width: 30, height: 30)
.background(Circle().fill(LP.accent.opacity(0.10)))
VStack(alignment: .leading, spacing: 1) {
Text("Aktueller Planungsabschnitt")
.font(.system(size: 9, weight: .semibold))
.foregroundStyle(LP.inkTertiary)
Text(model.range.title)
.font(.system(size: 12, weight: .semibold))
.foregroundStyle(LP.ink)
}
Spacer()
HStack(spacing: 14) {
countLabel("\(model.stats.serviceCount)", "Gottesdienste")
countLabel("\(model.stats.assignmentCount)", "Einsätze")
countLabel("\(model.stats.openSlots)", "offen")
}
SecondaryActionButton(title: "Zeitraum ändern", icon: "slider.horizontal.3") {
model.section = .planning
}
}
}
}
private func countLabel(_ value: String, _ label: String) -> some View {
VStack(alignment: .trailing, spacing: 0) {
Text(value)
.font(.system(size: 13, weight: .bold, design: .rounded))
.foregroundStyle(LP.ink)
Text(label)
.font(.system(size: 8))
.foregroundStyle(LP.inkTertiary)
}
}
// MARK: - Export cards
private var exportPlanCard: some View {
SurfaceCard(padding: 17, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 12) {
cardHeader(
icon: "calendar.badge.clock",
title: "Planungsabschnitt",
subtitle: "Gottesdienste, Einsätze und Liturgie des aktuellen Zeitraums",
tint: LP.accent
)
VStack(alignment: .leading, spacing: 6) {
detailRow("Zeitraum", model.range.shortTitle)
detailRow("Gottesdienste", "\(model.stats.serviceCount)")
detailRow("Einsätze", "\(model.stats.assignmentCount)")
detailRow("Beteiligte Personen", "\(Set(model.assignments.map(\.personID)).count)")
detailRow("Liturgische Tage", "\(model.liturgicalDays.count)")
}
Text("Enthält zusätzlich die Stammdaten der beteiligten Personen sowie Kirchen, Vorlagen und Ausnahmen, damit der Abschnitt am Zielort vollständig lesbar ist.")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
.fixedSize(horizontal: false, vertical: true)
PrimaryActionButton(title: "Plan als JSON exportieren", icon: "square.and.arrow.up") {
model.exportInteractive(scope: .plan)
}
}
}
}
private var exportResourcesCard: some View {
SurfaceCard(padding: 17, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 12) {
cardHeader(
icon: "person.2.badge.gearshape",
title: "Ressourcen",
subtitle: "Kirchen, Personen, Abwesenheiten und Gottesdienstordnung",
tint: LP.burgundy
)
VStack(alignment: .leading, spacing: 6) {
detailRow("Kirchen", "\(model.churches.count)")
detailRow("Personen", "\(model.people.count)")
detailRow("Abwesenheiten", "\(model.absences.count)")
detailRow("Vorlagen", "\(model.templates.count)")
detailRow("Ausnahmen", "\(model.exceptions.count)")
}
Text("Ideal zur Weitergabe des kompletten Stammdatenbestands an eine zweite Installation. Einsätze und Gottesdienste sind nicht enthalten.")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
.fixedSize(horizontal: false, vertical: true)
PrimaryActionButton(title: "Ressourcen als JSON exportieren", icon: "square.and.arrow.up") {
model.exportInteractive(scope: .resources)
}
}
}
}
// MARK: - Import
private var importCard: some View {
SurfaceCard(padding: 17, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 12) {
cardHeader(
icon: "square.and.arrow.down",
title: "Datei importieren",
subtitle: "Zusammenführen mit dem aktuellen Bestand – ohne Datenverlust",
tint: LP.gold
)
HStack(spacing: 14) {
ZStack {
RoundedRectangle(cornerRadius: 12, style: .continuous)
.strokeBorder(
style: StrokeStyle(lineWidth: 1.2, dash: [5, 4])
)
.foregroundStyle(isDropTarget ? LP.accent : LP.line)
VStack(spacing: 6) {
Image(systemName: isDropTarget ? "arrow.down.doc.fill" : "doc.badge.plus")
.font(.system(size: 22, weight: .light))
.foregroundStyle(isDropTarget ? LP.accent : LP.inkTertiary)
Text(isDropTarget ? "Loslassen zum Prüfen" : "LektorenPlan-JSON hierher ziehen")
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.inkSecondary)
Text("oder Datei auswählen")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
}
}
.frame(height: 116)
.frame(maxWidth: .infinity)
.background(RoundedRectangle(cornerRadius: 12).fill(isDropTarget ? LP.accentSoft.opacity(0.4) : LP.cardMuted.opacity(0.35)))
.onDrop(of: [UTType.fileURL.identifier], isTargeted: $isDropTarget) { providers in
handleDrop(providers)
return true
}
VStack(alignment: .leading, spacing: 8) {
Text("Ablauf")
.font(.system(size: 9, weight: .bold, design: .rounded))
.tracking(0.8)
.foregroundStyle(LP.inkTertiary)
step(1, "Datei auswählen oder ablegen")
step(2, "Inhalt in der Vorschau prüfen")
step(3, "Zusammenführen bestätigen")
SecondaryActionButton(title: "Datei auswählen…", icon: "folder") {
model.importInteractive()
}
.padding(.top, 2)
}
.frame(width: 240, alignment: .leading)
}
}
}
}
private func step(_ number: Int, _ text: String) -> some View {
HStack(spacing: 7) {
Text("\(number)")
.font(.system(size: 8, weight: .bold, design: .rounded))
.foregroundStyle(LP.accent)
.frame(width: 16, height: 16)
.background(Circle().fill(LP.accent.opacity(0.10)))
Text(text)
.font(.system(size: 9.5))
.foregroundStyle(LP.inkSecondary)
}
}
private func handleDrop(_ providers: [NSItemProvider]) {
guard let provider = providers.first else { return }
_ = provider.loadObject(ofClass: URL.self) { url, _ in
guard let url else { return }
Task { @MainActor in
model.prepareImport(url: url)
}
}
}
// MARK: - Info
private var formatInfo: some View {
SurfaceCard(padding: 15, radius: 14, background: LP.accentSoft.opacity(0.4)) {
HStack(alignment: .top, spacing: 10) {
Image(systemName: "info.circle")
.font(.system(size: 12))
.foregroundStyle(LP.accent)
VStack(alignment: .leading, spacing: 4) {
Text("Offenes Austauschformat")
.font(.system(size: 10.5, weight: .semibold))
.foregroundStyle(LP.ink)
Text("Die Dateien sind lesbare JSON-Dokumente mit Versionsnummer, Zeitraum, Ressourcen und Planungsdaten. Datensätze werden über stabile IDs zusammengeführt. Vor dem Import wird immer eine Vorschau mit allen enthaltenen Elementen angezeigt.")
.font(.system(size: 9.5))
.foregroundStyle(LP.inkSecondary)
.fixedSize(horizontal: false, vertical: true)
}
Spacer()
}
}
}
private func cardHeader(icon: String, title: String, subtitle: String, tint: Color) -> some View {
HStack(alignment: .top, spacing: 9) {
Image(systemName: icon)
.font(.system(size: 12, weight: .semibold))
.foregroundStyle(tint)
.frame(width: 28, height: 28)
.background(Circle().fill(tint.opacity(0.10)))
VStack(alignment: .leading, spacing: 1) {
Text(title)
.font(LP.serifSubhead)
.foregroundStyle(LP.ink)
Text(subtitle)
.font(.system(size: 8.5))
.foregroundStyle(LP.inkTertiary)
.fixedSize(horizontal: false, vertical: true)
}
Spacer()
}
}
private func detailRow(_ label: String, _ value: String) -> some View {
HStack {
Text(label)
.font(.system(size: 9.5))
.foregroundStyle(LP.inkSecondary)
Spacer()
Text(value)
.font(.system(size: 9.5, weight: .semibold, design: .rounded))
.foregroundStyle(LP.ink)
}
}
}
@@ -0,0 +1,125 @@
import SwiftUI
import LektorenPlanCore
struct ImportPreviewSheet: View {
@EnvironmentObject private var model: PlanModel
@Environment(\.dismiss) private var dismiss
let preview: ImportPreview
private var exchange: PlanExchange { preview.exchange }
private var summary: ExchangeSummary { exchange.summary }
var body: some View {
VStack(spacing: 0) {
SheetHeader(
icon: "square.and.arrow.down",
title: "Import prüfen",
subtitle: "Die Datei \(preview.sourceName) wurde gelesen. Prüfe den Inhalt, bevor du ihn übernimmst."
)
Hairline()
ScrollView {
VStack(alignment: .leading, spacing: 20) {
HStack(spacing: 10) {
TinyBadge(text: exchange.scope.title.uppercased(), color: LP.accent, filled: true)
Text("Format \(exchange.formatVersion) · \(exchange.appName)")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
Spacer()
if let exported = exchange.exportedAt as Date? {
Text("Exportiert am \(DayMath.mediumString(exported))")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
}
}
.padding(11)
.background(RoundedRectangle(cornerRadius: 9).fill(LP.cardMuted))
.overlay(RoundedRectangle(cornerRadius: 9).strokeBorder(LP.line.opacity(0.6), lineWidth: 0.8))
FormSection(title: "Zeitraum") {
HStack(spacing: 8) {
Image(systemName: "calendar")
.foregroundStyle(LP.accent)
Text(exchange.range.title)
.font(.system(size: 12, weight: .medium))
.foregroundStyle(LP.ink)
Text("· \(exchange.range.dayCount) Tage")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
}
}
FormSection(title: "Enthaltene Daten") {
LazyVGrid(columns: [GridItem(.adaptive(minimum: 150), spacing: 10)], spacing: 10) {
countCard(icon: "building.columns", value: summary.churches, label: "Kirchen", tint: LP.accent)
countCard(icon: "person.2", value: summary.people, label: "Personen", tint: LP.burgundy)
countCard(icon: "calendar.badge.clock", value: summary.templates, label: "Vorlagen", tint: LP.gold)
countCard(icon: "list.bullet.rectangle", value: summary.services, label: "Gottesdienste", tint: LP.accent)
countCard(icon: "checkmark.seal", value: summary.assignments, label: "Einsätze", tint: LP.success)
countCard(icon: "book.closed", value: summary.liturgicalDays, label: "Liturgische Tage", tint: LP.burgundy)
}
}
if !exchange.note.isEmpty {
FormSection(title: "Notiz") {
Text(exchange.note)
.font(.system(size: 10.5))
.foregroundStyle(LP.inkSecondary)
.fixedSize(horizontal: false, vertical: true)
}
}
HStack(alignment: .top, spacing: 8) {
Image(systemName: "info.circle")
.font(.system(size: 11))
.foregroundStyle(LP.accent)
Text("Datensätze werden anhand ihrer stabilen IDs zusammengeführt. Bereits vorhandene Kirchen, Personen und Vorlagen werden aktualisiert, neue Dienste und Einsätze ergänzt. Es wird nichts gelöscht.")
.font(.system(size: 10))
.foregroundStyle(LP.inkSecondary)
.fixedSize(horizontal: false, vertical: true)
}
.padding(11)
.background(RoundedRectangle(cornerRadius: 9).fill(LP.accentSoft.opacity(0.55)))
}
.padding(22)
}
SheetFooter {
Spacer()
SecondaryActionButton(title: "Abbrechen", icon: "xmark") {
model.importPreview = nil
dismiss()
}
PrimaryActionButton(title: "Importieren", icon: "square.and.arrow.down") {
model.applyImport(preview)
dismiss()
}
}
}
.sheetSurface(width: 620, height: 620)
}
private func countCard(icon: String, value: Int, label: String, tint: Color) -> some View {
HStack(spacing: 9) {
Image(systemName: icon)
.font(.system(size: 12, weight: .semibold))
.foregroundStyle(tint)
.frame(width: 28, height: 28)
.background(Circle().fill(tint.opacity(0.10)))
VStack(alignment: .leading, spacing: 1) {
Text("\(value)")
.font(.system(size: 15, weight: .bold, design: .rounded))
.foregroundStyle(LP.ink)
Text(label)
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
}
Spacer(minLength: 0)
}
.padding(9)
.background(RoundedRectangle(cornerRadius: 9).fill(LP.card))
.overlay(RoundedRectangle(cornerRadius: 9).strokeBorder(LP.line.opacity(0.6), lineWidth: 0.8))
}
}
@@ -0,0 +1,83 @@
import SwiftUI
import PDFKit
import LektorenPlanCore
struct PDFPreviewSheet: View {
@EnvironmentObject private var model: PlanModel
@Environment(\.dismiss) private var dismiss
let preview: PDFPreview
private var document: PDFDocument? {
PDFDocument(data: preview.data)
}
var body: some View {
VStack(spacing: 0) {
HStack(spacing: 12) {
ZStack {
RoundedRectangle(cornerRadius: 10, style: .continuous)
.fill(LP.accent.opacity(0.11))
Image(systemName: "doc.richtext")
.font(.system(size: 16, weight: .semibold))
.foregroundStyle(LP.accent)
}
.frame(width: 38, height: 38)
VStack(alignment: .leading, spacing: 2) {
Text(preview.title)
.font(LP.serifHeadline)
.foregroundStyle(LP.ink)
Text("\(document?.pageCount ?? 0) Seiten · A4 quer · bereit zum Drucken")
.font(.system(size: 10))
.foregroundStyle(LP.inkSecondary)
}
Spacer()
SecondaryActionButton(title: "Sichern", icon: "square.and.arrow.down") {
model.savePDF(data: preview.data, suggestedName: preview.filename)
}
SecondaryActionButton(title: "Drucken", icon: "printer") {
model.printPDF(data: preview.data)
}
PrimaryActionButton(title: "Fertig", icon: "checkmark") { dismiss() }
}
.padding(.horizontal, 20)
.padding(.vertical, 14)
Hairline()
if let document {
PDFKitPreview(document: document)
.background(Color(nsColor: .windowBackgroundColor))
} else {
EmptyStateView(
icon: "exclamationmark.triangle",
title: "PDF nicht verfügbar",
message: "Das Dokument konnte nicht erzeugt werden."
)
}
}
.sheetSurface(width: 960, height: 760)
}
}
private struct PDFKitPreview: NSViewRepresentable {
let document: PDFDocument
func makeNSView(context: Context) -> PDFView {
let view = PDFView()
view.document = document
view.autoScales = true
view.displayMode = .singlePageContinuous
view.displayDirection = .vertical
view.backgroundColor = NSColor(calibratedWhite: 0.90, alpha: 1)
view.pageShadowsEnabled = true
return view
}
func updateNSView(_ nsView: PDFView, context: Context) {
if nsView.document !== document {
nsView.document = document
}
}
}
@@ -0,0 +1,452 @@
import SwiftUI
import LektorenPlanCore
struct PersonEditorSheet: View {
@EnvironmentObject private var model: PlanModel
@Environment(\.dismiss) private var dismiss
let request: PersonEditorRequest
@State private var firstName = ""
@State private var lastName = ""
@State private var email = ""
@State private var phone = ""
@State private var roles: Set<Role> = [.lector]
@State private var preferredChurchIDs: Set<String> = []
@State private var preferredWeekdays: Set<Int> = []
@State private var preferredServiceTitles: Set<String> = []
@State private var maxPerMonth = 6
@State private var active = true
@State private var notes = ""
@State private var showAbsenceForm = false
@State private var absenceStart = DayMath.today()
@State private var absenceEnd = DayMath.today()
@State private var absenceReason = ""
@State private var confirmDelete = false
private var personID: String? { request.person?.id }
private var weekdayOrder: [Int] { [2, 3, 4, 5, 6, 7, 1] }
private func weekdayLabel(_ weekday: Int) -> String {
["", "So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"][max(0, min(7, weekday))]
}
private var isValid: Bool {
!firstName.trimmingCharacters(in: .whitespaces).isEmpty
&& !lastName.trimmingCharacters(in: .whitespaces).isEmpty
&& !roles.isEmpty
}
var body: some View {
VStack(spacing: 0) {
SheetHeader(
icon: request.person == nil ? "person.badge.plus" : "person.crop.circle",
title: request.person == nil ? "Neue Person" : request.person?.fullName ?? "Person",
subtitle: "Rollen, bevorzugte Einsatzorte und Einsatztage, Abwesenheiten und Monatslimit."
)
Hairline()
ScrollView {
VStack(alignment: .leading, spacing: 22) {
basics
rolesSection
preferencesSection
capacitySection
if let personID, let person = request.person {
absenceSection(person: person, personID: personID)
}
}
.padding(22)
}
SheetFooter {
if request.person != nil {
Button {
confirmDelete = true
} label: {
HStack(spacing: 5) {
Image(systemName: "trash")
Text("Löschen")
}
.font(.system(size: 11.5, weight: .medium))
.foregroundStyle(LP.danger)
}
.buttonStyle(.plain)
}
Spacer()
SecondaryActionButton(title: "Abbrechen", icon: "xmark") { dismiss() }
PrimaryActionButton(
title: "Speichern",
icon: "checkmark",
action: save,
disabled: !isValid
)
}
}
.sheetSurface(width: 640, height: 700)
.onAppear(perform: load)
.confirmationDialog(
"Person löschen?",
isPresented: $confirmDelete,
titleVisibility: .visible
) {
Button("Endgültig löschen", role: .destructive) {
if let person = request.person {
model.deletePerson(person)
}
dismiss()
}
Button("Abbrechen", role: .cancel) {}
} message: {
Text("Alle Einsätze und Abwesenheiten dieser Person werden mit entfernt. Bereits geplante Dienste werden wieder offen.")
}
}
// MARK: - Sections
private var basics: some View {
FormSection(title: "Stammdaten") {
HStack(spacing: 12) {
LabeledField(label: "Vorname") {
TextField("z. B. Anna", text: $firstName)
.textFieldStyle(.roundedBorder)
}
LabeledField(label: "Nachname") {
TextField("z. B. Berg", text: $lastName)
.textFieldStyle(.roundedBorder)
}
}
HStack(spacing: 12) {
LabeledField(label: "E-Mail") {
TextField("optional", text: $email)
.textFieldStyle(.roundedBorder)
}
LabeledField(label: "Telefon") {
TextField("optional", text: $phone)
.textFieldStyle(.roundedBorder)
}
}
}
}
private var rolesSection: some View {
FormSection(
title: "Rollen",
subtitle: "Eine Person kann als Lektor und als Kommunionhelfer eingeplant werden."
) {
HStack(spacing: 8) {
ForEach(Role.allCases) { role in
ChipToggle(
title: role.titlePluralShort,
icon: role.symbolName,
isOn: roles.contains(role),
tint: role == .lector ? LP.accent : LP.burgundy
) {
if roles.contains(role) {
if roles.count > 1 { roles.remove(role) }
} else {
roles.insert(role)
}
}
}
Spacer()
Toggle(isOn: $active) {
Text("Aktiv im Plan")
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.inkSecondary)
}
.toggleStyle(.switch)
.controlSize(.small)
}
}
}
private var preferencesSection: some View {
FormSection(
title: "Einsatzpräferenzen",
subtitle: "Leere Auswahl bedeutet: flexibel für alle Orte, Tage und Gottesdienste."
) {
VStack(alignment: .leading, spacing: 5) {
Text("Bevorzugte Kirchen")
.font(.system(size: 9.5, weight: .semibold))
.foregroundStyle(LP.inkSecondary)
FlowLayout(spacing: 6) {
ForEach(model.churches) { church in
ChipToggle(
title: church.shortName,
icon: "building.columns",
isOn: preferredChurchIDs.contains(church.id),
tint: LP.churchColor(church.colorHex)
) {
if preferredChurchIDs.contains(church.id) {
preferredChurchIDs.remove(church.id)
} else {
preferredChurchIDs.insert(church.id)
}
}
}
}
}
VStack(alignment: .leading, spacing: 5) {
Text("Bevorzugte Einsatztage")
.font(.system(size: 9.5, weight: .semibold))
.foregroundStyle(LP.inkSecondary)
HStack(spacing: 5) {
ForEach(weekdayOrder, id: \.self) { weekday in
ChipToggle(
title: weekdayLabel(weekday),
isOn: preferredWeekdays.contains(weekday),
tint: weekday == 1 ? LP.burgundy : LP.accent
) {
if preferredWeekdays.contains(weekday) {
preferredWeekdays.remove(weekday)
} else {
preferredWeekdays.insert(weekday)
}
}
}
}
}
VStack(alignment: .leading, spacing: 5) {
Text("Bevorzugte Gottesdienste")
.font(.system(size: 9.5, weight: .semibold))
.foregroundStyle(LP.inkSecondary)
FlowLayout(spacing: 6) {
ForEach(model.serviceTitles, id: \.self) { title in
ChipToggle(
title: title,
icon: "book.closed",
isOn: preferredServiceTitles.contains(title),
tint: LP.gold
) {
if preferredServiceTitles.contains(title) {
preferredServiceTitles.remove(title)
} else {
preferredServiceTitles.insert(title)
}
}
}
}
}
}
}
private var capacitySection: some View {
FormSection(title: "Kapazität & Notizen") {
HStack(spacing: 16) {
LabeledField(label: "Maximale Einsätze pro Monat") {
HStack(spacing: 8) {
Stepper(value: $maxPerMonth, in: 1...30) {
Text("\(maxPerMonth)")
.font(.system(size: 12, weight: .semibold, design: .rounded))
.monospacedDigit()
}
.fixedSize()
Text(maxPerMonth >= 12 ? "sehr flexibel" : "Einsätze")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
}
}
Spacer()
}
LabeledField(label: "Notizen") {
TextEditor(text: $notes)
.font(.system(size: 11))
.frame(height: 62)
.padding(5)
.background(RoundedRectangle(cornerRadius: 7).fill(LP.card))
.overlay(RoundedRectangle(cornerRadius: 7).strokeBorder(LP.line.opacity(0.8), lineWidth: 1))
}
}
}
private func absenceSection(person: Person, personID: String) -> some View {
FormSection(
title: "Abwesenheiten",
subtitle: "In diesen Zeiträumen wird die Person nicht eingeplant."
) {
let list = model.absences(for: personID)
if list.isEmpty {
Text("Keine Abwesenheiten erfasst.")
.font(.system(size: 10.5))
.foregroundStyle(LP.inkTertiary)
} else {
VStack(spacing: 5) {
ForEach(list) { absence in
HStack(spacing: 8) {
Image(systemName: "calendar.badge.minus")
.font(.system(size: 10))
.foregroundStyle(LP.open)
Text(absence.label)
.font(.system(size: 10.5))
.foregroundStyle(LP.ink)
Spacer()
Button {
model.deleteAbsence(absence)
} label: {
Image(systemName: "xmark.circle.fill")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
}
.buttonStyle(.plain)
.help("Abwesenheit entfernen")
}
.padding(.horizontal, 9)
.padding(.vertical, 6)
.background(RoundedRectangle(cornerRadius: 7).fill(LP.card))
.overlay(RoundedRectangle(cornerRadius: 7).strokeBorder(LP.line.opacity(0.6), lineWidth: 0.8))
}
}
}
if showAbsenceForm {
VStack(alignment: .leading, spacing: 8) {
HStack(spacing: 10) {
DatePicker("Von", selection: $absenceStart, displayedComponents: .date)
.font(.system(size: 10.5))
DatePicker("Bis", selection: $absenceEnd, displayedComponents: .date)
.font(.system(size: 10.5))
}
HStack(spacing: 8) {
TextField("Grund (optional)", text: $absenceReason)
.textFieldStyle(.roundedBorder)
.font(.system(size: 11))
PrimaryActionButton(title: "Hinzufügen", icon: "plus", action: addAbsence)
}
}
.padding(10)
.background(RoundedRectangle(cornerRadius: 9).fill(LP.cardMuted))
}
Button {
withAnimation(.easeInOut(duration: 0.16)) {
showAbsenceForm.toggle()
}
} label: {
HStack(spacing: 4) {
Image(systemName: showAbsenceForm ? "minus.circle" : "plus.circle")
Text(showAbsenceForm ? "Eingabe schließen" : "Abwesenheit erfassen")
}
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.accent)
}
.buttonStyle(.plain)
}
}
// MARK: - Actions
private func load() {
guard let person = request.person else {
if let role = request.presetRole {
roles = [role]
}
return
}
firstName = person.firstName
lastName = person.lastName
email = person.email
phone = person.phone
roles = person.roles
preferredChurchIDs = person.preferredChurchIDs
preferredWeekdays = person.preferredWeekdays
preferredServiceTitles = Set(person.preferredServiceTitles)
maxPerMonth = person.maxPerMonth
active = person.active
notes = person.notes
}
private func addAbsence() {
guard let personID else { return }
let start = min(absenceStart, absenceEnd)
let end = max(absenceStart, absenceEnd)
model.saveAbsence(Absence(
personID: personID,
start: start,
end: end,
reason: absenceReason.trimmingCharacters(in: .whitespaces)
))
absenceReason = ""
showAbsenceForm = false
}
private func save() {
let person = Person(
id: personID ?? UUID().uuidString,
firstName: firstName.trimmingCharacters(in: .whitespaces),
lastName: lastName.trimmingCharacters(in: .whitespaces),
roles: roles,
email: email.trimmingCharacters(in: .whitespaces),
phone: phone.trimmingCharacters(in: .whitespaces),
preferredChurchIDs: preferredChurchIDs,
preferredWeekdays: preferredWeekdays,
preferredServiceTitles: Array(preferredServiceTitles).sorted(),
maxPerMonth: maxPerMonth,
active: active,
notes: notes.trimmingCharacters(in: .whitespacesAndNewlines)
)
model.savePerson(person)
dismiss()
}
}
private extension Role {
var titlePluralShort: String {
switch self {
case .lector: "Lektor"
case .helper: "Kommunionhelfer"
}
}
}
// MARK: - Flow layout
/// A tiny wrapping layout so preference chips flow naturally in narrow sheets.
struct FlowLayout: Layout {
var spacing: CGFloat = 6
func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
let maxWidth = proposal.width ?? .infinity
var x: CGFloat = 0
var y: CGFloat = 0
var rowHeight: CGFloat = 0
var usedWidth: CGFloat = 0
for subview in subviews {
let size = subview.sizeThatFits(.unspecified)
if x > 0, x + size.width > maxWidth {
x = 0
y += rowHeight + spacing
rowHeight = 0
}
x += size.width + spacing
usedWidth = max(usedWidth, x - spacing)
rowHeight = max(rowHeight, size.height)
}
return CGSize(width: min(usedWidth, maxWidth == .infinity ? usedWidth : maxWidth),
height: y + rowHeight)
}
func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
var x = bounds.minX
var y = bounds.minY
var rowHeight: CGFloat = 0
for subview in subviews {
let size = subview.sizeThatFits(.unspecified)
if x > bounds.minX, x + size.width > bounds.maxX {
x = bounds.minX
y += rowHeight + spacing
rowHeight = 0
}
subview.place(at: CGPoint(x: x, y: y), proposal: ProposedViewSize(size))
x += size.width + spacing
rowHeight = max(rowHeight, size.height)
}
}
}
@@ -0,0 +1,143 @@
import SwiftUI
import LektorenPlanCore
struct PlanResultSheet: View {
@EnvironmentObject private var model: PlanModel
@Environment(\.dismiss) private var dismiss
var body: some View {
VStack(spacing: 0) {
if let result = model.planResult {
SheetHeader(
icon: result.unfilled.isEmpty ? "checkmark.seal" : "exclamationmark.triangle",
title: result.unfilled.isEmpty ? "Planung abgeschlossen" : "Planung mit Lücken",
subtitle: result.message,
tint: result.unfilled.isEmpty ? LP.success : LP.open
)
Hairline()
ScrollView {
VStack(alignment: .leading, spacing: 18) {
HStack(spacing: 12) {
resultTile(
icon: "checkmark.circle",
value: "\(result.filledCount)",
label: "neu besetzte Dienste",
tint: LP.success
)
resultTile(
icon: "circle.dashed",
value: "\(result.unfilled.count)",
label: "offene Dienste",
tint: LP.open
)
resultTile(
icon: "person.2",
value: "\(model.stats.assignmentCount)",
label: "Einsätze im Zeitraum",
tint: LP.accent
)
}
if result.unfilled.isEmpty {
HStack(alignment: .top, spacing: 9) {
Image(systemName: "sparkles")
.foregroundStyle(LP.gold)
Text("Alle Dienste im gewählten Zeitraum konnten unter Berücksichtigung von Abwesenheiten, Einsatztagen und Monatslimits besetzt werden. Gesperrte Einsätze wurden nicht verändert.")
.font(.system(size: 10.5))
.foregroundStyle(LP.inkSecondary)
.fixedSize(horizontal: false, vertical: true)
}
.padding(12)
.background(RoundedRectangle(cornerRadius: 10).fill(LP.successSoft.opacity(0.6)))
} else {
FormSection(
title: "Nicht besetzbare Dienste",
subtitle: "Die genannten Gründe zeigen, warum keine geeignete Person gefunden wurde."
) {
VStack(spacing: 0) {
ForEach(Array(result.unfilled.enumerated()), id: \.element.id) { index, slot in
HStack(alignment: .top, spacing: 10) {
VStack(alignment: .leading, spacing: 1) {
Text(DayMath.shortWeekdayName(slot.service.date).uppercased())
.font(.system(size: 7.5, weight: .bold, design: .rounded))
.foregroundStyle(LP.inkTertiary)
Text("\(DayMath.dayNumber(slot.service.date)).")
.font(.system(size: 14, weight: .semibold, design: .serif))
.foregroundStyle(LP.ink)
Text(DayMath.shortMonthName(slot.service.date))
.font(.system(size: 8))
.foregroundStyle(LP.inkTertiary)
}
.frame(width: 34)
VStack(alignment: .leading, spacing: 2) {
HStack(spacing: 5) {
Text(slot.service.timeLabel)
.font(.system(size: 9.5, weight: .bold, design: .rounded))
.foregroundStyle(LP.accent)
Text(slot.service.title)
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.ink)
}
Text("\(slot.churchName) · \(slot.role.title)")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
Text(slot.reason)
.font(.system(size: 9.5))
.foregroundStyle(LP.open)
}
Spacer()
}
.padding(.horizontal, 10)
.padding(.vertical, 7)
.background(index % 2 == 0 ? LP.cardMuted.opacity(0.4) : Color.clear)
}
}
.clipShape(RoundedRectangle(cornerRadius: 9))
.overlay(RoundedRectangle(cornerRadius: 9).strokeBorder(LP.line.opacity(0.55), lineWidth: 0.8))
}
}
}
.padding(22)
}
SheetFooter {
Spacer()
SecondaryActionButton(title: "Statistik ansehen", icon: "chart.xyaxis.line") {
model.planResult = nil
model.section = .statistics
dismiss()
}
PrimaryActionButton(title: "Schließen", icon: "checkmark") {
model.planResult = nil
dismiss()
}
}
} else {
ProgressView()
.frame(maxWidth: .infinity, maxHeight: .infinity)
}
}
.sheetSurface(width: 620, height: 560)
}
private func resultTile(icon: String, value: String, label: String, tint: Color) -> some View {
VStack(alignment: .leading, spacing: 4) {
Image(systemName: icon)
.font(.system(size: 13, weight: .semibold))
.foregroundStyle(tint)
Text(value)
.font(.system(size: 22, weight: .bold, design: .rounded))
.foregroundStyle(LP.ink)
Text(label)
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
}
.frame(maxWidth: .infinity, alignment: .leading)
.padding(12)
.background(RoundedRectangle(cornerRadius: 10).fill(LP.cardMuted))
.overlay(RoundedRectangle(cornerRadius: 10).strokeBorder(LP.line.opacity(0.55), lineWidth: 0.8))
}
}
@@ -0,0 +1,721 @@
import SwiftUI
import LektorenPlanCore
struct PlanningView: View {
@EnvironmentObject private var model: PlanModel
@State private var showReplanConfirm = false
@State private var showSyncHelp = false
var body: some View {
VStack(spacing: 14) {
header
kpiRow
TimelineRangePicker()
CalendarTable()
.frame(maxHeight: .infinity)
}
.padding(.horizontal, 22)
.padding(.top, 30)
.padding(.bottom, 18)
.confirmationDialog(
"Gesamten Zeitraum neu planen?",
isPresented: $showReplanConfirm,
titleVisibility: .visible
) {
Button("Neu planen", role: .destructive) {
_ = model.autoPlan(replaceExisting: true)
}
Button("Abbrechen", role: .cancel) {}
} message: {
Text("Nicht gesperrte Zuweisungen im Zeitraum werden verworfen und fair neu verteilt. Gesperrte Einsätze bleiben erhalten.")
}
}
private var header: some View {
PageHeader(
eyebrow: "Pfarreiengemeinschaft Bad Godesberg",
title: "Gottesdienste im Blick",
subtitle: "Lektoren, Kommunionhelfer und liturgischer Kalender · Erzbistum Köln"
) {
HStack(spacing: 8) {
if model.isSyncing {
HStack(spacing: 6) {
ProgressView().controlSize(.small)
Text(model.syncMessage.isEmpty ? "Kalender…" : model.syncMessage)
.font(.system(size: 10.5))
.foregroundStyle(LP.inkSecondary)
}
.padding(.horizontal, 10)
}
SecondaryActionButton(title: "Kalender", icon: "arrow.triangle.2.circlepath") {
Task { await model.syncLiturgy() }
}
.help("Liturgischen Kalender für \(rangeYearsLabel) von www.eucharistiefeier.de aktualisieren")
.disabled(model.isSyncing)
SecondaryActionButton(title: "PDF", icon: "doc.richtext") {
model.createPDFPreview()
}
.help("Planung als PDF ansehen, sichern oder drucken")
Menu {
Button {
_ = model.autoPlan(replaceExisting: false)
} label: {
Label("Offene Dienste besetzen", systemImage: "wand.and.stars")
}
Button {
showReplanConfirm = true
} label: {
Label("Zeitraum neu planen…", systemImage: "arrow.triangle.2.circlepath")
}
} label: {
HStack(spacing: 7) {
Image(systemName: "wand.and.stars")
.font(.system(size: 11, weight: .bold))
Text("Automatisch planen")
.font(.system(size: 12, weight: .semibold))
Image(systemName: "chevron.down")
.font(.system(size: 8, weight: .bold))
.opacity(0.7)
}
.foregroundStyle(.white)
.padding(.horizontal, 14)
.padding(.vertical, 8)
.background(
RoundedRectangle(cornerRadius: 9, style: .continuous)
.fill(LinearGradient(colors: [LP.accent, LP.accent.opacity(0.82)],
startPoint: .top, endPoint: .bottom))
.shadow(color: LP.accent.opacity(0.20), radius: 5, y: 2)
)
}
.menuStyle(.borderlessButton)
.fixedSize()
.help("Alle offenen Dienste im Zeitraum automatisch besetzen")
}
}
}
private var rangeYearsLabel: String {
let years = Array(Set(model.range.days.map { DayMath.year($0) })).sorted()
return years.map(String.init).joined(separator: ", ")
}
private var kpiRow: some View {
SurfaceCard(padding: 14, radius: 14, background: LP.card.opacity(0.88)) {
HStack(spacing: 0) {
StatPill(icon: "building.columns", value: "\(model.stats.serviceCount)", label: "Gottesdienste")
divider
StatPill(icon: "checkmark.seal", value: "\(model.stats.assignmentCount)", label: "Einsätze", tint: LP.success)
divider
StatPill(icon: "person.crop.circle.badge.exclamationmark", value: "\(model.stats.openSlots)", label: "Offene Dienste", tint: LP.open)
divider
StatPill(icon: "person.2", value: "\(model.people.filter(\.active).count)", label: "Aktive Personen", tint: LP.burgundy)
divider
StatPill(icon: "cross.case", value: "\(model.stats.sundayServiceCount)", label: "Sonntagsgottesdienste", tint: LP.gold)
Spacer(minLength: 12)
VStack(alignment: .trailing, spacing: 4) {
Text("BESETZUNGSQUOTE")
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.tracking(1)
.foregroundStyle(LP.inkTertiary)
HStack(alignment: .firstTextBaseline, spacing: 4) {
Text("\(Int(model.stats.coverageRate * 100))")
.font(.system(size: 24, weight: .bold, design: .rounded))
.foregroundStyle(model.stats.openSlots == 0 ? LP.success : LP.ink)
Text("%")
.font(.system(size: 12, weight: .semibold, design: .rounded))
.foregroundStyle(LP.inkTertiary)
}
ProgressView(value: model.stats.coverageRate)
.progressViewStyle(.linear)
.tint(model.stats.openSlots == 0 ? LP.success : LP.accent)
.frame(width: 100)
}
}
}
}
private var divider: some View {
Rectangle()
.fill(LP.line.opacity(0.55))
.frame(width: 1, height: 32)
.padding(.horizontal, 14)
}
}
// MARK: - Calendar table
private struct CalendarTable: View {
@EnvironmentObject private var model: PlanModel
private let gap: CGFloat = 8
private let horizontalPadding: CGFloat = 12
private let dateWidth: CGFloat = 86
private let liturgyWidth: CGFloat = 240
private let churchMinWidth: CGFloat = 186
var body: some View {
SurfaceCard(padding: 0, radius: 16, background: LP.card) {
VStack(spacing: 0) {
toolbar
Hairline()
GeometryReader { geo in
let minimum = horizontalPadding * 2 + dateWidth + liturgyWidth + churchMinWidth * 4 + gap * 5
let width = max(geo.size.width, minimum)
let churchWidth = (width - horizontalPadding * 2 - dateWidth - liturgyWidth - gap * 5) / 4
ScrollView(.horizontal, showsIndicators: false) {
VStack(spacing: 0) {
columnHeader(churchWidth: churchWidth)
Hairline()
if model.filteredRows.isEmpty {
EmptyStateView(
icon: "calendar",
title: "Keine Tage im Filter",
message: "Für diesen Zeitraum und Filter sind keine Einträge vorhanden."
)
.frame(maxWidth: .infinity, maxHeight: .infinity)
} else {
ScrollView(.vertical) {
LazyVStack(spacing: 0, pinnedViews: []) {
ForEach(monthGroups) { group in
monthHeader(group, churchWidth: churchWidth)
ForEach(group.rows) { row in
DayRow(
row: row,
churchWidth: churchWidth,
dateWidth: dateWidth,
liturgyWidth: liturgyWidth,
gap: gap,
horizontalPadding: horizontalPadding
)
}
}
}
.padding(.bottom, 10)
}
}
}
.frame(width: width, height: geo.size.height, alignment: .top)
}
}
}
}
}
private var toolbar: some View {
HStack(spacing: 12) {
HStack(spacing: 2) {
ForEach(PlanFilter.allCases) { filter in
Button {
withAnimation(.easeInOut(duration: 0.18)) {
model.filter = filter
}
} label: {
HStack(spacing: 4) {
Text(filter.title)
.font(.system(size: 10.5, weight: .semibold))
if filter == .open, model.stats.openSlots > 0 {
Text("\(model.stats.openSlots)")
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.foregroundStyle(.white)
.padding(.horizontal, 4)
.padding(.vertical, 1)
.background(Capsule().fill(LP.open))
}
}
.foregroundStyle(model.filter == filter ? Color.white : LP.inkSecondary)
.padding(.horizontal, 10)
.padding(.vertical, 5)
.background(
Capsule().fill(model.filter == filter ? LP.accent : Color.clear)
)
}
.buttonStyle(.plain)
}
}
.padding(3)
.background(Capsule().fill(LP.cardMuted))
.overlay(Capsule().strokeBorder(LP.line.opacity(0.55), lineWidth: 0.7))
Toggle(isOn: Binding(
get: { model.showOnlySundaysAndFeasts },
set: { model.setSundayFilter($0) }
)) {
Text("Sonn- & Feiertage")
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.inkSecondary)
}
.toggleStyle(.checkbox)
searchField
Spacer(minLength: 8)
legend
Text("\(model.filteredRows.count) Tage")
.font(.system(size: 9.5, weight: .medium, design: .rounded))
.foregroundStyle(LP.inkTertiary)
.padding(.horizontal, 8)
.padding(.vertical, 4)
.background(Capsule().fill(LP.cardMuted))
}
.padding(.horizontal, 14)
.padding(.vertical, 10)
}
private var searchField: some View {
HStack(spacing: 5) {
Image(systemName: "magnifyingglass")
.font(.system(size: 10, weight: .medium))
.foregroundStyle(LP.inkTertiary)
TextField("Person, Ort, Lesung…", text: $model.searchText)
.textFieldStyle(.plain)
.font(.system(size: 10.5))
.frame(width: 150)
if !model.searchText.isEmpty {
Button {
model.searchText = ""
} label: {
Image(systemName: "xmark.circle.fill")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
}
.buttonStyle(.plain)
}
}
.padding(.horizontal, 8)
.padding(.vertical, 5)
.background(RoundedRectangle(cornerRadius: 7).fill(LP.cardMuted))
.overlay(RoundedRectangle(cornerRadius: 7).strokeBorder(LP.line.opacity(0.6), lineWidth: 0.7))
}
private var legend: some View {
HStack(spacing: 9) {
legendItem(color: LP.sundayWash, text: "Sonntag")
legendItem(color: LP.feastWash, text: "Hochfest")
HStack(spacing: 3) {
Image(systemName: "circle.dashed")
.font(.system(size: 8))
.foregroundStyle(LP.open)
Text("offen")
}
.font(.system(size: 8.5, weight: .medium))
.foregroundStyle(LP.inkTertiary)
}
}
private func legendItem(color: Color, text: String) -> some View {
HStack(spacing: 3) {
RoundedRectangle(cornerRadius: 2).fill(color).frame(width: 8, height: 8)
.overlay(RoundedRectangle(cornerRadius: 2).strokeBorder(LP.line.opacity(0.5), lineWidth: 0.5))
Text(text)
}
.font(.system(size: 8.5, weight: .medium))
.foregroundStyle(LP.inkTertiary)
}
private func columnHeader(churchWidth: CGFloat) -> some View {
HStack(spacing: gap) {
Text("TAG")
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.tracking(1.1)
.foregroundStyle(LP.inkTertiary)
.frame(width: dateWidth, alignment: .leading)
Text("LITURGIE & LESUNGEN")
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.tracking(1.1)
.foregroundStyle(LP.inkTertiary)
.frame(width: liturgyWidth, alignment: .leading)
ForEach(model.churches) { church in
ChurchColumnHeader(church: church, width: churchWidth)
}
}
.padding(.horizontal, horizontalPadding)
.padding(.vertical, 10)
.background(LP.cardMuted.opacity(0.55))
}
private func monthHeader(_ group: MonthGroup, churchWidth: CGFloat) -> some View {
HStack(spacing: 8) {
Text(group.title.uppercased())
.font(.system(size: 9.5, weight: .bold, design: .rounded))
.tracking(1.1)
.foregroundStyle(LP.inkSecondary)
Hairline()
Text("\(group.serviceCount) Gottesdienste")
.font(.system(size: 8.5, weight: .medium, design: .rounded))
.foregroundStyle(LP.inkTertiary)
if group.openSlots > 0 {
Text("\(group.openSlots) offen")
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.foregroundStyle(LP.open)
}
}
.padding(.horizontal, horizontalPadding)
.padding(.vertical, 7)
.frame(width: horizontalPadding * 2 + dateWidth + liturgyWidth + churchWidth * 4 + gap * 5, alignment: .leading)
.background(LP.paperDeep.opacity(0.55))
.overlay(alignment: .top) { Hairline() }
.overlay(alignment: .bottom) { Hairline().opacity(0.55) }
}
private struct MonthGroup: Identifiable {
var id: String
var title: String
var rows: [DayPlanRow]
var serviceCount: Int
var openSlots: Int
}
private var monthGroups: [MonthGroup] {
var groups: [MonthGroup] = []
for row in model.filteredRows {
let key = DayMath.monthKey(row.date)
if groups.last?.id == key {
groups[groups.count - 1].rows.append(row)
groups[groups.count - 1].serviceCount += row.services.count
groups[groups.count - 1].openSlots += row.openSlots
} else {
let title = "\(DayMath.monthName(row.date)) \(DayMath.year(row.date))"
groups.append(MonthGroup(
id: key,
title: title,
rows: [row],
serviceCount: row.services.count,
openSlots: row.openSlots
))
}
}
return groups
}
}
private struct ChurchColumnHeader: View {
var church: Church
var width: CGFloat
var body: some View {
HStack(spacing: 8) {
ChurchGlyph(symbol: church.symbol, tint: LP.churchColor(church.colorHex), lineWidth: 1.5)
.frame(width: 34, height: 25)
VStack(alignment: .leading, spacing: 2) {
Text(church.name)
.font(LP.serifSubhead)
.foregroundStyle(LP.ink)
.lineLimit(1)
Text(church.address)
.font(.system(size: 8, weight: .medium))
.foregroundStyle(LP.inkTertiary)
.lineLimit(1)
}
Spacer(minLength: 0)
Image(systemName: "info.circle")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary.opacity(0.65))
}
.frame(width: width, alignment: .leading)
.help("\(church.name)\n\(church.address)\n\(church.notes)\n\n\(church.symbol.caption)")
}
}
private struct DayRow: View {
@EnvironmentObject private var model: PlanModel
var row: DayPlanRow
var churchWidth: CGFloat
var dateWidth: CGFloat
var liturgyWidth: CGFloat
var gap: CGFloat
var horizontalPadding: CGFloat
private var day: LiturgicalDay? { row.liturgicalDay }
private var isHighFeast: Bool { day?.isHighFeast == true }
private var isFeast: Bool { day?.isFeast == true }
private var isSunday: Bool { day?.isSunday == true || DayMath.isSunday(row.date) }
private var isSpecialDay: Bool { isSunday || isFeast || day?.isObligation == true }
var body: some View {
HStack(alignment: .top, spacing: gap) {
dateCell
.frame(width: dateWidth, alignment: .leading)
liturgyCell
.frame(width: liturgyWidth, alignment: .leading)
ForEach(model.churches) { church in
churchCell(church: church)
.frame(width: churchWidth, alignment: .topLeading)
}
}
.padding(.horizontal, horizontalPadding)
.padding(.vertical, 9)
.background(background)
.overlay(alignment: .bottom) {
Rectangle()
.fill(LP.line.opacity(isSpecialDay ? 0.55 : 0.32))
.frame(height: 0.7)
}
}
private var background: some View {
Group {
if isHighFeast {
LinearGradient(colors: [LP.feastWash, LP.sundayWash.opacity(0.6)],
startPoint: .leading, endPoint: .trailing)
} else if isSunday || day?.isObligation == true {
LP.sundayWash.opacity(0.72)
} else if isFeast {
LP.feastWash.opacity(0.42)
} else {
Color.clear
}
}
}
private var accentColor: Color {
guard let day else { return LP.line }
return LP.liturgicalColor(day.color)
}
private var dateCell: some View {
HStack(spacing: 8) {
RoundedRectangle(cornerRadius: 2)
.fill(accentColor)
.frame(width: 3, height: 46)
.opacity(isSpecialDay ? 1 : 0.35)
VStack(alignment: .leading, spacing: 1) {
Text(DayMath.shortWeekdayName(row.date).uppercased())
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.tracking(0.8)
.foregroundStyle(isSunday ? LP.burgundy : LP.inkTertiary)
HStack(alignment: .firstTextBaseline, spacing: 3) {
Text("\(DayMath.dayNumber(row.date))")
.font(.system(size: 24, weight: .semibold, design: .serif))
.foregroundStyle(isHighFeast ? LP.gold : (isSunday ? LP.burgundy : LP.ink))
Text(DayMath.shortMonthName(row.date))
.font(.system(size: 9, weight: .medium, design: .rounded))
.foregroundStyle(LP.inkTertiary)
}
if isSunday {
Text("SONNTAG")
.font(.system(size: 7, weight: .bold, design: .rounded))
.tracking(0.8)
.foregroundStyle(LP.burgundy.opacity(0.8))
} else if day?.isObligation == true {
Text("GEBOTEN")
.font(.system(size: 7, weight: .bold, design: .rounded))
.tracking(0.8)
.foregroundStyle(LP.burgundy.opacity(0.8))
} else {
Text(DayMath.yearString(row.date))
.font(.system(size: 7.5, weight: .medium, design: .rounded))
.foregroundStyle(LP.inkTertiary.opacity(0.8))
}
}
}
}
private var liturgyCell: some View {
VStack(alignment: .leading, spacing: 4) {
HStack(spacing: 5) {
if let day {
RankBadge(day: day)
if day.rank == .weekday, !day.isSunday, !day.isObligation {
Text(day.season.shortTitle.uppercased())
.font(.system(size: 7.5, weight: .bold, design: .rounded))
.tracking(0.5)
.foregroundStyle(LP.inkTertiary)
}
}
Spacer(minLength: 0)
if let day, day.isFeast {
Image(systemName: day.symbol.symbolName)
.font(.system(size: 10, weight: .medium))
.foregroundStyle(isHighFeast ? LP.gold : LP.burgundy.opacity(0.7))
.help("\(day.symbol.label) · \(day.rank.label)")
}
}
Text(day?.displayTitle ?? "—")
.font(.system(size: 13.5, weight: isSpecialDay ? .semibold : .regular, design: .serif))
.foregroundStyle(isHighFeast ? LP.ink : (isSunday ? LP.burgundy : LP.ink))
.lineLimit(2)
.fixedSize(horizontal: false, vertical: true)
if let day, !day.readings.isEmpty {
HStack(alignment: .top, spacing: 4) {
Image(systemName: "book.closed")
.font(.system(size: 7.5, weight: .medium))
.foregroundStyle(LP.inkTertiary)
.padding(.top, 1)
Text(day.readings.shortLabel)
.font(.system(size: 8.8, weight: .regular))
.foregroundStyle(LP.inkSecondary)
.lineLimit(2)
.fixedSize(horizontal: false, vertical: true)
}
} else if day?.title == "Karsamstag" {
Text("Keine Eucharistiefeier am Tag")
.font(.system(size: 8.5, weight: .medium))
.foregroundStyle(LP.inkTertiary)
}
}
.padding(.top, 1)
.help(liturgyHelp)
}
private var liturgyHelp: String {
guard let day else { return DayMath.longString(row.date) }
var parts = ["\(DayMath.longString(row.date))", day.title]
if !day.remark.isEmpty { parts.append(day.remark) }
if !day.badgeText.isEmpty { parts.append(day.badgeText) }
parts.append("Liturgische Farbe: \(day.color.label)")
if !day.readings.isEmpty { parts.append(day.readings.fullLabel) }
if day.isObligation { parts.append("Gebotener Feiertag") }
return parts.joined(separator: "\n")
}
private func churchCell(church: Church) -> some View {
let services = row.services.filter { $0.church.id == church.id }
return Group {
if services.isEmpty {
HStack {
Spacer()
Image(systemName: "circle.dotted")
.font(.system(size: 8))
.foregroundStyle(LP.inkTertiary.opacity(0.18))
Spacer()
}
.frame(minHeight: 58)
} else {
VStack(spacing: 5) {
ForEach(services) { service in
ServiceCard(service: service, liturgy: day)
}
}
}
}
}
}
private struct ServiceCard: View {
@EnvironmentObject private var model: PlanModel
var service: ServiceWithAssignments
var liturgy: LiturgicalDay?
private var churchColor: Color { LP.churchColor(service.church.colorHex) }
var body: some View {
Button {
model.serviceDetail = ServiceDetailRequest(serviceID: service.service.id)
} label: {
VStack(alignment: .leading, spacing: 4) {
HStack(spacing: 5) {
Text(service.service.timeLabel)
.font(.system(size: 10.5, weight: .bold, design: .rounded))
.foregroundStyle(churchColor)
Text(service.service.title)
.font(.system(size: 9.5, weight: .semibold))
.foregroundStyle(LP.ink)
.lineLimit(1)
if service.service.kind == .special {
Text("S")
.font(.system(size: 7, weight: .black, design: .rounded))
.foregroundStyle(.white)
.frame(width: 12, height: 12)
.background(Circle().fill(LP.burgundy))
}
Spacer(minLength: 0)
if service.isFullyStaffed {
Image(systemName: "checkmark.circle.fill")
.font(.system(size: 9))
.foregroundStyle(LP.success.opacity(0.8))
} else {
Text("\(service.openSlots)")
.font(.system(size: 7.5, weight: .bold, design: .rounded))
.foregroundStyle(LP.open)
.padding(.horizontal, 4)
.padding(.vertical, 1)
.background(Capsule().fill(LP.openSoft))
}
}
ForEach(Role.allCases) { role in
if service.service.requiredCount(for: role) > 0 {
roleLine(role: role)
}
}
}
.padding(.horizontal, 7)
.padding(.vertical, 6)
.frame(maxWidth: .infinity, alignment: .leading)
.background(
RoundedRectangle(cornerRadius: 8, style: .continuous)
.fill(service.service.kind == .special ? LP.burgundySoft.opacity(0.55) : LP.card)
)
.overlay(
RoundedRectangle(cornerRadius: 8, style: .continuous)
.strokeBorder(service.service.kind == .special ? LP.burgundy.opacity(0.28) : LP.line.opacity(0.55), lineWidth: 0.8)
)
.overlay(alignment: .leading) {
RoundedRectangle(cornerRadius: 1)
.fill(churchColor.opacity(0.55))
.frame(width: 2.2)
.padding(.vertical, 6)
}
}
.buttonStyle(.plain)
.help(helpText)
}
private func roleLine(role: Role) -> some View {
let assigned = service.assignments(for: role)
let open = service.openSlots(for: role)
return HStack(spacing: 3) {
Image(systemName: role.symbolName)
.font(.system(size: 7))
.foregroundStyle(role == .lector ? LP.accent : LP.burgundy)
.frame(width: 10)
if assigned.isEmpty {
Text(open > 1 ? "\(open)× \(role.title) offen" : "\(role.title) offen")
.font(.system(size: 8.5, weight: .medium))
.foregroundStyle(LP.open)
.padding(.horizontal, 4)
.padding(.vertical, 1)
.background(Capsule().fill(LP.openSoft.opacity(0.7)))
} else {
ForEach(assigned) { assignment in
if let person = model.peopleByID[assignment.personID] {
PersonMiniChip(person: person, role: role, color: churchColor)
}
}
if open > 0 {
Text("+\(open)")
.font(.system(size: 8, weight: .bold, design: .rounded))
.foregroundStyle(LP.open)
}
}
Spacer(minLength: 0)
}
}
private var helpText: String {
var lines = [
"\(service.church.name) · \(DayMath.longString(service.service.date)) · \(service.service.timeLabel)",
service.service.title
]
for role in Role.allCases {
let names = service.assignments(for: role).compactMap { model.peopleByID[$0.personID]?.fullName }
if service.service.requiredCount(for: role) > 0 {
lines.append("\(role.title): \(names.isEmpty ? "offen" : names.joined(separator: ", "))")
}
}
if let liturgy {
if !liturgy.readings.isEmpty { lines.append(liturgy.readings.shortLabel) }
if !liturgy.remark.isEmpty { lines.append(liturgy.remark) }
}
if !service.service.notes.isEmpty { lines.append(service.service.notes) }
lines.append("Klicken zum Bearbeiten")
return lines.joined(separator: "\n")
}
}
private extension DayMath {
static func yearString(_ date: Date) -> String {
String(year(date))
}
}
@@ -0,0 +1,448 @@
import SwiftUI
import LektorenPlanCore
struct ServiceDetailSheet: View {
@EnvironmentObject private var model: PlanModel
@Environment(\.dismiss) private var dismiss
let serviceID: String
@State private var selectedRole: Role = .lector
@State private var confirmDelete = false
private var item: ServiceWithAssignments? {
model.serviceWithAssignments(id: serviceID)
}
var body: some View {
VStack(spacing: 0) {
if let item {
header(item: item)
Hairline()
HStack(alignment: .top, spacing: 0) {
leftColumn(item: item)
.frame(width: 330)
Rectangle().fill(LP.line.opacity(0.6)).frame(width: 1)
rightColumn(item: item)
.frame(maxWidth: .infinity)
}
SheetFooter {
if item.service.kind == .special {
Button {
model.serviceDetail = nil
model.specialServiceEditor = SpecialServiceRequest(
churchID: item.service.churchID,
date: item.service.date,
service: item.service
)
} label: {
HStack(spacing: 5) {
Image(systemName: "pencil")
Text("Bearbeiten")
}
.font(.system(size: 11.5, weight: .medium))
.foregroundStyle(LP.inkSecondary)
}
.buttonStyle(.plain)
Button {
confirmDelete = true
} label: {
Image(systemName: "trash")
.font(.system(size: 11.5, weight: .medium))
.foregroundStyle(LP.danger)
}
.buttonStyle(.plain)
.help("Sondergottesdienst löschen")
}
Spacer()
SecondaryActionButton(title: "Schließen", icon: "xmark") { dismiss() }
PrimaryActionButton(title: "Automatisch besetzen", icon: "wand.and.stars") {
model.autoFill(serviceID: serviceID)
}
}
} else {
VStack(spacing: 12) {
ProgressView()
Text("Gottesdienst wird geladen…")
.font(.system(size: 11))
.foregroundStyle(LP.inkTertiary)
}
.frame(maxWidth: .infinity, maxHeight: .infinity)
}
}
.sheetSurface(width: 820, height: 660)
.onAppear {
if let item, item.service.lectorsNeeded == 0 {
selectedRole = .helper
}
}
.confirmationDialog(
"Sondergottesdienst löschen?",
isPresented: $confirmDelete,
titleVisibility: .visible
) {
Button("Löschen", role: .destructive) {
if let item {
model.deleteService(item.service)
}
dismiss()
}
Button("Abbrechen", role: .cancel) {}
} message: {
Text("Der Termin und alle zugehörigen Einsätze werden entfernt.")
}
}
// MARK: - Header
private func header(item: ServiceWithAssignments) -> some View {
let churchColor = LP.churchColor(item.church.colorHex)
let day = model.liturgicalDays[item.service.dateKey]
return HStack(alignment: .top, spacing: 14) {
ZStack {
RoundedRectangle(cornerRadius: 12, style: .continuous)
.fill(churchColor.opacity(0.10))
ChurchGlyph(symbol: item.church.symbol, tint: churchColor, lineWidth: 1.5, showGround: false)
.padding(7)
}
.frame(width: 52, height: 52)
.overlay(RoundedRectangle(cornerRadius: 12, style: .continuous)
.strokeBorder(churchColor.opacity(0.22), lineWidth: 0.8))
VStack(alignment: .leading, spacing: 3) {
HStack(spacing: 6) {
Text(item.church.name)
.font(.system(size: 10, weight: .bold, design: .rounded))
.tracking(0.8)
.foregroundStyle(churchColor)
if item.service.kind == .special {
TinyBadge(text: "SONDERGOTTESDIENST", color: LP.burgundy, filled: true)
}
if !item.isFullyStaffed {
TinyBadge(text: "\(item.openSlots) OFFEN", color: LP.open, filled: true)
}
}
Text(item.service.title)
.font(LP.serifHeadline)
.foregroundStyle(LP.ink)
Text("\(DayMath.longString(item.service.date)) · \(item.service.timeLabel) Uhr")
.font(.system(size: 10.5))
.foregroundStyle(LP.inkSecondary)
if let day {
Text(day.displayTitle + (day.remark.isEmpty ? "" : " · \(day.remark)"))
.font(.system(size: 9.5))
.foregroundStyle(LP.inkTertiary)
}
}
Spacer(minLength: 12)
VStack(alignment: .trailing, spacing: 5) {
HStack(spacing: 10) {
requirementBadge(role: .lector, needed: item.service.lectorsNeeded)
requirementBadge(role: .helper, needed: item.service.helpersNeeded)
}
if item.service.locked {
Label("Gesperrt", systemImage: "lock.fill")
.font(.system(size: 9, weight: .medium))
.foregroundStyle(LP.inkTertiary)
}
}
}
.padding(.horizontal, 22)
.padding(.vertical, 18)
}
private func requirementBadge(role: Role, needed: Int) -> some View {
HStack(spacing: 4) {
Image(systemName: role.symbolName)
.font(.system(size: 9, weight: .semibold))
Text("\(needed)×")
.font(.system(size: 10, weight: .bold, design: .rounded))
}
.foregroundStyle(needed == 0 ? LP.inkTertiary : (role == .lector ? LP.accent : LP.burgundy))
.padding(.horizontal, 7)
.padding(.vertical, 3)
.background(Capsule().fill((role == .lector ? LP.accent : LP.burgundy).opacity(needed == 0 ? 0.04 : 0.10)))
}
// MARK: - Left column
private func leftColumn(item: ServiceWithAssignments) -> some View {
ScrollView {
VStack(alignment: .leading, spacing: 18) {
if let day = model.liturgicalDays[item.service.dateKey] {
liturgyCard(day)
}
VStack(alignment: .leading, spacing: 9) {
SectionLabel(title: "Aktuelle Besetzung")
ForEach(Role.allCases) { role in
let needed = item.service.requiredCount(for: role)
if needed > 0 {
assignmentGroup(item: item, role: role, needed: needed)
}
}
}
if !item.service.notes.isEmpty {
VStack(alignment: .leading, spacing: 5) {
SectionLabel(title: "Notiz")
Text(item.service.notes)
.font(.system(size: 10.5))
.foregroundStyle(LP.inkSecondary)
.fixedSize(horizontal: false, vertical: true)
}
}
}
.padding(20)
}
}
private func liturgyCard(_ day: LiturgicalDay) -> some View {
VStack(alignment: .leading, spacing: 7) {
HStack(spacing: 6) {
Image(systemName: day.symbol.symbolName)
.font(.system(size: 11, weight: .medium))
.foregroundStyle(day.isHighFeast ? LP.gold : LP.burgundy)
Text("LITURGIE DES TAGES")
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.tracking(1)
.foregroundStyle(LP.inkTertiary)
Spacer()
if day.isHighFeast {
TinyBadge(text: "HOCHFEST", color: LP.gold)
}
}
Text(day.displayTitle)
.font(LP.serifSubhead)
.foregroundStyle(LP.ink)
if !day.readings.isEmpty {
VStack(alignment: .leading, spacing: 4) {
readingLine("1. Lesung", day.readings.first)
readingLine("Psalm", day.readings.psalm)
readingLine("2. Lesung", day.readings.second)
readingLine("Evangelium", day.readings.gospel)
}
} else {
Text("Für diesen Tag sind keine Lesungen hinterlegt.")
.font(.system(size: 9.5))
.foregroundStyle(LP.inkTertiary)
}
Text(day.source)
.font(.system(size: 7.5))
.foregroundStyle(LP.inkTertiary.opacity(0.8))
}
.padding(12)
.frame(maxWidth: .infinity, alignment: .leading)
.background(RoundedRectangle(cornerRadius: 10).fill(LP.cardMuted))
.overlay(RoundedRectangle(cornerRadius: 10).strokeBorder(LP.line.opacity(0.6), lineWidth: 0.8))
}
private func readingLine(_ label: String, _ value: String) -> some View {
if value.isEmpty {
return AnyView(EmptyView())
}
return AnyView(HStack(alignment: .top, spacing: 5) {
Text(label)
.font(.system(size: 8.5, weight: .semibold))
.foregroundStyle(LP.inkTertiary)
.frame(width: 62, alignment: .leading)
Text(value)
.font(.system(size: 9.5))
.foregroundStyle(LP.inkSecondary)
.fixedSize(horizontal: false, vertical: true)
})
}
private func assignmentGroup(item: ServiceWithAssignments, role: Role, needed: Int) -> some View {
let assigned = item.assignments(for: role)
return VStack(alignment: .leading, spacing: 6) {
HStack(spacing: 5) {
RepBadge(role: role)
Text("\(assigned.count) von \(needed)")
.font(.system(size: 9, weight: .medium, design: .rounded))
.foregroundStyle(assigned.count >= needed ? LP.success : LP.open)
Spacer()
}
if assigned.isEmpty {
Text("Noch offen")
.font(.system(size: 10))
.foregroundStyle(LP.open)
.padding(.leading, 2)
} else {
ForEach(assigned) { assignment in
if let person = model.peopleByID[assignment.personID] {
HStack(spacing: 8) {
Avatar(initials: person.initials, color: LP.churchColor(item.church.colorHex), size: 24)
VStack(alignment: .leading, spacing: 1) {
Text(person.fullName)
.font(.system(size: 11, weight: .medium))
.foregroundStyle(LP.ink)
Text(person.roleLabel)
.font(.system(size: 8.5))
.foregroundStyle(LP.inkTertiary)
}
Spacer()
Button {
model.toggleAssignmentLock(assignment)
} label: {
Image(systemName: assignment.locked ? "lock.fill" : "lock.open")
.font(.system(size: 9.5))
.foregroundStyle(assignment.locked ? LP.accent : LP.inkTertiary)
}
.buttonStyle(.plain)
.help(assignment.locked ? "Sperre aufheben" : "Einsatz sperren")
Button {
model.assign(serviceID: item.service.id, role: role, personID: nil)
} label: {
Image(systemName: "xmark.circle.fill")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
}
.buttonStyle(.plain)
.help("Einsatz entfernen")
}
.padding(.horizontal, 8)
.padding(.vertical, 5)
.background(RoundedRectangle(cornerRadius: 8).fill(LP.card))
.overlay(RoundedRectangle(cornerRadius: 8).strokeBorder(LP.line.opacity(0.6), lineWidth: 0.8))
}
}
}
}
}
// MARK: - Right column (candidates)
private func rightColumn(item: ServiceWithAssignments) -> some View {
VStack(alignment: .leading, spacing: 0) {
HStack(spacing: 10) {
Text("Vorschläge")
.font(.system(size: 10, weight: .bold, design: .rounded))
.tracking(1)
.foregroundStyle(LP.inkTertiary)
Picker("", selection: $selectedRole) {
ForEach(Role.allCases) { role in
Text(role.title).tag(role)
}
}
.labelsHidden()
.pickerStyle(.segmented)
.frame(width: 230)
.disabled(item.service.lectorsNeeded == 0 || item.service.helpersNeeded == 0)
Spacer()
Text("Fairness · Präferenzen · Verfügbarkeit")
.font(.system(size: 8.5))
.foregroundStyle(LP.inkTertiary)
}
.padding(.horizontal, 18)
.padding(.vertical, 12)
Hairline()
let suggestions = model.candidateSuggestions(for: item.service, role: selectedRole)
if suggestions.isEmpty {
EmptyStateView(
icon: "person.crop.circle.badge.questionmark",
title: "Keine Kandidaten",
message: "Für diese Rolle ist derzeit niemand verfügbar oder alle geeigneten Personen sind bereits eingeteilt."
)
} else {
ScrollView {
LazyVStack(spacing: 6) {
ForEach(Array(suggestions.enumerated()), id: \.element.id) { index, candidate in
candidateRow(candidate, rank: index + 1, item: item)
}
}
.padding(14)
}
}
}
}
private func candidateRow(_ candidate: CandidateSuggestion, rank: Int, item: ServiceWithAssignments) -> some View {
HStack(spacing: 9) {
Text("\(rank)")
.font(.system(size: 9, weight: .bold, design: .rounded))
.foregroundStyle(LP.inkTertiary)
.frame(width: 18)
Avatar(initials: candidate.person.initials,
color: candidate.blocked ? LP.inkTertiary : LP.churchColor(item.church.colorHex),
size: 26)
VStack(alignment: .leading, spacing: 2) {
HStack(spacing: 5) {
Text(candidate.person.fullName)
.font(.system(size: 11.5, weight: .medium))
.foregroundStyle(candidate.blocked ? LP.inkTertiary : LP.ink)
if candidate.preferred {
Image(systemName: "star.fill")
.font(.system(size: 7))
.foregroundStyle(LP.gold)
.help("Entspricht einer Präferenz")
}
if candidate.person.roles.contains(.lector) && candidate.person.roles.contains(.helper) {
TinyBadge(text: "L+K", color: LP.accent)
}
}
HStack(spacing: 6) {
Text("\(candidate.totalAssignments) Einsätze im Zeitraum")
.font(.system(size: 8.5))
.foregroundStyle(LP.inkTertiary)
ForEach(candidate.warnings, id: \.self) { warning in
Text(warning)
.font(.system(size: 8, weight: .medium))
.foregroundStyle(LP.open)
.padding(.horizontal, 4)
.padding(.vertical, 1)
.background(Capsule().fill(LP.openSoft.opacity(0.75)))
}
}
}
Spacer(minLength: 4)
Button {
model.assign(serviceID: item.service.id, role: selectedRole, personID: candidate.person.id)
} label: {
HStack(spacing: 3) {
Image(systemName: "plus")
.font(.system(size: 8, weight: .bold))
Text("Einteilen")
.font(.system(size: 9.5, weight: .semibold))
}
.foregroundStyle(candidate.blocked ? LP.inkTertiary : .white)
.padding(.horizontal, 8)
.padding(.vertical, 4)
.background(
Capsule().fill(candidate.blocked ? LP.cardMuted : LP.accent)
)
}
.buttonStyle(.plain)
.disabled(candidate.blocked)
.help(candidate.blocked ? candidate.warnings.joined(separator: ", ") : "Für diesen Dienst einteilen")
}
.padding(.horizontal, 9)
.padding(.vertical, 7)
.background(RoundedRectangle(cornerRadius: 9).fill(candidate.blocked ? LP.cardMuted.opacity(0.5) : LP.card))
.overlay(RoundedRectangle(cornerRadius: 9).strokeBorder(LP.line.opacity(0.55), lineWidth: 0.8))
.opacity(candidate.blocked ? 0.72 : 1)
}
}
private struct RepBadge: View {
var role: Role
var body: some View {
HStack(spacing: 3) {
Image(systemName: role.symbolName)
.font(.system(size: 7.5, weight: .semibold))
Text(role.title)
.font(.system(size: 9, weight: .semibold))
}
.foregroundStyle(role == .lector ? LP.accent : LP.burgundy)
}
}
@@ -0,0 +1,343 @@
import SwiftUI
import LektorenPlanCore
struct ServiceOrderView: View {
@EnvironmentObject private var model: PlanModel
@State private var showExceptions = false
private let columns = [GridItem(.adaptive(minimum: 500), spacing: 14)]
var body: some View {
VStack(spacing: 14) {
PageHeader(
eyebrow: "Gottesdienstordnung",
title: "Wiederkehrende Zeiten",
subtitle: "Regelmäßige Gottesdienste je Kirche, Sondertermine und Ausnahmen im Kirchenjahr."
) {
HStack(spacing: 8) {
SecondaryActionButton(title: "Ausnahmen", icon: "calendar.badge.exclamationmark") {
withAnimation(.easeInOut(duration: 0.18)) {
showExceptions.toggle()
}
}
SecondaryActionButton(title: "Termine erzeugen", icon: "arrow.clockwise") {
model.generateServices()
}
.help("Erzeugt aus den Vorlagen alle Gottesdienste im gewählten Zeitraum")
PrimaryActionButton(title: "Sondergottesdienst", icon: "sparkles") {
model.specialServiceEditor = SpecialServiceRequest(
churchID: model.churches.first?.id,
date: DayMath.today()
)
}
}
}
if showExceptions {
exceptionsPanel
.transition(.move(edge: .top).combined(with: .opacity))
}
ScrollView {
VStack(alignment: .leading, spacing: 20) {
LazyVGrid(columns: columns, alignment: .leading, spacing: 14) {
ForEach(model.churches) { church in
churchCard(church)
}
}
specialsSection
}
.padding(.bottom, 16)
}
}
.padding(.horizontal, 22)
.padding(.top, 30)
.padding(.bottom, 18)
}
// MARK: - Church card
private func churchCard(_ church: Church) -> some View {
let templates = model.templates(for: church.id)
let color = LP.churchColor(church.colorHex)
return SurfaceCard(padding: 0, radius: 15, background: LP.card) {
VStack(spacing: 0) {
HStack(spacing: 11) {
ZStack {
RoundedRectangle(cornerRadius: 10, style: .continuous)
.fill(color.opacity(0.10))
ChurchGlyph(symbol: church.symbol, tint: color, lineWidth: 1.5, showGround: false)
.padding(5)
}
.frame(width: 44, height: 44)
.overlay(RoundedRectangle(cornerRadius: 10, style: .continuous)
.strokeBorder(color.opacity(0.22), lineWidth: 0.8))
VStack(alignment: .leading, spacing: 2) {
Text(church.name)
.font(LP.serifHeadline)
.foregroundStyle(LP.ink)
Text(church.address)
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
Text(templates.count == 1 ? "1 regelmäßiger Termin" : "\(templates.count) regelmäßige Termine")
.font(.system(size: 9, weight: .medium))
.foregroundStyle(LP.inkSecondary)
}
Spacer()
Button {
model.templateEditor = TemplateEditorRequest(
template: nil,
churchID: church.id
)
} label: {
Image(systemName: "plus")
.font(.system(size: 10, weight: .bold))
.foregroundStyle(.white)
.frame(width: 24, height: 24)
.background(Circle().fill(color))
}
.buttonStyle(.plain)
.help("Neuen regelmäßigen Gottesdienst für \(church.name) anlegen")
}
.padding(14)
Hairline()
if templates.isEmpty {
Text("Noch keine Gottesdienstzeiten hinterlegt.")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
.frame(maxWidth: .infinity, alignment: .leading)
.padding(14)
} else {
VStack(spacing: 0) {
ForEach(templates) { template in
templateRow(template, color: color)
if template.id != templates.last?.id {
Hairline().opacity(0.5)
}
}
}
}
}
}
}
private func templateRow(_ template: ServiceTemplate, color: Color) -> some View {
let exceptionCount = model.exceptions.filter { $0.templateID == template.id }.count
return HStack(spacing: 10) {
VStack(alignment: .leading, spacing: 1) {
HStack(spacing: 5) {
Text(template.weekdayLabel)
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.foregroundStyle(LP.inkTertiary)
Text(template.timeLabel)
.font(.system(size: 11, weight: .bold, design: .rounded))
.foregroundStyle(color)
}
Text(template.title)
.font(.system(size: 11.5, weight: .medium))
.foregroundStyle(LP.ink)
}
Spacer(minLength: 4)
HStack(spacing: 5) {
if template.lectorsNeeded > 0 {
requirementChip(role: .lector, count: template.lectorsNeeded)
}
if template.helpersNeeded > 0 {
requirementChip(role: .helper, count: template.helpersNeeded)
}
}
if exceptionCount > 0 {
Text("\(exceptionCount)× ausgesetzt")
.font(.system(size: 7.5, weight: .medium))
.foregroundStyle(LP.inkTertiary)
.help("Ausnahmen: \(model.exceptions.filter { $0.templateID == template.id }.map { DayMath.mediumString($0.date) }.joined(separator: ", "))")
}
if !template.active {
TinyBadge(text: "INAKTIV", color: LP.inkTertiary)
}
Button {
model.templateEditor = TemplateEditorRequest(template: template, churchID: template.churchID)
} label: {
Image(systemName: "pencil")
.font(.system(size: 9.5))
.foregroundStyle(LP.inkTertiary)
.frame(width: 22, height: 22)
.background(Circle().fill(LP.cardMuted))
}
.buttonStyle(.plain)
.help("Gottesdienst bearbeiten")
}
.padding(.horizontal, 14)
.padding(.vertical, 9)
.opacity(template.active ? 1 : 0.6)
}
private func requirementChip(role: Role, count: Int) -> some View {
HStack(spacing: 3) {
Text(role == .lector ? "L" : "K")
.font(.system(size: 7.5, weight: .bold, design: .rounded))
.opacity(0.75)
Text("\(count)")
.font(.system(size: 8.5, weight: .bold, design: .rounded))
}
.foregroundStyle(role == .lector ? LP.accent : LP.burgundy)
.padding(.horizontal, 5)
.padding(.vertical, 1.5)
.background(Capsule().fill((role == .lector ? LP.accent : LP.burgundy).opacity(0.09)))
.help(role.title)
}
// MARK: - Specials
private var specialsSection: some View {
SurfaceCard(padding: 0, radius: 15, background: LP.card) {
VStack(spacing: 0) {
HStack(spacing: 9) {
Image(systemName: "sparkles")
.font(.system(size: 12, weight: .semibold))
.foregroundStyle(LP.burgundy)
VStack(alignment: .leading, spacing: 1) {
Text("Sondergottesdienste")
.font(LP.serifSubhead)
.foregroundStyle(LP.ink)
Text("Einmalige Termine und Hochfeste mit abweichender Ordnung")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
}
Spacer()
SecondaryActionButton(title: "Hinzufügen", icon: "plus") {
model.specialServiceEditor = SpecialServiceRequest(
churchID: model.churches.first?.id,
date: DayMath.today()
)
}
}
.padding(14)
Hairline()
let specials = model.upcomingSpecials()
if specials.isEmpty {
Text("Keine anstehenden Sondergottesdienste.")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
.frame(maxWidth: .infinity, alignment: .leading)
.padding(14)
} else {
VStack(spacing: 0) {
ForEach(specials, id: \.id) { service in
specialRow(service)
if service.id != specials.last?.id {
Hairline().opacity(0.5)
}
}
}
}
}
}
}
private func specialRow(_ service: ServiceOccurrence) -> some View {
let church = model.churchByID[service.churchID]
let color = church.map { LP.churchColor($0.colorHex) } ?? LP.burgundy
return HStack(spacing: 11) {
VStack(spacing: 0) {
Text(DayMath.shortWeekdayName(service.date).uppercased())
.font(.system(size: 7, weight: .bold, design: .rounded))
.foregroundStyle(LP.inkTertiary)
Text("\(DayMath.dayNumber(service.date)).")
.font(.system(size: 15, weight: .semibold, design: .serif))
.foregroundStyle(color)
Text(DayMath.shortMonthName(service.date))
.font(.system(size: 7.5))
.foregroundStyle(LP.inkTertiary)
}
.frame(width: 34)
.padding(.vertical, 3)
.background(RoundedRectangle(cornerRadius: 7).fill(LP.cardMuted))
VStack(alignment: .leading, spacing: 2) {
HStack(spacing: 5) {
Text(service.timeLabel)
.font(.system(size: 9.5, weight: .bold, design: .rounded))
.foregroundStyle(color)
Text(service.title)
.font(.system(size: 11, weight: .medium))
.foregroundStyle(LP.ink)
}
Text([church?.name, service.notes].compactMap { $0 }.filter { !$0.isEmpty }.joined(separator: " · "))
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
.lineLimit(1)
}
Spacer()
requirementChip(role: .lector, count: service.lectorsNeeded)
requirementChip(role: .helper, count: service.helpersNeeded)
Button {
model.serviceDetail = ServiceDetailRequest(serviceID: service.id)
} label: {
Image(systemName: "pencil")
.font(.system(size: 9.5))
.foregroundStyle(LP.inkTertiary)
.frame(width: 22, height: 22)
.background(Circle().fill(LP.cardMuted))
}
.buttonStyle(.plain)
}
.padding(.horizontal, 14)
.padding(.vertical, 8)
}
// MARK: - Exceptions
private var exceptionsPanel: some View {
let exceptions = model.exceptions.sorted { $0.date < $1.date }.filter { $0.date >= DayMath.adding(days: -30, to: DayMath.today()) }
return SurfaceCard(padding: 14, radius: 14, background: LP.goldSoft.opacity(0.35)) {
VStack(alignment: .leading, spacing: 8) {
HStack {
Text("AUSSETZUNGEN & AUSNAHMEN")
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.tracking(1.1)
.foregroundStyle(LP.inkTertiary)
Spacer()
Text("\(exceptions.count) Einträge")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
}
if exceptions.isEmpty {
Text("Keine Ausnahmen erfasst.")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
} else {
FlowLayout(spacing: 6) {
ForEach(exceptions) { exception in
if let template = model.templates.first(where: { $0.id == exception.templateID }),
let church = model.churchByID[template.churchID] {
HStack(spacing: 4) {
Image(systemName: "calendar.badge.minus")
.font(.system(size: 7.5))
Text("\(DayMath.mediumString(exception.date)) · \(church.shortName) \(template.timeLabel)")
.font(.system(size: 8.5, weight: .medium))
if !exception.reason.isEmpty {
Text("(\(exception.reason))")
.font(.system(size: 8))
.foregroundStyle(LP.inkTertiary)
}
}
.foregroundStyle(LP.inkSecondary)
.padding(.horizontal, 7)
.padding(.vertical, 4)
.background(Capsule().fill(LP.card))
.overlay(Capsule().strokeBorder(LP.line.opacity(0.6), lineWidth: 0.7))
}
}
}
}
}
}
}
}
@@ -0,0 +1,365 @@
import SwiftUI
import LektorenPlanCore
struct SettingsView: View {
@EnvironmentObject private var model: PlanModel
@State private var autoSync = true
@State private var respectWeekdays = true
@State private var fairnessWeight = 2.2
@State private var confirmReset = false
var body: some View {
VStack(spacing: 14) {
PageHeader(
eyebrow: "Einstellungen",
title: "Kalender, Planung & Daten",
subtitle: "Liturgische Quelle, Planungsvorgaben und lokale Datenhaltung."
) {
HStack(spacing: 8) {
SecondaryActionButton(title: "Datenbank öffnen", icon: "folder") {
model.openDatabaseFolder()
}
PrimaryActionButton(title: "Kalender aktualisieren", icon: "arrow.triangle.2.circlepath") {
Task { await model.syncLiturgy() }
}
}
}
ScrollView {
VStack(alignment: .leading, spacing: 14) {
liturgicalSection
planningSection
databaseSection
aboutSection
}
.padding(.bottom, 16)
}
}
.padding(.horizontal, 22)
.padding(.top, 30)
.padding(.bottom, 18)
.onAppear(perform: loadSettings)
.confirmationDialog(
"Demo-Daten zurücksetzen?",
isPresented: $confirmReset,
titleVisibility: .visible
) {
Button("Alle Daten zurücksetzen", role: .destructive) {
model.resetDemoData()
}
Button("Abbrechen", role: .cancel) {}
} message: {
Text("Sämtliche Kirchen, Personen, Vorlagen, Gottesdienste und Einsätze werden gelöscht und mit den Demo-Daten neu aufgebaut. Dieser Schritt kann nicht rückgängig gemacht werden.")
}
}
// MARK: - Liturgy
private var liturgicalSection: some View {
SurfaceCard(padding: 17, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 14) {
sectionHeader(
icon: "book.closed",
title: "Liturgischer Kalender",
subtitle: "Erzbistum Köln · Bezug über www.eucharistiefeier.de",
tint: LP.gold
)
HStack(spacing: 14) {
infoTile(
label: "Letzte Aktualisierung",
value: model.lastSync.map { DayMath.mediumString($0) } ?? "Noch nicht online aktualisiert",
detail: model.lastSync == nil ? "Offline-Snapshot aktiv" : "Online-Quelle",
tint: model.lastSync == nil ? LP.open : LP.success
)
infoTile(
label: "Verfügbare Jahre",
value: availableYearsLabel,
detail: "in der Datenbank",
tint: LP.accent
)
infoTile(
label: "Quelle",
value: "eucharistiefeier.de",
detail: "fair use, manuelle Abfrage",
tint: LP.burgundy
)
Spacer(minLength: 0)
}
HStack(spacing: 10) {
Toggle(isOn: $autoSync) {
VStack(alignment: .leading, spacing: 1) {
Text("Tägliche automatische Aktualisierung")
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.ink)
Text("Beim Start wird höchstens einmal pro Tag der aktuelle Jahrgang geladen.")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
}
}
.toggleStyle(.checkbox)
.onChange(of: autoSync) { _, newValue in
model.db.setSetting("autoSyncLiturgy", value: newValue ? "1" : "0")
}
Spacer()
SecondaryActionButton(title: "Jahrgänge aktualisieren", icon: "arrow.clockwise") {
Task { await model.syncLiturgy(years: Array(Set(model.range.days.map { DayMath.year($0) })).sorted()) }
}
.disabled(model.isSyncing)
}
if model.isSyncing {
HStack(spacing: 7) {
ProgressView().controlSize(.small)
Text(model.syncMessage.isEmpty ? "Lade Kalender…" : model.syncMessage)
.font(.system(size: 9.5))
.foregroundStyle(LP.inkSecondary)
}
}
Text("Die liturgischen Daten werden für die Darstellung von Hochfesten, liturgischen Farben und Tageslesungen verwendet. Bei fehlender Internetverbindung steht ein mitgelieferter Offline-Bestand zur Verfügung. Die Daten bleiben Eigentum der Quelle und werden ausschließlich zur Anzeige genutzt.")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
.fixedSize(horizontal: false, vertical: true)
}
}
}
private var availableYearsLabel: String {
let years = (try? model.db.liturgicalYears()) ?? []
return years.isEmpty ? "—" : years.map(String.init).joined(separator: ", ")
}
// MARK: - Planning
private var planningSection: some View {
SurfaceCard(padding: 17, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 14) {
sectionHeader(
icon: "wand.and.stars",
title: "Planungsvorgaben",
subtitle: "Gewichtung und harte Randbedingungen der automatischen Verteilung",
tint: LP.accent
)
Toggle(isOn: $respectWeekdays) {
VStack(alignment: .leading, spacing: 1) {
Text("Bevorzugte Einsatztage als Ausschluss behandeln")
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.ink)
Text("Wenn aktiv, werden Personen nur an ihren hinterlegten Wochentagen eingeplant.")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
}
}
.toggleStyle(.checkbox)
.onChange(of: respectWeekdays) { _, newValue in
model.db.setSetting("respectPreferredWeekdays", value: newValue ? "1" : "0")
}
VStack(alignment: .leading, spacing: 5) {
HStack {
Text("Gewicht der Fairness")
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.ink)
Spacer()
Text(String(format: "%.1f", fairnessWeight))
.font(.system(size: 10.5, weight: .semibold, design: .rounded))
.foregroundStyle(LP.accent)
}
Slider(value: $fairnessWeight, in: 0.5...4.0)
.tint(LP.accent)
.onChange(of: fairnessWeight) { _, newValue in
let rounded = (newValue * 10).rounded() / 10
if rounded != newValue {
fairnessWeight = rounded
}
model.db.setSetting("fairnessWeight", value: String(format: "%.1f", rounded))
}
HStack {
Text("Vorlieben stärker")
Spacer()
Text("Gleichverteilung stärker")
}
.font(.system(size: 8))
.foregroundStyle(LP.inkTertiary)
}
Hairline()
HStack(spacing: 8) {
Image(systemName: "info.circle")
.font(.system(size: 10))
.foregroundStyle(LP.accent)
Text("Harte Ausschlüsse: Abwesenheit, fehlende Rolle, Monatslimit, Doppelbelegung am selben Tag. Gesperrte Einsätze werden bei einer Neuplanung nie verändert.")
.font(.system(size: 9))
.foregroundStyle(LP.inkSecondary)
.fixedSize(horizontal: false, vertical: true)
Spacer()
}
}
}
}
// MARK: - Database
private var databaseSection: some View {
SurfaceCard(padding: 17, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 14) {
sectionHeader(
icon: "internaldrive",
title: "Datenhaltung",
subtitle: "Alle Daten liegen lokal in einer SQLite-Datenbank",
tint: LP.burgundy
)
HStack(alignment: .top, spacing: 12) {
VStack(alignment: .leading, spacing: 4) {
Text("Datenbankpfad")
.font(.system(size: 9, weight: .semibold))
.foregroundStyle(LP.inkTertiary)
Text(model.databasePath)
.font(.system(size: 9.5, design: .monospaced))
.foregroundStyle(LP.inkSecondary)
.textSelection(.enabled)
.lineLimit(2)
}
Spacer()
VStack(alignment: .trailing, spacing: 4) {
Text(model.databaseSizeLabel)
.font(.system(size: 13, weight: .bold, design: .rounded))
.foregroundStyle(LP.ink)
Text("Dateigröße")
.font(.system(size: 8.5))
.foregroundStyle(LP.inkTertiary)
}
}
.padding(11)
.background(RoundedRectangle(cornerRadius: 9).fill(LP.cardMuted))
.overlay(RoundedRectangle(cornerRadius: 9).strokeBorder(LP.line.opacity(0.55), lineWidth: 0.8))
HStack(spacing: 9) {
SecondaryActionButton(title: "Im Finder zeigen", icon: "folder") {
model.openDatabaseFolder()
}
SecondaryActionButton(title: "Plan exportieren", icon: "square.and.arrow.up") {
model.exportInteractive(scope: .plan)
}
SecondaryActionButton(title: "Ressourcen exportieren", icon: "square.and.arrow.up") {
model.exportInteractive(scope: .resources)
}
Spacer()
Button {
confirmReset = true
} label: {
HStack(spacing: 5) {
Image(systemName: "arrow.counterclockwise")
Text("Demo-Daten zurücksetzen")
}
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.danger)
.padding(.horizontal, 10)
.padding(.vertical, 5)
.background(RoundedRectangle(cornerRadius: 7).fill(LP.danger.opacity(0.08)))
}
.buttonStyle(.plain)
}
}
}
}
// MARK: - About
private var aboutSection: some View {
SurfaceCard(padding: 17, radius: 15, background: LP.card) {
HStack(alignment: .top, spacing: 16) {
ZStack {
Circle().fill(LP.accent.opacity(0.10))
ChurchGlyph(symbol: .basilica, tint: LP.accent, lineWidth: 1.3, showGround: false)
.padding(7)
}
.frame(width: 58, height: 58)
.overlay(Circle().strokeBorder(LP.accent.opacity(0.18), lineWidth: 0.8))
VStack(alignment: .leading, spacing: 5) {
Text("LektorenPlan")
.font(LP.serifHeadline)
.foregroundStyle(LP.ink)
Text("Prototyp 0.1 · Pfarreiengemeinschaft Bad Godesberg · Erzbistum Köln")
.font(.system(size: 9.5))
.foregroundStyle(LP.inkSecondary)
Text("Geplant werden Lektoren und Kommunionhelfer für St. Andreas, St. Evergislus, Herz Jesu und St. Hildegard. Liturgische Daten: www.eucharistiefeier.de (fair use). Alle Personen- und Plandaten in dieser Demo sind fiktiv.")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
.fixedSize(horizontal: false, vertical: true)
}
Spacer(minLength: 12)
VStack(alignment: .trailing, spacing: 5) {
Link(destination: URL(string: "https://www.eucharistiefeier.de")!) {
HStack(spacing: 3) {
Text("www.eucharistiefeier.de")
Image(systemName: "arrow.up.right")
.font(.system(size: 7))
}
.font(.system(size: 9, weight: .medium))
.foregroundStyle(LP.accent)
}
Text("SwiftUI · SQLite · Swift Charts")
.font(.system(size: 8))
.foregroundStyle(LP.inkTertiary)
}
}
}
}
// MARK: - Helpers
private func loadSettings() {
autoSync = model.db.setting("autoSyncLiturgy") != "0"
respectWeekdays = model.db.setting("respectPreferredWeekdays") != "0"
fairnessWeight = Double(model.db.setting("fairnessWeight") ?? "") ?? 2.2
}
private func sectionHeader(icon: String, title: String, subtitle: String, tint: Color) -> some View {
HStack(alignment: .top, spacing: 9) {
Image(systemName: icon)
.font(.system(size: 12, weight: .semibold))
.foregroundStyle(tint)
.frame(width: 28, height: 28)
.background(Circle().fill(tint.opacity(0.10)))
VStack(alignment: .leading, spacing: 1) {
Text(title)
.font(LP.serifSubhead)
.foregroundStyle(LP.ink)
Text(subtitle)
.font(.system(size: 8.5))
.foregroundStyle(LP.inkTertiary)
}
Spacer()
}
}
private func infoTile(label: String, value: String, detail: String, tint: Color) -> some View {
VStack(alignment: .leading, spacing: 3) {
Text(label.uppercased())
.font(.system(size: 8, weight: .bold, design: .rounded))
.tracking(0.7)
.foregroundStyle(LP.inkTertiary)
Text(value)
.font(.system(size: 11.5, weight: .semibold))
.foregroundStyle(LP.ink)
.lineLimit(1)
Text(detail)
.font(.system(size: 8.5))
.foregroundStyle(tint)
}
.frame(maxWidth: .infinity, alignment: .leading)
.padding(10)
.background(RoundedRectangle(cornerRadius: 9).fill(LP.cardMuted))
.overlay(RoundedRectangle(cornerRadius: 9).strokeBorder(LP.line.opacity(0.55), lineWidth: 0.8))
}
}
@@ -0,0 +1,145 @@
import SwiftUI
import LektorenPlanCore
// MARK: - Sheet chrome
struct SheetHeader: View {
var icon: String
var title: String
var subtitle: String
var tint: Color = LP.accent
var body: some View {
HStack(alignment: .top, spacing: 13) {
ZStack {
RoundedRectangle(cornerRadius: 11, style: .continuous)
.fill(tint.opacity(0.11))
Image(systemName: icon)
.font(.system(size: 17, weight: .semibold))
.foregroundStyle(tint)
}
.frame(width: 40, height: 40)
VStack(alignment: .leading, spacing: 3) {
Text(title)
.font(LP.serifHeadline)
.foregroundStyle(LP.ink)
Text(subtitle)
.font(.system(size: 11))
.foregroundStyle(LP.inkSecondary)
.fixedSize(horizontal: false, vertical: true)
}
Spacer(minLength: 8)
}
.padding(.horizontal, 22)
.padding(.top, 20)
.padding(.bottom, 14)
}
}
struct SheetFooter<Content: View>: View {
@ViewBuilder var content: Content
var body: some View {
VStack(spacing: 0) {
Hairline()
HStack(spacing: 10) {
content
}
.padding(.horizontal, 22)
.padding(.vertical, 13)
}
.background(LP.card)
}
}
struct FormSection<Content: View>: View {
var title: String
var subtitle: String? = nil
@ViewBuilder var content: Content
var body: some View {
VStack(alignment: .leading, spacing: 10) {
VStack(alignment: .leading, spacing: 2) {
Text(title.uppercased())
.font(.system(size: 9, weight: .bold, design: .rounded))
.tracking(1.2)
.foregroundStyle(LP.inkTertiary)
if let subtitle {
Text(subtitle)
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary.opacity(0.9))
}
}
content
}
}
}
struct LabeledField<Content: View>: View {
var label: String
@ViewBuilder var content: Content
var body: some View {
VStack(alignment: .leading, spacing: 4) {
Text(label)
.font(.system(size: 9.5, weight: .semibold))
.foregroundStyle(LP.inkSecondary)
content
}
}
}
struct ChipToggle: View {
var title: String
var icon: String? = nil
var isOn: Bool
var tint: Color = LP.accent
var action: () -> Void
var body: some View {
Button(action: action) {
HStack(spacing: 4) {
if let icon {
Image(systemName: icon)
.font(.system(size: 8.5, weight: .semibold))
}
Text(title)
.font(.system(size: 10, weight: .medium))
}
.foregroundStyle(isOn ? .white : LP.inkSecondary)
.padding(.horizontal, 9)
.padding(.vertical, 5)
.background(
Capsule().fill(isOn ? tint : LP.cardMuted)
)
.overlay(
Capsule().strokeBorder(isOn ? .clear : LP.line.opacity(0.8), lineWidth: 0.8)
)
}
.buttonStyle(.plain)
}
}
struct SheetDestinationPicker: View {
@Binding var selection: String
var churches: [Church]
var body: some View {
Picker("", selection: $selection) {
ForEach(churches) { church in
Text(church.name).tag(church.id)
}
}
.labelsHidden()
.pickerStyle(.menu)
}
}
extension View {
func sheetSurface(width: CGFloat, height: CGFloat) -> some View {
self
.frame(width: width, height: height)
.background(LP.paper)
}
}
@@ -0,0 +1,198 @@
import SwiftUI
import LektorenPlanCore
struct SpecialServiceSheet: View {
@EnvironmentObject private var model: PlanModel
@Environment(\.dismiss) private var dismiss
let request: SpecialServiceRequest
@State private var churchID = ""
@State private var date = DayMath.today()
@State private var timeDate = Date()
@State private var title = ""
@State private var lectorsNeeded = 1
@State private var helpersNeeded = 1
@State private var notes = ""
@State private var useLiturgicalTitle = true
@State private var existing: ServiceOccurrence?
private var isValid: Bool {
!churchID.isEmpty && !title.trimmingCharacters(in: .whitespaces).isEmpty
&& (lectorsNeeded + helpersNeeded) > 0
}
private var liturgicalDay: LiturgicalDay? {
let key = DayMath.key(date)
if let day = model.liturgicalDays[key] { return day }
return LiturgicalCalendarEngine.localDay(for: date)
}
var body: some View {
VStack(spacing: 0) {
SheetHeader(
icon: "sparkles",
title: existing == nil ? "Sondergottesdienst" : "Sondergottesdienst bearbeiten",
subtitle: "Einmaliger Termin außerhalb der regelmäßigen Ordnung – z. B. Christmette, Osternacht oder Patronatsfest.",
tint: LP.burgundy
)
Hairline()
ScrollView {
VStack(alignment: .leading, spacing: 22) {
FormSection(title: "Ort & Zeit") {
HStack(spacing: 12) {
LabeledField(label: "Kirche") {
Picker("", selection: $churchID) {
ForEach(model.churches) { church in
Text(church.name).tag(church.id)
}
}
.labelsHidden()
.pickerStyle(.menu)
}
LabeledField(label: "Datum") {
DatePicker("", selection: $date, displayedComponents: .date)
.labelsHidden()
.datePickerStyle(.field)
}
LabeledField(label: "Uhrzeit") {
DatePicker("", selection: $timeDate, displayedComponents: .hourAndMinute)
.labelsHidden()
.datePickerStyle(.field)
}
}
}
if let day = liturgicalDay {
HStack(spacing: 11) {
Image(systemName: day.symbol.symbolName)
.font(.system(size: 15, weight: .medium))
.foregroundStyle(day.isHighFeast ? LP.gold : LP.burgundy)
.frame(width: 30, height: 30)
.background(Circle().fill((day.isHighFeast ? LP.gold : LP.burgundy).opacity(0.10)))
VStack(alignment: .leading, spacing: 2) {
Text(day.displayTitle)
.font(LP.serifSubhead)
.foregroundStyle(LP.ink)
Text([day.rank.label, day.isObligation ? "gebotener Feiertag" : nil]
.compactMap { $0 }.joined(separator: " · "))
.font(.system(size: 9.5))
.foregroundStyle(LP.inkTertiary)
if !day.readings.isEmpty {
Text(day.readings.shortLabel)
.font(.system(size: 9.5))
.foregroundStyle(LP.inkSecondary)
.lineLimit(2)
}
}
Spacer()
if !title.isEmpty || useLiturgicalTitle {
SecondaryActionButton(title: "Titel übernehmen", icon: "arrow.down.doc") {
title = day.displayTitle
useLiturgicalTitle = true
}
}
}
.padding(11)
.background(RoundedRectangle(cornerRadius: 10).fill(LP.cardMuted))
.overlay(RoundedRectangle(cornerRadius: 10).strokeBorder(LP.line.opacity(0.6), lineWidth: 0.8))
}
FormSection(title: "Bezeichnung & Dienste") {
LabeledField(label: "Titel") {
TextField("z. B. Christmette", text: $title)
.textFieldStyle(.roundedBorder)
}
HStack(spacing: 26) {
HStack(spacing: 8) {
RoleBadge(role: .lector)
Stepper(value: $lectorsNeeded, in: 0...4) {
Text("\(lectorsNeeded)")
.font(.system(size: 12, weight: .semibold, design: .rounded))
.monospacedDigit()
}
.fixedSize()
}
HStack(spacing: 8) {
RoleBadge(role: .helper)
Stepper(value: $helpersNeeded, in: 0...4) {
Text("\(helpersNeeded)")
.font(.system(size: 12, weight: .semibold, design: .rounded))
.monospacedDigit()
}
.fixedSize()
}
Spacer()
}
}
FormSection(title: "Notizen") {
TextEditor(text: $notes)
.font(.system(size: 11))
.frame(height: 58)
.padding(5)
.background(RoundedRectangle(cornerRadius: 7).fill(LP.card))
.overlay(RoundedRectangle(cornerRadius: 7).strokeBorder(LP.line.opacity(0.8), lineWidth: 1))
}
}
.padding(22)
}
SheetFooter {
Spacer()
SecondaryActionButton(title: "Abbrechen", icon: "xmark") { dismiss() }
PrimaryActionButton(title: "Speichern", icon: "checkmark", action: save, disabled: !isValid)
}
}
.sheetSurface(width: 600, height: 610)
.onAppear(perform: load)
}
private func load() {
existing = request.service
if let service = existing {
churchID = service.churchID
date = service.date
timeDate = calendarTime(minutes: service.timeMinutes)
title = service.title
lectorsNeeded = service.lectorsNeeded
helpersNeeded = service.helpersNeeded
notes = service.notes
return
}
churchID = request.churchID ?? model.churches.first?.id ?? ""
date = request.date
timeDate = calendarTime(minutes: 18 * 60)
if let day = liturgicalDay {
title = day.isFeast ? day.displayTitle : ""
}
}
private func calendarTime(minutes: Int) -> Date {
let start = DayMath.today()
return DayMath.calendar.date(bySettingHour: minutes / 60, minute: minutes % 60, second: 0, of: start) ?? start
}
private func save() {
let comps = DayMath.calendar.dateComponents([.hour, .minute], from: timeDate)
let minutes = (comps.hour ?? 18) * 60 + (comps.minute ?? 0)
let service = ServiceOccurrence(
id: existing?.id ?? UUID().uuidString,
churchID: churchID,
templateID: nil,
date: date,
timeMinutes: minutes,
title: title.trimmingCharacters(in: .whitespaces),
lectorsNeeded: lectorsNeeded,
helpersNeeded: helpersNeeded,
kind: .special,
notes: notes.trimmingCharacters(in: .whitespacesAndNewlines),
locked: existing?.locked ?? false,
createdAt: existing?.createdAt ?? Date()
)
model.saveSpecialService(service)
dismiss()
}
}
@@ -0,0 +1,489 @@
import SwiftUI
import Charts
import LektorenPlanCore
struct StatisticsView: View {
@EnvironmentObject private var model: PlanModel
private var stats: RangeStatistics { model.stats }
private var topPeople: [PersonStat] {
Array(stats.personStats.sorted { $0.total > $1.total }.prefix(18))
}
private var monthlyPoints: [MonthlyPoint] {
var points: [MonthlyPoint] = []
var cursor = DayMath.startOfMonth(model.range.start)
let lastMonth = DayMath.startOfMonth(model.range.end)
while cursor <= lastMonth {
let key = DayMath.monthKey(cursor)
points.append(MonthlyPoint(
month: cursor,
label: "\(DayMath.shortMonthName(cursor)) \(String(DayMath.year(cursor)).suffix(2))",
count: stats.monthlyCounts[key] ?? 0
))
cursor = DayMath.adding(months: 1, to: cursor)
}
return points
}
private var monthlyBarWidth: MarkDimension {
monthlyPoints.count > 16 ? .automatic : .fixed(26)
}
private var activePersonStats: [PersonStat] {
stats.personStats.filter { $0.total > 0 }
}
var body: some View {
VStack(spacing: 14) {
PageHeader(
eyebrow: "Auswertung",
title: "Statistik & Verteilung",
subtitle: "Einsatzhäufigkeit, Orte, Vorlieben und Fairness für den gewählten Zeitraum."
) {
HStack(spacing: 8) {
SecondaryActionButton(title: "PDF", icon: "doc.richtext") {
model.createPDFPreview()
}
PrimaryActionButton(title: "Offene Dienste besetzen", icon: "wand.and.stars") {
_ = model.autoPlan(replaceExisting: false)
}
}
}
TimelineRangePicker()
ScrollView {
VStack(alignment: .leading, spacing: 14) {
kpiGrid
HStack(alignment: .top, spacing: 14) {
workloadChart
fairnessCard
.frame(width: 268)
}
monthlyChart
HStack(alignment: .top, spacing: 14) {
churchDistribution
preferenceCard
.frame(width: 300)
}
personTable
}
.padding(.bottom, 16)
}
}
.padding(.horizontal, 22)
.padding(.top, 30)
.padding(.bottom, 18)
}
// MARK: - KPI
private var kpiGrid: some View {
LazyVGrid(columns: [GridItem(.adaptive(minimum: 156), spacing: 12)], spacing: 12) {
kpiCard(icon: "building.columns", value: "\(stats.serviceCount)", label: "Gottesdienste", tint: LP.accent)
kpiCard(icon: "checkmark.seal", value: "\(stats.assignmentCount)", label: "Einsätze", tint: LP.success)
kpiCard(icon: "circle.dashed", value: "\(stats.openSlots)", label: "offene Dienste", tint: LP.open)
kpiCard(icon: "percent", value: "\(Int(stats.coverageRate * 100)) %", label: "Besetzungsquote", tint: LP.gold)
kpiCard(icon: "star", value: "\(Int(stats.preferenceRate * 100)) %", label: "Präferenztreffer", tint: LP.burgundy)
kpiCard(icon: "person.2", value: "\(stats.activePeople)", label: "eingesetzte Personen", tint: LP.accent)
kpiCard(icon: "calendar.badge.minus", value: "\(stats.absenceDays)", label: "Abwesenheitstage", tint: LP.open)
kpiCard(icon: "cross.case", value: "\(stats.sundayServiceCount)", label: "Sonntage", tint: LP.gold)
}
}
private func kpiCard(icon: String, value: String, label: String, tint: Color) -> some View {
HStack(spacing: 9) {
Image(systemName: icon)
.font(.system(size: 13, weight: .semibold))
.foregroundStyle(tint)
.frame(width: 30, height: 30)
.background(Circle().fill(tint.opacity(0.10)))
VStack(alignment: .leading, spacing: 1) {
Text(value)
.font(.system(size: 17, weight: .bold, design: .rounded))
.foregroundStyle(LP.ink)
.monospacedDigit()
Text(label)
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
.lineLimit(1)
}
Spacer(minLength: 0)
}
.padding(10)
.background(RoundedRectangle(cornerRadius: 11).fill(LP.card))
.overlay(RoundedRectangle(cornerRadius: 11).strokeBorder(LP.line.opacity(0.55), lineWidth: 0.8))
}
// MARK: - Workload
private var workloadChart: some View {
SurfaceCard(padding: 16, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 12) {
chartHeader(
title: "Einsätze pro Person",
subtitle: "Top \(topPeople.count) im Zeitraum · faire Verteilung anstreben",
icon: "person.3"
)
if topPeople.allSatisfy({ $0.total == 0 }) || topPeople.isEmpty {
chartEmpty("Für diesen Zeitraum liegen noch keine Einsätze vor.")
} else {
Chart(topPeople) { stat in
BarMark(
x: .value("Einsätze", stat.total),
y: .value("Person", stat.person.lastName),
height: .fixed(8)
)
.foregroundStyle(
LinearGradient(colors: [LP.accent.opacity(0.85), LP.accent.opacity(0.5)],
startPoint: .leading, endPoint: .trailing)
)
.cornerRadius(3)
.annotation(position: .trailing, alignment: .leading) {
Text("\(stat.total)")
.font(.system(size: 8.5, weight: .semibold, design: .rounded))
.foregroundStyle(LP.inkTertiary)
}
}
.chartXAxis {
AxisMarks(position: .bottom) { _ in
AxisGridLine().foregroundStyle(LP.line.opacity(0.4))
AxisValueLabel().foregroundStyle(LP.inkTertiary)
}
}
.chartYAxis {
AxisMarks { _ in
AxisValueLabel().foregroundStyle(LP.inkSecondary)
}
}
.frame(height: CGFloat(max(220, topPeople.count * 17)))
}
}
}
}
private var fairnessCard: some View {
let totals = activePersonStats.map(\.total)
let average = totals.isEmpty ? 0 : Double(totals.reduce(0, +)) / Double(totals.count)
let maximum = totals.max() ?? 0
let minimum = totals.min() ?? 0
return SurfaceCard(padding: 16, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 12) {
chartHeader(title: "Fairness", subtitle: "Verteilung der Last", icon: "scale.3d")
Text(String(format: "%.1f", average))
.font(.system(size: 30, weight: .bold, design: .rounded))
.foregroundStyle(LP.ink)
Text("Einsätze pro aktive Person im Schnitt")
.font(.system(size: 9.5))
.foregroundStyle(LP.inkTertiary)
Hairline()
fairnessRow(label: "Höchste Last", value: "\(maximum)")
fairnessRow(label: "Niedrigste Last", value: "\(minimum)")
fairnessRow(label: "Spannweite", value: "\(maximum - minimum)")
fairnessRow(label: "Aktive Personen", value: "\(totals.count)")
Hairline()
Text("Eine geringe Spannweite bedeutet eine gleichmäßige Verteilung. Präferenzen und Abwesenheiten können bewusst zu Abweichungen führen.")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
.fixedSize(horizontal: false, vertical: true)
}
}
}
private func fairnessRow(label: String, value: String) -> some View {
HStack {
Text(label)
.font(.system(size: 9.5))
.foregroundStyle(LP.inkSecondary)
Spacer()
Text(value)
.font(.system(size: 10.5, weight: .semibold, design: .rounded))
.foregroundStyle(LP.ink)
.monospacedDigit()
}
}
// MARK: - Monthly
private var monthlyChart: some View {
SurfaceCard(padding: 16, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 12) {
chartHeader(
title: "Verlauf nach Monat",
subtitle: "Einsätze im gewählten Zeitraum",
icon: "chart.bar.xaxis"
)
if monthlyPoints.isEmpty {
chartEmpty("Keine Monatsdaten im Zeitraum.")
} else {
Chart {
ForEach(monthlyPoints) { point in
BarMark(
x: .value("Monat", point.label),
y: .value("Einsätze", point.count),
width: monthlyBarWidth
)
.foregroundStyle(LP.accent.opacity(0.32))
.cornerRadius(3)
}
ForEach(monthlyPoints) { point in
LineMark(
x: .value("Monat", point.label),
y: .value("Einsätze", point.count)
)
.foregroundStyle(LP.gold)
.symbol(Circle())
.symbolSize(18)
.interpolationMethod(.catmullRom)
}
}
.chartYAxis {
AxisMarks { _ in
AxisGridLine().foregroundStyle(LP.line.opacity(0.4))
AxisValueLabel().foregroundStyle(LP.inkTertiary)
}
}
.chartXAxis {
AxisMarks { _ in
AxisValueLabel().foregroundStyle(LP.inkTertiary)
}
}
.frame(height: 168)
}
}
}
}
// MARK: - Church distribution
private var churchDistribution: some View {
SurfaceCard(padding: 16, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 12) {
chartHeader(
title: "Verteilung auf die Kirchen",
subtitle: "Einsätze, Gottesdienste und offene Dienste",
icon: "building.columns"
)
let maximum = max(1, stats.churchStats.map(\.assignments).max() ?? 1)
ForEach(stats.churchStats) { stat in
HStack(spacing: 10) {
ZStack {
RoundedRectangle(cornerRadius: 7).fill(LP.churchColor(stat.church.colorHex).opacity(0.10))
ChurchGlyph(symbol: stat.church.symbol, tint: LP.churchColor(stat.church.colorHex), lineWidth: 1.4, showGround: false)
.padding(4)
}
.frame(width: 32, height: 32)
VStack(alignment: .leading, spacing: 4) {
HStack {
Text(stat.church.name)
.font(.system(size: 10.5, weight: .semibold))
.foregroundStyle(LP.ink)
Spacer()
Text("\(stat.assignments) Einsätze · \(stat.services) Gottesdienste")
.font(.system(size: 8.5))
.foregroundStyle(LP.inkTertiary)
}
GeometryReader { geo in
ZStack(alignment: .leading) {
Capsule().fill(LP.line.opacity(0.35))
Capsule()
.fill(LP.churchColor(stat.church.colorHex))
.frame(width: max(3, geo.size.width * CGFloat(stat.assignments) / CGFloat(maximum)))
}
}
.frame(height: 6)
HStack(spacing: 8) {
Text("\(stat.personCount) Personen")
.font(.system(size: 8))
.foregroundStyle(LP.inkTertiary)
if stat.openSlots > 0 {
Text("\(stat.openSlots) offen")
.font(.system(size: 8, weight: .semibold))
.foregroundStyle(LP.open)
}
}
}
}
.padding(.vertical, 3)
}
}
}
}
// MARK: - Preferences
private var preferenceCard: some View {
SurfaceCard(padding: 16, radius: 15, background: LP.card) {
VStack(alignment: .leading, spacing: 12) {
chartHeader(title: "Vorlieben", subtitle: "Berücksichtigung im Plan", icon: "star")
ZStack {
Circle()
.stroke(LP.line.opacity(0.35), lineWidth: 9)
Circle()
.trim(from: 0, to: min(1, max(0, stats.preferenceRate)))
.stroke(
AngularGradient(colors: [LP.gold, LP.accent], center: .center),
style: StrokeStyle(lineWidth: 9, lineCap: .round)
)
.rotationEffect(.degrees(-90))
VStack(spacing: 1) {
Text("\(Int(stats.preferenceRate * 100))%")
.font(.system(size: 22, weight: .bold, design: .rounded))
.foregroundStyle(LP.ink)
Text("Treffer")
.font(.system(size: 8))
.foregroundStyle(LP.inkTertiary)
}
}
.frame(width: 112, height: 112)
.frame(maxWidth: .infinity)
fairnessRow(label: "Treffer", value: "\(stats.preferenceHits)")
fairnessRow(label: "Bewertbare Einsätze", value: "\(stats.preferenceEligible)")
Text("Gezählt werden Einsätze, bei denen Kirche, Wochentag oder Gottesdienst einer hinterlegten Präferenz entsprechen.")
.font(.system(size: 9))
.foregroundStyle(LP.inkTertiary)
.fixedSize(horizontal: false, vertical: true)
}
}
}
// MARK: - Person table
private var personTable: some View {
SurfaceCard(padding: 0, radius: 15, background: LP.card) {
VStack(spacing: 0) {
HStack {
Text("EINSATZÜBERSICHT")
.font(.system(size: 8.5, weight: .bold, design: .rounded))
.tracking(1.1)
.foregroundStyle(LP.inkTertiary)
Spacer()
Text("Personen mit Einsätzen im Zeitraum")
.font(.system(size: 8.5))
.foregroundStyle(LP.inkTertiary)
}
.padding(.horizontal, 14)
.padding(.vertical, 11)
Hairline()
HStack(spacing: 8) {
Text("Person")
.frame(maxWidth: .infinity, alignment: .leading)
Text("L")
.frame(width: 28)
Text("K")
.frame(width: 28)
Text("Sonntage")
.frame(width: 62)
Text("Kirchen")
.frame(width: 150, alignment: .leading)
Text("Präferenz")
.frame(width: 70)
Text("Zuletzt")
.frame(width: 86, alignment: .leading)
}
.font(.system(size: 8, weight: .bold, design: .rounded))
.foregroundStyle(LP.inkTertiary)
.padding(.horizontal, 14)
.padding(.vertical, 7)
.background(LP.cardMuted.opacity(0.5))
ForEach(Array(activePersonStats.enumerated()), id: \.element.id) { index, stat in
HStack(spacing: 8) {
HStack(spacing: 6) {
Avatar(initials: stat.person.initials,
color: stat.person.roles.contains(.lector) ? LP.accent : LP.burgundy,
size: 20)
Text(stat.person.fullName)
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.ink)
.lineLimit(1)
}
.frame(maxWidth: .infinity, alignment: .leading)
Text("\(stat.lectors)")
.frame(width: 28)
Text("\(stat.helpers)")
.frame(width: 28)
Text("\(stat.sundayCount)")
.frame(width: 62)
HStack(spacing: 3) {
ForEach(Array(stat.churchCounts.sorted { $0.value > $1.value }.prefix(3)), id: \.key) { item in
if let church = model.churchByID[item.key] {
Text("\(church.shortName) \(item.value)")
.font(.system(size: 8))
.foregroundStyle(LP.churchColor(church.colorHex))
.lineLimit(1)
.fixedSize(horizontal: true, vertical: false)
.padding(.horizontal, 4)
.padding(.vertical, 1)
.background(Capsule().fill(LP.churchColor(church.colorHex).opacity(0.08)))
}
}
}
.frame(width: 150, alignment: .leading)
Text(StatisticsCalculator.hasAnyPreference(stat.person)
? "\(Int(stat.preferenceRate * 100)) %"
: "—")
.frame(width: 70)
.foregroundStyle(stat.preferenceRate >= 0.6 ? LP.success : LP.inkSecondary)
Text(stat.lastAssignment.map(DayMath.mediumString) ?? "—")
.frame(width: 86, alignment: .leading)
.foregroundStyle(LP.inkTertiary)
}
.font(.system(size: 9.5, design: .rounded))
.foregroundStyle(LP.inkSecondary)
.padding(.horizontal, 14)
.padding(.vertical, 5)
.background(index % 2 == 0 ? LP.cardMuted.opacity(0.22) : Color.clear)
}
}
}
}
// MARK: - Helpers
private func chartHeader(title: String, subtitle: String, icon: String) -> some View {
HStack(alignment: .top, spacing: 8) {
Image(systemName: icon)
.font(.system(size: 10.5, weight: .semibold))
.foregroundStyle(LP.accent)
.padding(.top, 1)
VStack(alignment: .leading, spacing: 1) {
Text(title)
.font(LP.serifSubhead)
.foregroundStyle(LP.ink)
Text(subtitle)
.font(.system(size: 8.5))
.foregroundStyle(LP.inkTertiary)
}
Spacer()
}
}
private func chartEmpty(_ message: String) -> some View {
Text(message)
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
.frame(maxWidth: .infinity, minHeight: 130)
}
}
private struct MonthlyPoint: Identifiable {
var month: Date
var label: String
var count: Int
var id: String { label }
}
+255
View File
@@ -0,0 +1,255 @@
import SwiftUI
import LektorenPlanCore
private enum TeamFilter: String, CaseIterable, Identifiable {
case all, lectors, helpers, inactive
var id: String { rawValue }
var title: String {
switch self {
case .all: "Alle"
case .lectors: "Lektoren"
case .helpers: "Kommunionhelfer"
case .inactive: "Inaktiv"
}
}
}
struct TeamView: View {
@EnvironmentObject private var model: PlanModel
@State private var filter: TeamFilter = .all
@State private var search = ""
private let columns = [GridItem(.adaptive(minimum: 292), spacing: 12)]
private var filteredPeople: [Person] {
let query = search.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
return model.people.filter { person in
switch filter {
case .all:
if !person.active { return false }
case .lectors:
if !person.active || !person.roles.contains(.lector) { return false }
case .helpers:
if !person.active || !person.roles.contains(.helper) { return false }
case .inactive:
if person.active { return false }
}
guard !query.isEmpty else { return true }
if person.fullName.lowercased().contains(query) { return true }
if person.email.lowercased().contains(query) { return true }
if person.roleLabel.lowercased().contains(query) { return true }
return false
}
}
var body: some View {
VStack(spacing: 14) {
PageHeader(
eyebrow: "Lektoren & Kommunionhelfer",
title: "Das Team",
subtitle: "Rollen, bevorzugte Orte, Einsatztage, Abwesenheiten und Monatslimits."
) {
HStack(spacing: 8) {
SecondaryActionButton(title: "Abwesenheiten", icon: "calendar.badge.minus") {}
.hidden()
PrimaryActionButton(title: "Person hinzufügen", icon: "person.badge.plus") {
model.personEditor = PersonEditorRequest(person: nil)
}
}
}
summaryBar
filterBar
ScrollView {
LazyVGrid(columns: columns, alignment: .leading, spacing: 12) {
ForEach(filteredPeople) { person in
personCard(person)
}
}
.padding(.bottom, 16)
}
}
.padding(.horizontal, 22)
.padding(.top, 30)
.padding(.bottom, 18)
}
private var summaryBar: some View {
SurfaceCard(padding: 13, radius: 14, background: LP.card.opacity(0.9)) {
HStack(spacing: 0) {
StatPill(icon: "person.2", value: "\(model.people.filter(\.active).count)", label: "Aktiv")
divider
StatPill(icon: "book.closed", value: "\(model.lectorCount)", label: "Lektoren", tint: LP.accent)
divider
StatPill(icon: "hand.raised", value: "\(model.helperCount)", label: "Kommunionhelfer", tint: LP.burgundy)
divider
StatPill(icon: "calendar.badge.minus", value: "\(model.absences.count)", label: "Abwesenheiten", tint: LP.open)
divider
StatPill(icon: "checkmark.seal", value: "\(model.stats.activePeople)", label: "im Zeitraum eingeteilt", tint: LP.success)
Spacer()
}
}
}
private var divider: some View {
Rectangle()
.fill(LP.line.opacity(0.55))
.frame(width: 1, height: 28)
.padding(.horizontal, 12)
}
private var filterBar: some View {
HStack(spacing: 12) {
HStack(spacing: 2) {
ForEach(TeamFilter.allCases) { item in
Button {
withAnimation(.easeInOut(duration: 0.15)) { filter = item }
} label: {
Text(item.title)
.font(.system(size: 10.5, weight: .semibold))
.foregroundStyle(filter == item ? .white : LP.inkSecondary)
.padding(.horizontal, 10)
.padding(.vertical, 5)
.background(Capsule().fill(filter == item ? LP.accent : Color.clear))
}
.buttonStyle(.plain)
}
}
.padding(3)
.background(Capsule().fill(LP.cardMuted))
.overlay(Capsule().strokeBorder(LP.line.opacity(0.55), lineWidth: 0.7))
HStack(spacing: 5) {
Image(systemName: "magnifyingglass")
.font(.system(size: 10))
.foregroundStyle(LP.inkTertiary)
TextField("Person suchen…", text: $search)
.textFieldStyle(.plain)
.font(.system(size: 10.5))
.frame(width: 160)
}
.padding(.horizontal, 8)
.padding(.vertical, 5)
.background(RoundedRectangle(cornerRadius: 7).fill(LP.cardMuted))
.overlay(RoundedRectangle(cornerRadius: 7).strokeBorder(LP.line.opacity(0.6), lineWidth: 0.7))
Spacer()
Text("\(filteredPeople.count) Personen")
.font(.system(size: 9.5, weight: .medium, design: .rounded))
.foregroundStyle(LP.inkTertiary)
}
}
private func personCard(_ person: Person) -> some View {
let assignments = model.assignmentCount(for: person.id)
let currentAbsence = model.currentAbsence(for: person)
let roleColor = person.roles.contains(.lector) ? LP.accent : LP.burgundy
return Button {
model.personEditor = PersonEditorRequest(person: person)
} label: {
VStack(alignment: .leading, spacing: 9) {
HStack(spacing: 9) {
Avatar(initials: person.initials, color: roleColor, size: 34)
VStack(alignment: .leading, spacing: 2) {
Text(person.fullName)
.font(.system(size: 12.5, weight: .semibold))
.foregroundStyle(LP.ink)
HStack(spacing: 4) {
ForEach(Role.allCases.filter { person.roles.contains($0) }) { role in
TinyBadge(text: role.title.uppercased(), color: role == .lector ? LP.accent : LP.burgundy)
}
}
}
Spacer(minLength: 4)
VStack(alignment: .trailing, spacing: 1) {
Text("\(assignments)")
.font(.system(size: 16, weight: .bold, design: .rounded))
.foregroundStyle(assignments > 0 ? LP.ink : LP.inkTertiary)
Text("Einsätze")
.font(.system(size: 8))
.foregroundStyle(LP.inkTertiary)
}
}
if !person.notes.isEmpty {
Text(person.notes)
.font(.system(size: 9.5))
.foregroundStyle(LP.inkSecondary)
.lineLimit(2)
.frame(maxWidth: .infinity, alignment: .leading)
}
VStack(alignment: .leading, spacing: 5) {
preferenceRow(
icon: "building.columns",
text: person.preferredChurchIDs.isEmpty
? "Alle Kirchen"
: person.preferredChurchIDs.compactMap { model.churchByID[$0]?.shortName }.sorted().joined(separator: ", "),
active: !person.preferredChurchIDs.isEmpty
)
preferenceRow(
icon: "calendar",
text: person.preferredWeekdays.isEmpty
? "Alle Tage"
: person.preferredWeekdays.sorted().map(weekdayShort).joined(separator: ", "),
active: !person.preferredWeekdays.isEmpty
)
if !person.preferredServiceTitles.isEmpty {
preferenceRow(
icon: "book.closed",
text: person.preferredServiceTitles.joined(separator: ", "),
active: true
)
}
}
HStack(spacing: 6) {
TinyBadge(text: "MAX \(person.maxPerMonth)×/MONAT", color: LP.inkTertiary)
if let currentAbsence {
TinyBadge(text: "ABWESEND · \(currentAbsence.reason.isEmpty ? "bis \(DayMath.mediumString(currentAbsence.end))" : currentAbsence.reason)", color: LP.open, filled: true)
} else if !model.absences(for: person.id).isEmpty {
TinyBadge(text: "\(model.absences(for: person.id).count)× ABWESEND", color: LP.inkTertiary)
}
Spacer()
Image(systemName: "chevron.right")
.font(.system(size: 8, weight: .semibold))
.foregroundStyle(LP.inkTertiary.opacity(0.6))
}
}
.padding(13)
.frame(maxWidth: .infinity, alignment: .leading)
.background(
RoundedRectangle(cornerRadius: 14, style: .continuous)
.fill(LP.card)
.shadow(color: .black.opacity(0.03), radius: 8, y: 3)
)
.overlay(
RoundedRectangle(cornerRadius: 14, style: .continuous)
.strokeBorder(LP.line.opacity(0.55), lineWidth: 1)
)
.opacity(person.active ? 1 : 0.62)
}
.buttonStyle(.plain)
.help("\(person.fullName)\n\(person.roleLabel)\nKlicken zum Bearbeiten")
}
private func preferenceRow(icon: String, text: String, active: Bool) -> some View {
HStack(spacing: 5) {
Image(systemName: icon)
.font(.system(size: 8))
.foregroundStyle(active ? LP.accent : LP.inkTertiary)
.frame(width: 11)
Text(text)
.font(.system(size: 9))
.foregroundStyle(active ? LP.inkSecondary : LP.inkTertiary)
.lineLimit(1)
}
}
private func weekdayShort(_ weekday: Int) -> String {
["", "So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"][max(0, min(7, weekday))]
}
}
@@ -0,0 +1,231 @@
import SwiftUI
import LektorenPlanCore
struct TemplateEditorSheet: View {
@EnvironmentObject private var model: PlanModel
@Environment(\.dismiss) private var dismiss
let request: TemplateEditorRequest
@State private var churchID = ""
@State private var weekday = 1
@State private var timeDate = Date()
@State private var title = ""
@State private var lectorsNeeded = 1
@State private var helpersNeeded = 1
@State private var validFrom = DayMath.today()
@State private var hasValidTo = false
@State private var validTo = DayMath.adding(years: 1, to: DayMath.today())
@State private var active = true
@State private var notes = ""
@State private var confirmDelete = false
private var isEditing: Bool { request.template != nil }
private var isValid: Bool {
!churchID.isEmpty && !title.trimmingCharacters(in: .whitespaces).isEmpty
&& (lectorsNeeded + helpersNeeded) > 0
}
private var weekdayOptions: [(Int, String)] {
[(1, "Sonntag"), (2, "Montag"), (3, "Dienstag"), (4, "Mittwoch"),
(5, "Donnerstag"), (6, "Freitag"), (7, "Samstag")]
}
var body: some View {
VStack(spacing: 0) {
SheetHeader(
icon: "building.columns",
title: isEditing ? "Gottesdienst bearbeiten" : "Neuer regelmäßiger Gottesdienst",
subtitle: "Wiederkehrender Termin der Gottesdienstordnung inklusive benötigter Dienste."
)
Hairline()
ScrollView {
VStack(alignment: .leading, spacing: 22) {
FormSection(title: "Ort & Zeit") {
HStack(spacing: 12) {
LabeledField(label: "Kirche") {
Picker("", selection: $churchID) {
ForEach(model.churches) { church in
Text(church.name).tag(church.id)
}
}
.labelsHidden()
.pickerStyle(.menu)
}
LabeledField(label: "Wochentag") {
Picker("", selection: $weekday) {
ForEach(weekdayOptions, id: \.0) { option in
Text(option.1).tag(option.0)
}
}
.labelsHidden()
.pickerStyle(.menu)
}
LabeledField(label: "Uhrzeit") {
DatePicker("", selection: $timeDate, displayedComponents: .hourAndMinute)
.labelsHidden()
.datePickerStyle(.field)
}
}
LabeledField(label: "Bezeichnung") {
TextField("z. B. Hochamt, Vorabendmesse, Wort-Gottes-Feier", text: $title)
.textFieldStyle(.roundedBorder)
}
}
FormSection(
title: "Benötigte Dienste",
subtitle: "Wie viele Personen werden pro Termin eingeplant?"
) {
HStack(spacing: 26) {
HStack(spacing: 8) {
RoleBadge(role: .lector)
Stepper(value: $lectorsNeeded, in: 0...4) {
Text("\(lectorsNeeded)")
.font(.system(size: 12, weight: .semibold, design: .rounded))
.monospacedDigit()
}
.fixedSize()
}
HStack(spacing: 8) {
RoleBadge(role: .helper)
Stepper(value: $helpersNeeded, in: 0...4) {
Text("\(helpersNeeded)")
.font(.system(size: 12, weight: .semibold, design: .rounded))
.monospacedDigit()
}
.fixedSize()
}
Spacer()
}
}
FormSection(title: "Gültigkeit") {
HStack(spacing: 12) {
LabeledField(label: "Gültig ab") {
DatePicker("", selection: $validFrom, displayedComponents: .date)
.labelsHidden()
.datePickerStyle(.field)
}
Toggle(isOn: $hasValidTo) {
Text("Befristet")
.font(.system(size: 10.5, weight: .medium))
}
.toggleStyle(.checkbox)
if hasValidTo {
LabeledField(label: "Gültig bis") {
DatePicker("", selection: $validTo, displayedComponents: .date)
.labelsHidden()
.datePickerStyle(.field)
}
}
Spacer()
}
Toggle(isOn: $active) {
Text("Vorlage aktiv – Termine werden bei der Erzeugung berücksichtigt")
.font(.system(size: 10.5, weight: .medium))
.foregroundStyle(LP.inkSecondary)
}
.toggleStyle(.checkbox)
}
FormSection(title: "Notizen") {
TextEditor(text: $notes)
.font(.system(size: 11))
.frame(height: 58)
.padding(5)
.background(RoundedRectangle(cornerRadius: 7).fill(LP.card))
.overlay(RoundedRectangle(cornerRadius: 7).strokeBorder(LP.line.opacity(0.8), lineWidth: 1))
}
}
.padding(22)
}
SheetFooter {
if isEditing {
Button {
confirmDelete = true
} label: {
HStack(spacing: 5) {
Image(systemName: "trash")
Text("Vorlage löschen")
}
.font(.system(size: 11.5, weight: .medium))
.foregroundStyle(LP.danger)
}
.buttonStyle(.plain)
}
Spacer()
SecondaryActionButton(title: "Abbrechen", icon: "xmark") { dismiss() }
PrimaryActionButton(title: "Speichern", icon: "checkmark", action: save, disabled: !isValid)
}
}
.sheetSurface(width: 620, height: 620)
.onAppear(perform: load)
.confirmationDialog(
"Vorlage löschen?",
isPresented: $confirmDelete,
titleVisibility: .visible
) {
Button("Vorlage löschen", role: .destructive) {
if let template = request.template {
model.deleteTemplate(template)
}
dismiss()
}
Button("Abbrechen", role: .cancel) {}
} message: {
Text("Bereits erzeugte Termine bleiben erhalten. Künftige Termine dieser Vorlage entfallen.")
}
}
private func load() {
churchID = request.template?.churchID ?? request.churchID ?? model.churches.first?.id ?? ""
guard let template = request.template else {
weekday = DayMath.weekday(DayMath.today())
timeDate = timeDateFor(minutes: 9 * 60 + 30)
title = "Hochamt"
return
}
weekday = template.weekday
timeDate = timeDateFor(minutes: template.timeMinutes)
title = template.title
lectorsNeeded = template.lectorsNeeded
helpersNeeded = template.helpersNeeded
validFrom = template.validFrom
if let end = template.validTo {
hasValidTo = true
validTo = end
}
active = template.active
notes = template.notes
}
private func timeDateFor(minutes: Int) -> Date {
let start = DayMath.today()
return DayMath.calendar.date(bySettingHour: minutes / 60, minute: minutes % 60, second: 0, of: start) ?? start
}
private func save() {
let comps = DayMath.calendar.dateComponents([.hour, .minute], from: timeDate)
let minutes = (comps.hour ?? 9) * 60 + (comps.minute ?? 30)
let template = ServiceTemplate(
id: request.template?.id ?? UUID().uuidString,
churchID: churchID,
weekday: weekday,
timeMinutes: minutes,
title: title.trimmingCharacters(in: .whitespaces),
lectorsNeeded: lectorsNeeded,
helpersNeeded: helpersNeeded,
validFrom: validFrom,
validTo: hasValidTo ? validTo : nil,
active: active,
notes: notes.trimmingCharacters(in: .whitespacesAndNewlines)
)
model.saveTemplate(template)
dismiss()
}
}
+756
View File
@@ -0,0 +1,756 @@
import Foundation
public final class AppDatabase {
public let database: SQLiteDatabase
public let path: String
private let encoder = JSONEncoder()
private let decoder = JSONDecoder()
public init(path: String, seedDemo: Bool = true) throws {
self.path = path
self.database = try SQLiteDatabase(path: path)
try migrate()
if seedDemo, try churchCount() == 0 {
try DemoData.seed(into: self)
}
}
public static func defaultPath() -> String {
let fm = FileManager.default
let base = fm.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
?? fm.homeDirectoryForCurrentUser.appendingPathComponent("Library/Application Support")
let folder = base.appendingPathComponent("LektorenPlan", isDirectory: true)
try? fm.createDirectory(at: folder, withIntermediateDirectories: true)
return folder.appendingPathComponent("lektorenplan.sqlite").path
}
public static func makeInMemory(seedDemo: Bool = false) throws -> AppDatabase {
try AppDatabase(path: ":memory:", seedDemo: seedDemo)
}
private func migrate() throws {
let schema = """
CREATE TABLE IF NOT EXISTS churches (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
short_name TEXT NOT NULL,
symbol TEXT NOT NULL,
color_hex TEXT NOT NULL,
address TEXT NOT NULL DEFAULT '',
sort_index INTEGER NOT NULL DEFAULT 0,
notes TEXT NOT NULL DEFAULT ''
);
CREATE TABLE IF NOT EXISTS people (
id TEXT PRIMARY KEY,
first_name TEXT NOT NULL,
last_name TEXT NOT NULL,
roles TEXT NOT NULL,
email TEXT NOT NULL DEFAULT '',
phone TEXT NOT NULL DEFAULT '',
preferred_church_ids TEXT NOT NULL DEFAULT '[]',
preferred_weekdays TEXT NOT NULL DEFAULT '[]',
preferred_service_titles TEXT NOT NULL DEFAULT '[]',
max_per_month INTEGER NOT NULL DEFAULT 6,
active INTEGER NOT NULL DEFAULT 1,
notes TEXT NOT NULL DEFAULT ''
);
CREATE TABLE IF NOT EXISTS absences (
id TEXT PRIMARY KEY,
person_id TEXT NOT NULL REFERENCES people(id) ON DELETE CASCADE,
start_date TEXT NOT NULL,
end_date TEXT NOT NULL,
reason TEXT NOT NULL DEFAULT ''
);
CREATE INDEX IF NOT EXISTS idx_absences_person ON absences(person_id);
CREATE TABLE IF NOT EXISTS service_templates (
id TEXT PRIMARY KEY,
church_id TEXT NOT NULL REFERENCES churches(id) ON DELETE CASCADE,
weekday INTEGER NOT NULL,
time_minutes INTEGER NOT NULL,
title TEXT NOT NULL,
lectors_needed INTEGER NOT NULL DEFAULT 1,
helpers_needed INTEGER NOT NULL DEFAULT 1,
valid_from TEXT NOT NULL,
valid_to TEXT,
active INTEGER NOT NULL DEFAULT 1,
notes TEXT NOT NULL DEFAULT ''
);
CREATE INDEX IF NOT EXISTS idx_templates_church ON service_templates(church_id);
CREATE TABLE IF NOT EXISTS service_exceptions (
id TEXT PRIMARY KEY,
template_id TEXT NOT NULL REFERENCES service_templates(id) ON DELETE CASCADE,
date TEXT NOT NULL,
reason TEXT NOT NULL DEFAULT '',
UNIQUE(template_id, date)
);
CREATE TABLE IF NOT EXISTS services (
id TEXT PRIMARY KEY,
church_id TEXT NOT NULL REFERENCES churches(id) ON DELETE CASCADE,
template_id TEXT REFERENCES service_templates(id) ON DELETE SET NULL,
date TEXT NOT NULL,
time_minutes INTEGER NOT NULL,
title TEXT NOT NULL,
lectors_needed INTEGER NOT NULL DEFAULT 1,
helpers_needed INTEGER NOT NULL DEFAULT 1,
kind TEXT NOT NULL DEFAULT 'regular',
notes TEXT NOT NULL DEFAULT '',
locked INTEGER NOT NULL DEFAULT 0,
created_at TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_services_date ON services(date);
CREATE INDEX IF NOT EXISTS idx_services_church ON services(church_id);
CREATE UNIQUE INDEX IF NOT EXISTS idx_services_template_date
ON services(template_id, date) WHERE template_id IS NOT NULL;
CREATE TABLE IF NOT EXISTS assignments (
id TEXT PRIMARY KEY,
service_id TEXT NOT NULL REFERENCES services(id) ON DELETE CASCADE,
person_id TEXT NOT NULL REFERENCES people(id) ON DELETE CASCADE,
role TEXT NOT NULL,
locked INTEGER NOT NULL DEFAULT 0,
note TEXT NOT NULL DEFAULT '',
created_at TEXT NOT NULL,
UNIQUE(service_id, person_id, role)
);
CREATE INDEX IF NOT EXISTS idx_assignments_service ON assignments(service_id);
CREATE INDEX IF NOT EXISTS idx_assignments_person ON assignments(person_id);
CREATE TABLE IF NOT EXISTS liturgical_days (
date TEXT PRIMARY KEY,
title TEXT NOT NULL,
rank TEXT NOT NULL DEFAULT '',
color TEXT NOT NULL DEFAULT 'g',
remark TEXT NOT NULL DEFAULT '',
first_reading TEXT NOT NULL DEFAULT '',
psalm TEXT NOT NULL DEFAULT '',
second_reading TEXT NOT NULL DEFAULT '',
gospel TEXT NOT NULL DEFAULT '',
is_obligation INTEGER NOT NULL DEFAULT 0,
source TEXT NOT NULL DEFAULT '',
updated_at TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_liturgical_date ON liturgical_days(date);
CREATE TABLE IF NOT EXISTS settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);
"""
try database.execute(schema)
try database.run("INSERT OR IGNORE INTO settings(key, value) VALUES('schemaVersion', '1')")
}
// MARK: - Churches
public func churchCount() throws -> Int {
try database.scalarInt("SELECT COUNT(*) AS value FROM churches")
}
public func churches() throws -> [Church] {
try database.query("SELECT * FROM churches ORDER BY sort_index, name").compactMap { row in
guard let id = row.string("id"),
let name = row.string("name"),
let shortName = row.string("short_name"),
let symbolRaw = row.string("symbol")
else { return nil }
return Church(
id: id,
name: name,
shortName: shortName,
symbol: ChurchSymbol(rawValue: symbolRaw) ?? .chapel,
colorHex: row.string("color_hex", default: "#2F5D62"),
address: row.string("address", default: ""),
sortIndex: row.int("sort_index", default: 0),
notes: row.string("notes", default: "")
)
}
}
public func upsert(_ church: Church) throws {
try database.run("""
INSERT INTO churches(id, name, short_name, symbol, color_hex, address, sort_index, notes)
VALUES(?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET
name=excluded.name, short_name=excluded.short_name, symbol=excluded.symbol,
color_hex=excluded.color_hex, address=excluded.address,
sort_index=excluded.sort_index, notes=excluded.notes
""", [
.text(church.id), .text(church.name), .text(church.shortName),
.text(church.symbol.rawValue), .text(church.colorHex), .text(church.address),
.int(church.sortIndex), .text(church.notes)
])
}
public func deleteChurch(id: String) throws {
try database.run("DELETE FROM churches WHERE id=?", [.text(id)])
}
// MARK: - People
public func people() throws -> [Person] {
try database.query("SELECT * FROM people ORDER BY last_name, first_name").compactMap { decodePerson($0) }
}
public func person(id: String) throws -> Person? {
try database.query("SELECT * FROM people WHERE id=?", [.text(id)]).first.flatMap(decodePerson)
}
public func upsert(_ person: Person) throws {
let roles = encode(person.roles.map(\.rawValue).sorted())
let churches = encode(person.preferredChurchIDs.sorted())
let weekdays = encode(person.preferredWeekdays.sorted())
let titles = encode(person.preferredServiceTitles)
try database.run("""
INSERT INTO people(id, first_name, last_name, roles, email, phone, preferred_church_ids,
preferred_weekdays, preferred_service_titles, max_per_month, active, notes)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET
first_name=excluded.first_name, last_name=excluded.last_name, roles=excluded.roles,
email=excluded.email, phone=excluded.phone,
preferred_church_ids=excluded.preferred_church_ids,
preferred_weekdays=excluded.preferred_weekdays,
preferred_service_titles=excluded.preferred_service_titles,
max_per_month=excluded.max_per_month, active=excluded.active, notes=excluded.notes
""", [
.text(person.id), .text(person.firstName), .text(person.lastName), .text(roles),
.text(person.email), .text(person.phone), .text(churches), .text(weekdays),
.text(titles), .int(person.maxPerMonth), .bool(person.active), .text(person.notes)
])
}
public func deletePerson(id: String) throws {
try database.run("DELETE FROM people WHERE id=?", [.text(id)])
}
private func decodePerson(_ row: SQLiteRow) -> Person? {
guard let id = row.string("id"),
let first = row.string("first_name"),
let last = row.string("last_name")
else { return nil }
let roleStrings: [String] = decode(row.string("roles", default: "[]"))
return Person(
id: id,
firstName: first,
lastName: last,
roles: Set(roleStrings.compactMap(Role.init(rawValue:))),
email: row.string("email", default: ""),
phone: row.string("phone", default: ""),
preferredChurchIDs: Set(decode(row.string("preferred_church_ids", default: "[]")) as [String]),
preferredWeekdays: Set(decode(row.string("preferred_weekdays", default: "[]")) as [Int]),
preferredServiceTitles: decode(row.string("preferred_service_titles", default: "[]")),
maxPerMonth: row.int("max_per_month", default: 6),
active: row.bool("active", default: true),
notes: row.string("notes", default: "")
)
}
// MARK: - Absences
public func absences() throws -> [Absence] {
try database.query("SELECT * FROM absences ORDER BY start_date").compactMap { row in
guard let id = row.string("id"), let personID = row.string("person_id"),
let start = row.date("start_date"), let end = row.date("end_date")
else { return nil }
return Absence(id: id, personID: personID, start: start, end: end, reason: row.string("reason", default: ""))
}
}
public func absences(personID: String) throws -> [Absence] {
try database.query("SELECT * FROM absences WHERE person_id=? ORDER BY start_date", [.text(personID)]).compactMap { row in
guard let id = row.string("id"), let start = row.date("start_date"), let end = row.date("end_date") else { return nil }
return Absence(id: id, personID: personID, start: start, end: end, reason: row.string("reason", default: ""))
}
}
public func upsert(_ absence: Absence) throws {
try database.run("""
INSERT INTO absences(id, person_id, start_date, end_date, reason) VALUES(?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET person_id=excluded.person_id, start_date=excluded.start_date,
end_date=excluded.end_date, reason=excluded.reason
""", [
.text(absence.id), .text(absence.personID), .dateKey(absence.start),
.dateKey(absence.end), .text(absence.reason)
])
}
public func deleteAbsence(id: String) throws {
try database.run("DELETE FROM absences WHERE id=?", [.text(id)])
}
// MARK: - Service templates
public func templates() throws -> [ServiceTemplate] {
try database.query("SELECT * FROM service_templates ORDER BY weekday, time_minutes").compactMap { row in
guard let id = row.string("id"), let churchID = row.string("church_id"),
let title = row.string("title"), let from = row.date("valid_from")
else { return nil }
return ServiceTemplate(
id: id,
churchID: churchID,
weekday: row.int("weekday", default: 1),
timeMinutes: row.int("time_minutes", default: 600),
title: title,
lectorsNeeded: row.int("lectors_needed", default: 1),
helpersNeeded: row.int("helpers_needed", default: 1),
validFrom: from,
validTo: row.date("valid_to"),
active: row.bool("active", default: true),
notes: row.string("notes", default: "")
)
}
}
public func upsert(_ template: ServiceTemplate) throws {
try database.run("""
INSERT INTO service_templates(id, church_id, weekday, time_minutes, title, lectors_needed,
helpers_needed, valid_from, valid_to, active, notes)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET church_id=excluded.church_id, weekday=excluded.weekday,
time_minutes=excluded.time_minutes, title=excluded.title,
lectors_needed=excluded.lectors_needed, helpers_needed=excluded.helpers_needed,
valid_from=excluded.valid_from, valid_to=excluded.valid_to,
active=excluded.active, notes=excluded.notes
""", [
.text(template.id), .text(template.churchID), .int(template.weekday),
.int(template.timeMinutes), .text(template.title), .int(template.lectorsNeeded),
.int(template.helpersNeeded), .dateKey(template.validFrom),
template.validTo.map(SQLiteValue.dateKey) ?? .null,
.bool(template.active), .text(template.notes)
])
}
public func deleteTemplate(id: String) throws {
try database.run("DELETE FROM service_templates WHERE id=?", [.text(id)])
}
// MARK: - Exceptions
public func exceptions() throws -> [ServiceException] {
try database.query("SELECT * FROM service_exceptions ORDER BY date").compactMap { row in
guard let id = row.string("id"), let templateID = row.string("template_id"), let date = row.date("date") else { return nil }
return ServiceException(id: id, templateID: templateID, date: date, reason: row.string("reason", default: ""))
}
}
public func upsert(_ exception: ServiceException) throws {
try database.run("""
INSERT INTO service_exceptions(id, template_id, date, reason) VALUES(?, ?, ?, ?)
ON CONFLICT(template_id, date) DO UPDATE SET reason=excluded.reason
""", [.text(exception.id), .text(exception.templateID), .dateKey(exception.date), .text(exception.reason)])
}
public func deleteException(id: String) throws {
try database.run("DELETE FROM service_exceptions WHERE id=?", [.text(id)])
}
// MARK: - Services
public func services(in range: DayRange) throws -> [ServiceOccurrence] {
try database.query("""
SELECT * FROM services WHERE date >= ? AND date <= ?
ORDER BY date, time_minutes, church_id
""", [.dateKey(range.start), .dateKey(range.end)]).compactMap(decodeService)
}
public func services(on date: Date) throws -> [ServiceOccurrence] {
try database.query("SELECT * FROM services WHERE date=? ORDER BY time_minutes", [.dateKey(date)]).compactMap(decodeService)
}
public func service(id: String) throws -> ServiceOccurrence? {
try database.query("SELECT * FROM services WHERE id=?", [.text(id)]).first.flatMap(decodeService)
}
public func specialServices() throws -> [ServiceOccurrence] {
try database.query("SELECT * FROM services WHERE kind='special' ORDER BY date, time_minutes").compactMap(decodeService)
}
public func serviceCount() throws -> Int {
try database.scalarInt("SELECT COUNT(*) AS value FROM services")
}
public func upsert(_ service: ServiceOccurrence) throws {
try database.run("""
INSERT INTO services(id, church_id, template_id, date, time_minutes, title, lectors_needed,
helpers_needed, kind, notes, locked, created_at)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET church_id=excluded.church_id, template_id=excluded.template_id,
date=excluded.date, time_minutes=excluded.time_minutes, title=excluded.title,
lectors_needed=excluded.lectors_needed, helpers_needed=excluded.helpers_needed,
kind=excluded.kind, notes=excluded.notes, locked=excluded.locked
""", [
.text(service.id), .text(service.churchID), service.templateID.map(SQLiteValue.text) ?? .null,
.dateKey(service.date), .int(service.timeMinutes), .text(service.title),
.int(service.lectorsNeeded), .int(service.helpersNeeded), .text(service.kind.rawValue),
.text(service.notes), .bool(service.locked), .text(ISO8601DateFormatter().string(from: service.createdAt))
])
}
public func deleteService(id: String) throws {
try database.run("DELETE FROM services WHERE id=?", [.text(id)])
}
private func decodeService(_ row: SQLiteRow) -> ServiceOccurrence? {
guard let id = row.string("id"), let churchID = row.string("church_id"),
let date = row.date("date"), let title = row.string("title")
else { return nil }
return ServiceOccurrence(
id: id,
churchID: churchID,
templateID: row.string("template_id"),
date: date,
timeMinutes: row.int("time_minutes", default: 600),
title: title,
lectorsNeeded: row.int("lectors_needed", default: 1),
helpersNeeded: row.int("helpers_needed", default: 1),
kind: ServiceKind(rawValue: row.string("kind", default: "regular")) ?? .regular,
notes: row.string("notes", default: ""),
locked: row.bool("locked", default: false),
createdAt: ISO8601DateFormatter().date(from: row.string("created_at", default: "")) ?? Date()
)
}
/// Generates regular occurrences from the current service order. Existing occurrences
/// that already have assignments are never overwritten.
@discardableResult
public func generateServices(in range: DayRange, regenerateUnassigned: Bool = true) throws -> Int {
let allTemplates = try templates()
let allExceptions = try exceptions()
let exceptionKeys = Set(allExceptions.map { "\($0.templateID)|\(DayMath.key($0.date))" })
let existing = try services(in: range)
var existingByTemplate: [String: ServiceOccurrence] = [:]
for service in existing {
if let templateID = service.templateID {
existingByTemplate["\(templateID)|\(service.dateKey)"] = service
}
}
var created = 0
try database.transaction {
for day in range.days {
for template in allTemplates where template.isValid(on: day) {
let key = "\(template.id)|\(DayMath.key(day))"
if exceptionKeys.contains(key) { continue }
if let existing = existingByTemplate[key] {
guard regenerateUnassigned else { continue }
let assignmentCount = try assignmentCount(serviceID: existing.id)
if assignmentCount == 0 {
var updated = existing
updated.timeMinutes = template.timeMinutes
updated.title = template.title
updated.lectorsNeeded = template.lectorsNeeded
updated.helpersNeeded = template.helpersNeeded
try upsert(updated)
}
continue
}
let service = ServiceOccurrence(
churchID: template.churchID,
templateID: template.id,
date: day,
timeMinutes: template.timeMinutes,
title: template.title,
lectorsNeeded: template.lectorsNeeded,
helpersNeeded: template.helpersNeeded,
kind: .regular,
notes: template.notes
)
try upsert(service)
created += 1
}
}
}
return created
}
private func assignmentCount(serviceID: String) throws -> Int {
try database.scalarInt("SELECT COUNT(*) AS value FROM assignments WHERE service_id=?", [.text(serviceID)])
}
// MARK: - Assignments
public func assignments(in range: DayRange) throws -> [Assignment] {
try database.query("""
SELECT a.* FROM assignments a JOIN services s ON s.id = a.service_id
WHERE s.date >= ? AND s.date <= ?
ORDER BY s.date, s.time_minutes
""", [.dateKey(range.start), .dateKey(range.end)]).compactMap(decodeAssignment)
}
public func assignments(serviceIDs: [String]) throws -> [Assignment] {
guard !serviceIDs.isEmpty else { return [] }
let placeholders = Array(repeating: "?", count: serviceIDs.count).joined(separator: ",")
return try database.query(
"SELECT * FROM assignments WHERE service_id IN (\(placeholders))",
serviceIDs.map(SQLiteValue.text)
).compactMap(decodeAssignment)
}
public func assignments(personID: String) throws -> [Assignment] {
try database.query("SELECT * FROM assignments WHERE person_id=?", [.text(personID)]).compactMap(decodeAssignment)
}
public func assignmentCount() throws -> Int {
try database.scalarInt("SELECT COUNT(*) AS value FROM assignments")
}
public func upsert(_ assignment: Assignment) throws {
try database.run("""
INSERT INTO assignments(id, service_id, person_id, role, locked, note, created_at)
VALUES(?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET service_id=excluded.service_id, person_id=excluded.person_id,
role=excluded.role, locked=excluded.locked, note=excluded.note
""", [
.text(assignment.id), .text(assignment.serviceID), .text(assignment.personID),
.text(assignment.role.rawValue), .bool(assignment.locked), .text(assignment.note),
.text(ISO8601DateFormatter().string(from: assignment.createdAt))
])
}
/// Replaces the assignment for one role of a service. Passing nil clears the slot.
public func setAssignment(serviceID: String, role: Role, personID: String?, locked: Bool = false) throws {
try database.transaction {
try database.run("DELETE FROM assignments WHERE service_id=? AND role=?", [.text(serviceID), .text(role.rawValue)])
guard let personID else { return }
let assignment = Assignment(serviceID: serviceID, personID: personID, role: role, locked: locked)
try upsert(assignment)
}
}
public func setAssignment(serviceID: String, personID: String?, role: Role, locked: Bool = false) throws {
try setAssignment(serviceID: serviceID, role: role, personID: personID, locked: locked)
}
public func deleteAssignment(id: String) throws {
try database.run("DELETE FROM assignments WHERE id=?", [.text(id)])
}
public func toggleAssignmentLock(id: String) throws {
try database.run("UPDATE assignments SET locked = CASE locked WHEN 0 THEN 1 ELSE 0 END WHERE id=?", [.text(id)])
}
public func savePlan(_ assignments: [Assignment], in range: DayRange, replaceUnlocked: Bool) throws {
let serviceIDs = try services(in: range).map(\.id)
try database.transaction {
if replaceUnlocked, !serviceIDs.isEmpty {
let placeholders = Array(repeating: "?", count: serviceIDs.count).joined(separator: ",")
try database.run(
"DELETE FROM assignments WHERE locked=0 AND service_id IN (\(placeholders))",
serviceIDs.map(SQLiteValue.text)
)
}
for assignment in assignments {
try upsert(assignment)
}
}
}
private func decodeAssignment(_ row: SQLiteRow) -> Assignment? {
guard let id = row.string("id"), let serviceID = row.string("service_id"),
let personID = row.string("person_id"), let roleRaw = row.string("role"),
let role = Role(rawValue: roleRaw)
else { return nil }
return Assignment(
id: id,
serviceID: serviceID,
personID: personID,
role: role,
locked: row.bool("locked", default: false),
note: row.string("note", default: ""),
createdAt: ISO8601DateFormatter().date(from: row.string("created_at", default: "")) ?? Date()
)
}
// MARK: - Liturgical days
public func liturgicalDays(in range: DayRange) throws -> [LiturgicalDay] {
try database.query("SELECT * FROM liturgical_days WHERE date >= ? AND date <= ? ORDER BY date",
[.dateKey(range.start), .dateKey(range.end)]).compactMap(decodeLiturgicalDay)
}
public func liturgicalDay(on date: Date) throws -> LiturgicalDay? {
try database.query("SELECT * FROM liturgical_days WHERE date=?", [.dateKey(date)]).first.flatMap(decodeLiturgicalDay)
}
public func liturgicalDayCount() throws -> Int {
try database.scalarInt("SELECT COUNT(*) AS value FROM liturgical_days")
}
public func liturgicalYears() throws -> [Int] {
try database.query("SELECT DISTINCT substr(date,1,4) AS year FROM liturgical_days ORDER BY year").compactMap {
Int($0.string("year", default: "0"))
}
}
public func upsert(liturgicalDay: LiturgicalDay) throws {
try database.run("""
INSERT INTO liturgical_days(date, title, rank, color, remark, first_reading, psalm,
second_reading, gospel, is_obligation, source, updated_at)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(date) DO UPDATE SET title=excluded.title, rank=excluded.rank, color=excluded.color,
remark=excluded.remark, first_reading=excluded.first_reading, psalm=excluded.psalm,
second_reading=excluded.second_reading, gospel=excluded.gospel,
is_obligation=excluded.is_obligation, source=excluded.source, updated_at=excluded.updated_at
""", [
.dateKey(liturgicalDay.date), .text(liturgicalDay.title), .text(liturgicalDay.rank.rawValue),
.text(liturgicalDay.color.rawValue), .text(liturgicalDay.remark),
.text(liturgicalDay.readings.first), .text(liturgicalDay.readings.psalm),
.text(liturgicalDay.readings.second), .text(liturgicalDay.readings.gospel),
.bool(liturgicalDay.isObligation), .text(liturgicalDay.source),
.text(ISO8601DateFormatter().string(from: liturgicalDay.updatedAt))
])
}
public func upsert(liturgicalDays days: [LiturgicalDay]) throws {
try database.transaction {
for day in days { try upsert(liturgicalDay: day) }
}
}
public func replaceLiturgicalYear(_ year: Int, with days: [LiturgicalDay]) throws {
try database.transaction {
try database.run("DELETE FROM liturgical_days WHERE date LIKE ?", [.text("\(year)-%")])
for day in days { try upsert(liturgicalDay: day) }
}
}
private func decodeLiturgicalDay(_ row: SQLiteRow) -> LiturgicalDay? {
guard let date = row.date("date") else { return nil }
return LiturgicalDay(
date: date,
title: row.string("title", default: ""),
rank: LiturgicalRank(rawValue: row.string("rank", default: "")) ?? .weekday,
color: LiturgicalColor(rawValue: row.string("color", default: "g")) ?? .green,
remark: row.string("remark", default: ""),
readings: Readings(
first: row.string("first_reading", default: ""),
psalm: row.string("psalm", default: ""),
second: row.string("second_reading", default: ""),
gospel: row.string("gospel", default: "")
),
isObligation: row.bool("is_obligation"),
source: row.string("source", default: ""),
updatedAt: ISO8601DateFormatter().date(from: row.string("updated_at", default: "")) ?? Date()
)
}
// MARK: - Settings
public func setting(_ key: String) -> String? {
guard let row = try? database.query("SELECT value FROM settings WHERE key=?", [.text(key)]).first else { return nil }
return row.string("value")
}
public func setSetting(_ key: String, value: String) {
try? database.run("INSERT INTO settings(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value",
[.text(key), .text(value)])
}
public func removeSetting(_ key: String) {
try? database.run("DELETE FROM settings WHERE key=?", [.text(key)])
}
// MARK: - Resources / exchange
public func resources() throws -> ResourceBundle {
ResourceBundle(
churches: try churches(),
people: try people(),
absences: try absences(),
templates: try templates(),
exceptions: try exceptions()
)
}
public func applyResourceBundle(_ bundle: ResourceBundle, replaceExisting: Bool = false) throws {
try database.transaction {
if replaceExisting {
for template in try templates() { try deleteTemplate(id: template.id) }
for person in try people() { try deletePerson(id: person.id) }
for church in try churches() { try deleteChurch(id: church.id) }
}
for church in bundle.churches { try upsert(church) }
for person in bundle.people { try upsert(person) }
for absence in bundle.absences { try upsert(absence) }
for template in bundle.templates { try upsert(template) }
for exception in bundle.exceptions { try upsert(exception) }
}
}
public func exportPlan(range: DayRange, scope: ExchangeScope = .plan) throws -> PlanExchange {
let services = scope == .resources ? [] : try services(in: range)
let serviceIDs = services.map(\.id)
let assignments = scope == .resources ? [] : try assignments(serviceIDs: serviceIDs)
let peopleIDs = Set(assignments.map(\.personID))
let allPeople = try people()
let relevantPeople = scope == .resources ? allPeople : allPeople.filter { peopleIDs.contains($0.id) }
let allAbsences = try absences()
let relevantAbsences = scope == .resources ? allAbsences : allAbsences.filter { peopleIDs.contains($0.personID) }
return PlanExchange(
scope: scope,
range: range,
resources: ResourceBundle(
churches: try churches(),
people: relevantPeople,
absences: relevantAbsences,
templates: try templates(),
exceptions: try exceptions()
),
services: services,
assignments: assignments,
liturgicalDays: scope == .resources ? [] : try liturgicalDays(in: range),
note: "Export aus LektorenPlan · \(DayMath.key(range.start)) bis \(DayMath.key(range.end))"
)
}
public func applyPlanExchange(_ exchange: PlanExchange) throws -> ExchangeSummary {
try database.transaction {
for church in exchange.resources.churches { try upsert(church) }
for person in exchange.resources.people { try upsert(person) }
for absence in exchange.resources.absences { try upsert(absence) }
for template in exchange.resources.templates { try upsert(template) }
for exception in exchange.resources.exceptions { try upsert(exception) }
for day in exchange.liturgicalDays { try upsert(liturgicalDay: day) }
for service in exchange.services { try upsert(service) }
for assignment in exchange.assignments { try upsert(assignment) }
}
return exchange.summary
}
// MARK: - Utilities
private func encode<T: Encodable>(_ value: T) -> String {
guard let data = try? encoder.encode(value) else { return "[]" }
return String(data: data, encoding: .utf8) ?? "[]"
}
private func decode<T: Decodable>(_ string: String) -> T {
guard let data = string.data(using: .utf8),
let value = try? decoder.decode(T.self, from: data)
else {
if T.self == [String].self { return [] as! T }
if T.self == [Int].self { return [] as! T }
return [] as! T
}
return value
}
public func resetDemoData() throws {
try database.execute("""
DELETE FROM assignments; DELETE FROM services; DELETE FROM service_exceptions;
DELETE FROM service_templates; DELETE FROM absences; DELETE FROM people;
DELETE FROM churches; DELETE FROM liturgical_days;
""")
try DemoData.seed(into: self)
}
public func databaseSizeBytes() -> Int {
guard path != ":memory:" else { return 0 }
let attributes = try? FileManager.default.attributesOfItem(atPath: path)
return (attributes?[.size] as? NSNumber)?.intValue ?? 0
}
}
+319
View File
@@ -0,0 +1,319 @@
import Foundation
/// All app dates are "calendar days" anchored at noon in the Europe/Berlin time zone.
/// Using noon avoids surprises around daylight-saving transitions while the ISO key
/// remains stable for persistence.
public enum DayMath {
public static var calendar: Calendar {
var cal = Calendar(identifier: .gregorian)
cal.locale = Locale(identifier: "de_DE")
cal.timeZone = TimeZone(identifier: "Europe/Berlin") ?? .current
cal.firstWeekday = 2
cal.minimumDaysInFirstWeek = 4
return cal
}
public static let germanLocale = Locale(identifier: "de_DE")
private static let keyFormatter: DateFormatter = {
let f = DateFormatter()
f.locale = Locale(identifier: "en_US_POSIX")
f.timeZone = TimeZone(identifier: "Europe/Berlin")
f.dateFormat = "yyyy-MM-dd"
return f
}()
private static let weekdayFormatter: DateFormatter = {
let f = DateFormatter()
f.locale = germanLocale
f.timeZone = TimeZone(identifier: "Europe/Berlin")
f.dateFormat = "EEEE"
return f
}()
private static let shortWeekdayFormatter: DateFormatter = {
let f = DateFormatter()
f.locale = germanLocale
f.timeZone = TimeZone(identifier: "Europe/Berlin")
f.dateFormat = "EEE"
return f
}()
private static let monthFormatter: DateFormatter = {
let f = DateFormatter()
f.locale = germanLocale
f.timeZone = TimeZone(identifier: "Europe/Berlin")
f.dateFormat = "MMMM"
return f
}()
private static let shortMonthFormatter: DateFormatter = {
let f = DateFormatter()
f.locale = germanLocale
f.timeZone = TimeZone(identifier: "Europe/Berlin")
f.dateFormat = "MMM"
return f
}()
private static let longFormatter: DateFormatter = {
let f = DateFormatter()
f.locale = germanLocale
f.timeZone = TimeZone(identifier: "Europe/Berlin")
f.dateFormat = "EEEE, d. MMMM yyyy"
return f
}()
private static let mediumFormatter: DateFormatter = {
let f = DateFormatter()
f.locale = germanLocale
f.timeZone = TimeZone(identifier: "Europe/Berlin")
f.dateFormat = "d. MMM yyyy"
return f
}()
public static func normalize(_ date: Date) -> Date {
let comps = calendar.dateComponents([.year, .month, .day], from: date)
return calendar.date(from: DateComponents(
timeZone: calendar.timeZone,
year: comps.year,
month: comps.month,
day: comps.day,
hour: 12
)) ?? date
}
public static func today() -> Date {
normalize(Date())
}
public static func date(fromKey key: String) -> Date? {
guard let date = keyFormatter.date(from: key) else { return nil }
return normalize(date)
}
public static func key(_ date: Date) -> String {
keyFormatter.string(from: date)
}
public static func key(year: Int, month: Int, day: Int) -> String {
String(format: "%04d-%02d-%02d", year, month, day)
}
public static func adding(days: Int, to date: Date) -> Date {
calendar.date(byAdding: .day, value: days, to: normalize(date)) ?? date
}
public static func adding(months: Int, to date: Date) -> Date {
calendar.date(byAdding: .month, value: months, to: normalize(date)) ?? date
}
public static func adding(years: Int, to date: Date) -> Date {
calendar.date(byAdding: .year, value: years, to: normalize(date)) ?? date
}
public static func daysBetween(_ start: Date, _ end: Date) -> Int {
calendar.dateComponents([.day], from: normalize(start), to: normalize(end)).day ?? 0
}
public static func days(in range: DayRange) -> [Date] {
guard range.start <= range.end else { return [] }
var result: [Date] = []
var cursor = normalize(range.start)
let end = normalize(range.end)
while cursor <= end {
result.append(cursor)
cursor = adding(days: 1, to: cursor)
}
return result
}
public static func weekday(_ date: Date) -> Int {
calendar.component(.weekday, from: normalize(date)) // 1 = Sunday … 7 = Saturday
}
public static func isSunday(_ date: Date) -> Bool {
weekday(date) == 1
}
public static func isSaturday(_ date: Date) -> Bool {
weekday(date) == 7
}
public static func weekdayName(_ date: Date) -> String {
weekdayFormatter.string(from: normalize(date))
}
public static func shortWeekdayName(_ date: Date) -> String {
shortWeekdayFormatter.string(from: normalize(date))
}
public static func monthName(_ date: Date) -> String {
monthFormatter.string(from: normalize(date))
}
public static func shortMonthName(_ date: Date) -> String {
shortMonthFormatter.string(from: normalize(date))
}
public static func longString(_ date: Date) -> String {
longFormatter.string(from: normalize(date))
}
public static func mediumString(_ date: Date) -> String {
mediumFormatter.string(from: normalize(date))
}
public static func dayNumber(_ date: Date) -> Int {
calendar.component(.day, from: normalize(date))
}
public static func month(_ date: Date) -> Int {
calendar.component(.month, from: normalize(date))
}
public static func year(_ date: Date) -> Int {
calendar.component(.year, from: normalize(date))
}
public static func startOfYear(_ date: Date) -> Date {
let y = year(date)
return calendar.date(from: DateComponents(timeZone: calendar.timeZone, year: y, month: 1, day: 1, hour: 12)) ?? date
}
public static func endOfYear(_ date: Date) -> Date {
let y = year(date)
return calendar.date(from: DateComponents(timeZone: calendar.timeZone, year: y, month: 12, day: 31, hour: 12)) ?? date
}
public static func startOfMonth(_ date: Date) -> Date {
let comps = calendar.dateComponents([.year, .month], from: date)
return calendar.date(from: DateComponents(
timeZone: calendar.timeZone, year: comps.year, month: comps.month, day: 1, hour: 12
)) ?? date
}
public static func endOfMonth(_ date: Date) -> Date {
let start = startOfMonth(date)
let next = adding(months: 1, to: start)
return adding(days: -1, to: next)
}
public static func startOfQuarter(_ date: Date) -> Date {
let m = month(date)
let quarterStartMonth = ((m - 1) / 3) * 3 + 1
return calendar.date(from: DateComponents(
timeZone: calendar.timeZone, year: year(date), month: quarterStartMonth, day: 1, hour: 12
)) ?? date
}
public static func endOfQuarter(_ date: Date) -> Date {
adding(days: -1, to: adding(months: 3, to: startOfQuarter(date)))
}
public static func quarter(_ date: Date) -> Int {
(month(date) - 1) / 3 + 1
}
public static func monthKey(_ date: Date) -> String {
String(format: "%04d-%02d", year(date), month(date))
}
public static func timeString(minutes: Int) -> String {
let h = max(0, min(23, minutes / 60))
let m = max(0, min(59, minutes % 60))
return String(format: "%02d:%02d", h, m)
}
public static func minutes(hour: Int, minute: Int) -> Int {
hour * 60 + minute
}
public static func ageString(from start: Date, to end: Date) -> String {
let days = abs(daysBetween(start, end)) + 1
return "\(days) Tage"
}
}
public struct DayRange: Hashable, Codable, Sendable, Identifiable {
public var start: Date
public var end: Date
public var id: String { "\(DayMath.key(start))_\(DayMath.key(end))" }
public init(start: Date, end: Date) {
let a = DayMath.normalize(start)
let b = DayMath.normalize(end)
if a <= b {
self.start = a
self.end = b
} else {
self.start = b
self.end = a
}
}
public init(startKey: String, endKey: String) {
let start = DayMath.date(fromKey: startKey) ?? DayMath.today()
let end = DayMath.date(fromKey: endKey) ?? start
self.init(start: start, end: end)
}
public static func quarter(containing date: Date) -> DayRange {
DayRange(start: DayMath.startOfQuarter(date), end: DayMath.endOfQuarter(date))
}
public static func year(_ year: Int) -> DayRange {
let start = DayMath.date(fromKey: DayMath.key(year: year, month: 1, day: 1)) ?? DayMath.today()
let end = DayMath.date(fromKey: DayMath.key(year: year, month: 12, day: 31)) ?? start
return DayRange(start: start, end: end)
}
public static func month(containing date: Date) -> DayRange {
DayRange(start: DayMath.startOfMonth(date), end: DayMath.endOfMonth(date))
}
public static func days(_ count: Int, from date: Date = DayMath.today()) -> DayRange {
DayRange(start: date, end: DayMath.adding(days: max(0, count - 1), to: date))
}
public var days: [Date] { DayMath.days(in: self) }
public var dayCount: Int { max(0, DayMath.daysBetween(start, end) + 1) }
public var monthCount: Int { max(1, (DayMath.year(end) - DayMath.year(start)) * 12 + DayMath.month(end) - DayMath.month(start) + 1) }
public var title: String {
if DayMath.year(start) == DayMath.year(end) {
return "\(DayMath.mediumString(start)) – \(DayMath.mediumString(end))"
}
return "\(DayMath.mediumString(start)) – \(DayMath.mediumString(end))"
}
public var shortTitle: String {
let startLabel = "\(DayMath.dayNumber(start)). \(DayMath.shortMonthName(start))"
let endLabel = "\(DayMath.dayNumber(end)). \(DayMath.shortMonthName(end))"
if DayMath.year(start) == DayMath.year(end) {
return "\(startLabel) – \(endLabel) \(DayMath.year(end))"
}
return "\(startLabel) \(DayMath.year(start)) – \(endLabel) \(DayMath.year(end))"
}
public func contains(_ date: Date) -> Bool {
let d = DayMath.normalize(date)
return d >= start && d <= end
}
public func clamped(to bounds: DayRange) -> DayRange {
DayRange(
start: max(start, bounds.start),
end: min(end, bounds.end)
)
}
public func extend(monthsBefore: Int, monthsAfter: Int) -> DayRange {
DayRange(
start: DayMath.adding(months: -monthsBefore, to: start),
end: DayMath.adding(months: monthsAfter, to: end)
)
}
}
+305
View File
@@ -0,0 +1,305 @@
import Foundation
/// Seeds a realistic working dataset for the parish area of Bad Godesberg.
/// All names, preferences and absences are fictional demo content.
public enum DemoData {
public static func seed(into db: AppDatabase) throws {
let churches = makeChurches()
for church in churches { try db.upsert(church) }
let people = makePeople()
for person in people { try db.upsert(person) }
for absence in makeAbsences() { try db.upsert(absence) }
let templates = makeTemplates()
for template in templates { try db.upsert(template) }
if try db.liturgicalDayCount() == 0 {
try db.upsert(liturgicalDays: LiturgicalSnapshot.loadBundled())
}
try db.generateServices(in: DayRange.year(2025))
try db.generateServices(in: DayRange.year(2026))
try db.generateServices(in: DayRange.year(2027))
try db.generateServices(in: DayRange.year(2028))
try addExceptions(to: db, templates: templates)
try addSpecialServices(to: db)
// Demo history: everything before today is planned, the future is left open
// so the planning workflow and the "offene Dienste" indicators are visible.
let today = DayMath.today()
let yesterday = DayMath.adding(days: -1, to: today)
let pastRange = DayRange(
start: DayMath.date(fromKey: "2025-01-01") ?? today,
end: yesterday
)
let pastServices = try db.services(in: pastRange)
let planner = ServicePlanner(
people: people,
absences: try db.absences(),
services: pastServices,
churches: churches,
options: PlannerOptions(
replaceExisting: true,
respectPreferredWeekdays: true,
weightFairness: 2.4,
maxAssignmentsPerDay: 1
)
)
let result = planner.plan()
try db.savePlan(result.assignments, in: pastRange, replaceUnlocked: true)
// A few locked assignments demonstrate protected planning.
let allAssignments = try db.assignments(in: pastRange)
for (index, assignment) in allAssignments.enumerated() where index % 41 == 0 {
try db.upsert(Assignment(
id: assignment.id,
serviceID: assignment.serviceID,
personID: assignment.personID,
role: assignment.role,
locked: true,
note: assignment.note,
createdAt: assignment.createdAt
))
}
db.setSetting("demoSeededAt", value: ISO8601DateFormatter().string(from: Date()))
db.setSetting("diocese", value: "koeln")
if db.setting("autoSyncLiturgy") == nil {
db.setSetting("autoSyncLiturgy", value: "1")
}
}
private static func makeChurches() -> [Church] {
[
Church(
id: Church.andreasID,
name: "St. Andreas",
shortName: "Andreas",
symbol: .basilica,
colorHex: "#9B5B44",
address: "Andreasstraße 1, 53179 Bonn",
sortIndex: 0,
notes: "Romanischer Kirchturm, Pfarrkirche im Rheinviertel"
),
Church(
id: Church.evergislusID,
name: "St. Evergislus",
shortName: "Evergislus",
symbol: .gothic,
colorHex: "#4E6E5D",
address: "Hardtstraße 13, 53175 Bonn",
sortIndex: 1,
notes: "Neugotische Kirche in Plittersdorf"
),
Church(
id: Church.herzJesuID,
name: "Herz Jesu",
shortName: "Herz Jesu",
symbol: .modern,
colorHex: "#7A5A78",
address: "Beethovenallee, 53173 Bonn",
sortIndex: 2,
notes: "Kirche im Villenviertel"
),
Church(
id: Church.hildegardID,
name: "St. Hildegard",
shortName: "Hildegard",
symbol: .rotunda,
colorHex: "#B0833C",
address: "Im Meisengarten, 53179 Bonn",
sortIndex: 3,
notes: "Rundkirche der 1960er Jahre in Rüngsdorf"
)
]
}
private static func makePeople() -> [Person] {
[
Person(id: "p-anna", firstName: "Anna", lastName: "Berg", roles: [.lector],
email: "anna.berg@example.org", phone: "0228 555 0101",
preferredChurchIDs: [Church.andreasID], preferredWeekdays: [1],
preferredServiceTitles: ["Hochamt"], maxPerMonth: 7,
notes: "Liest besonders gerne die Sonntagslesungen."),
Person(id: "p-markus", firstName: "Markus", lastName: "Weber", roles: [.lector],
email: "markus.weber@example.org", phone: "0228 555 0102",
preferredChurchIDs: [Church.herzJesuID], preferredWeekdays: [1, 7],
preferredServiceTitles: ["Vorabendmesse"], maxPerMonth: 8),
Person(id: "p-elisabeth", firstName: "Elisabeth", lastName: "Klein", roles: [.lector, .helper],
email: "elisabeth.klein@example.org", phone: "0228 555 0103",
preferredChurchIDs: [], preferredWeekdays: [], maxPerMonth: 9,
notes: "Flexibel einsetzbar, auch kurzfristig."),
Person(id: "p-johannes", firstName: "Johannes", lastName: "Schmitz", roles: [.lector],
email: "johannes.schmitz@example.org", preferredChurchIDs: [Church.evergislusID],
preferredWeekdays: [1], preferredServiceTitles: ["Hochamt"], maxPerMonth: 6),
Person(id: "p-maria", firstName: "Maria", lastName: "Hoffmann", roles: [.helper],
preferredChurchIDs: [Church.herzJesuID], preferredWeekdays: [1], maxPerMonth: 8),
Person(id: "p-peter", firstName: "Peter", lastName: "Lang", roles: [.helper],
preferredChurchIDs: [Church.hildegardID], preferredWeekdays: [1], maxPerMonth: 6),
Person(id: "p-susanne", firstName: "Susanne", lastName: "Vogel", roles: [.lector, .helper],
preferredChurchIDs: [Church.andreasID], preferredWeekdays: [1], maxPerMonth: 8),
Person(id: "p-thomas", firstName: "Thomas", lastName: "Neumann", roles: [.lector],
preferredChurchIDs: [], preferredWeekdays: [], maxPerMonth: 10,
notes: "Springerfunktion."),
Person(id: "p-claudia", firstName: "Claudia", lastName: "Roth", roles: [.helper],
preferredChurchIDs: [Church.evergislusID], preferredWeekdays: [1, 4], maxPerMonth: 7),
Person(id: "p-michael", firstName: "Michael", lastName: "Braun", roles: [.helper],
preferredChurchIDs: [Church.andreasID], preferredWeekdays: [1], maxPerMonth: 8),
Person(id: "p-julia", firstName: "Julia", lastName: "Schröder", roles: [.lector, .helper],
preferredChurchIDs: [Church.herzJesuID, Church.hildegardID], preferredWeekdays: [1, 7],
maxPerMonth: 8),
Person(id: "p-andreas", firstName: "Andreas", lastName: "Wolff", roles: [.lector],
preferredChurchIDs: [Church.hildegardID], preferredWeekdays: [1],
preferredServiceTitles: ["Wort-Gottes-Feier"], maxPerMonth: 6),
Person(id: "p-birgit", firstName: "Birgit", lastName: "Sauer", roles: [.helper],
preferredChurchIDs: [], preferredWeekdays: [], maxPerMonth: 9),
Person(id: "p-daniel", firstName: "Daniel", lastName: "Krüger", roles: [.lector],
preferredChurchIDs: [Church.herzJesuID, Church.andreasID], preferredWeekdays: [1, 2, 5],
maxPerMonth: 7),
Person(id: "p-petra", firstName: "Petra", lastName: "Sommer", roles: [.helper],
preferredChurchIDs: [Church.evergislusID, Church.hildegardID], preferredWeekdays: [1, 7],
maxPerMonth: 7),
Person(id: "p-stefan", firstName: "Stefan", lastName: "Haas", roles: [.lector, .helper],
preferredChurchIDs: [], preferredWeekdays: [], maxPerMonth: 9),
Person(id: "p-monika", firstName: "Monika", lastName: "Albrecht", roles: [.helper],
preferredChurchIDs: [Church.andreasID], preferredWeekdays: [1, 3], maxPerMonth: 6),
Person(id: "p-christoph", firstName: "Christoph", lastName: "Mertens", roles: [.lector],
preferredChurchIDs: [Church.evergislusID], preferredWeekdays: [1, 7],
preferredServiceTitles: ["Vorabendmesse"], maxPerMonth: 7),
Person(id: "p-simone", firstName: "Simone", lastName: "Becker", roles: [.helper],
preferredChurchIDs: [], preferredWeekdays: [], maxPerMonth: 8),
Person(id: "p-martin", firstName: "Martin", lastName: "Fuchs", roles: [.lector],
preferredChurchIDs: [], preferredWeekdays: [1, 3], maxPerMonth: 7),
Person(id: "p-ursula", firstName: "Ursula", lastName: "Peters", roles: [.helper],
preferredChurchIDs: [], preferredWeekdays: [3, 4, 5], maxPerMonth: 8,
notes: "Werktagsmessen."),
Person(id: "p-frank", firstName: "Frank", lastName: "Lorenz", roles: [.lector],
preferredChurchIDs: [], preferredWeekdays: [2, 3, 5], maxPerMonth: 8,
notes: "Werktagsmessen.")
]
}
private static func makeAbsences() -> [Absence] {
func date(_ key: String) -> Date { DayMath.date(fromKey: key) ?? DayMath.today() }
return [
Absence(personID: "p-anna", start: date("2026-12-20"), end: date("2027-01-06"), reason: "Weihnachtsreise"),
Absence(personID: "p-markus", start: date("2026-11-10"), end: date("2026-11-24"), reason: "Kur"),
Absence(personID: "p-maria", start: date("2027-03-01"), end: date("2027-03-15"), reason: "Fortbildung"),
Absence(personID: "p-peter", start: date("2026-12-24"), end: date("2026-12-26"), reason: "Familie"),
Absence(personID: "p-susanne", start: date("2026-08-01"), end: date("2026-08-21"), reason: "Urlaub"),
Absence(personID: "p-michael", start: date("2026-11-01"), end: date("2026-11-08"), reason: "Urlaub"),
Absence(personID: "p-julia", start: date("2027-05-01"), end: date("2027-05-14"), reason: "Urlaub"),
Absence(personID: "p-birgit", start: date("2026-11-15"), end: date("2026-11-22"), reason: "Dienstreise"),
Absence(personID: "p-daniel", start: date("2026-12-01"), end: date("2026-12-12"), reason: "Umzug"),
Absence(personID: "p-petra", start: date("2027-02-01"), end: date("2027-02-14"), reason: "Winterurlaub"),
Absence(personID: "p-thomas", start: date("2027-04-01"), end: date("2027-04-20"), reason: "Reha"),
Absence(personID: "p-simone", start: date("2026-12-24"), end: date("2027-01-02"), reason: "Familienbesuch"),
Absence(personID: "p-ursula", start: date("2026-09-07"), end: date("2026-09-20"), reason: "Urlaub"),
Absence(personID: "p-frank", start: date("2026-11-23"), end: date("2026-12-04"), reason: "Kur")
]
}
private static func makeTemplates() -> [ServiceTemplate] {
let from = DayMath.date(fromKey: "2024-01-01") ?? DayMath.today()
func t(_ id: String, _ church: String, _ weekday: Int, _ hour: Int, _ minute: Int,
_ title: String, _ lectors: Int = 1, _ helpers: Int = 1, notes: String = "") -> ServiceTemplate {
ServiceTemplate(
id: id,
churchID: church,
weekday: weekday,
timeMinutes: DayMath.minutes(hour: hour, minute: minute),
title: title,
lectorsNeeded: lectors,
helpersNeeded: helpers,
validFrom: from,
notes: notes
)
}
return [
t("t-andreas-so-hl", Church.andreasID, 1, 9, 30, "Hochamt", 1, 2, notes: "Sonntägliches Hochamt"),
t("t-andreas-so-ab", Church.andreasID, 1, 18, 0, "Abendmesse", 1, 1),
t("t-andreas-mi", Church.andreasID, 4, 8, 30, "Werktagsmesse", 1, 1),
t("t-evergislus-sa", Church.evergislusID, 7, 18, 0, "Vorabendmesse", 1, 1, notes: "Samstagabend"),
t("t-evergislus-so", Church.evergislusID, 1, 11, 0, "Hochamt", 1, 2),
t("t-evergislus-do", Church.evergislusID, 5, 8, 30, "Werktagsmesse", 1, 1),
t("t-herzjesu-sa", Church.herzJesuID, 7, 17, 0, "Vorabendmesse", 1, 1),
t("t-herzjesu-so", Church.herzJesuID, 1, 10, 0, "Hochamt", 1, 2),
t("t-herzjesu-di", Church.herzJesuID, 3, 18, 0, "Werktagsmesse", 1, 1),
t("t-herzjesu-fr", Church.herzJesuID, 6, 8, 30, "Werktagsmesse", 1, 1),
t("t-hildegard-so", Church.hildegardID, 1, 9, 0, "Messe", 1, 1),
t("t-hildegard-wgf", Church.hildegardID, 1, 11, 30, "Wort-Gottes-Feier", 1, 0, notes: "Lektorat, keine Kommunionspendung"),
t("t-hildegard-mi", Church.hildegardID, 4, 18, 30, "Werktagsmesse", 1, 1)
]
}
private static func addExceptions(to db: AppDatabase, templates: [ServiceTemplate]) throws {
let goodFridays = ["2025-04-18", "2026-04-03", "2027-03-26"]
let christmasEves = ["2025-12-24", "2027-12-24"]
for template in templates {
if template.weekday == 6, template.churchID == Church.herzJesuID {
for key in goodFridays {
if let date = DayMath.date(fromKey: key) {
try db.upsert(ServiceException(templateID: template.id, date: date, reason: "Karfreitag – keine Werktagsmesse"))
}
}
}
if template.weekday == 4 {
for key in christmasEves {
if let date = DayMath.date(fromKey: key) {
try db.upsert(ServiceException(templateID: template.id, date: date, reason: "Heiliger Abend"))
}
}
}
}
// Holy Saturday: the Easter Vigil replaces the regular Saturday evening mass.
if let evergislus = templates.first(where: { $0.id == "t-evergislus-sa" }) {
for key in ["2025-04-19", "2026-04-04", "2027-03-27"] {
if let date = DayMath.date(fromKey: key) {
try db.upsert(ServiceException(templateID: evergislus.id, date: date, reason: "Osternacht"))
}
}
}
}
private static func addSpecialServices(to db: AppDatabase) throws {
func date(_ key: String) -> Date { DayMath.date(fromKey: key) ?? DayMath.today() }
let specials: [ServiceOccurrence] = [
ServiceOccurrence(churchID: Church.andreasID, date: date("2025-12-24"), timeMinutes: DayMath.minutes(hour: 16, minute: 0),
title: "Familienchristmette", lectorsNeeded: 1, helpersNeeded: 1, kind: .special,
notes: "Kinder- und Familienchristmette mit Krippenspiel"),
ServiceOccurrence(churchID: Church.herzJesuID, date: date("2025-12-24"), timeMinutes: DayMath.minutes(hour: 22, minute: 0),
title: "Christmette", lectorsNeeded: 1, helpersNeeded: 2, kind: .special),
ServiceOccurrence(churchID: Church.evergislusID, date: date("2025-04-19"), timeMinutes: DayMath.minutes(hour: 21, minute: 0),
title: "Osternacht", lectorsNeeded: 1, helpersNeeded: 1, kind: .special,
notes: "Hochfest der Auferstehung, Lichterfeier"),
ServiceOccurrence(churchID: Church.andreasID, date: date("2026-04-04"), timeMinutes: DayMath.minutes(hour: 21, minute: 0),
title: "Osternacht", lectorsNeeded: 1, helpersNeeded: 1, kind: .special,
notes: "Lichterfeier mit Taufgedächtnis"),
ServiceOccurrence(churchID: Church.andreasID, date: date("2026-11-30"), timeMinutes: DayMath.minutes(hour: 18, minute: 0),
title: "Patronatsfest St. Andreas", lectorsNeeded: 1, helpersNeeded: 1, kind: .special,
notes: "Hochfest des heiligen Andreas"),
ServiceOccurrence(churchID: Church.andreasID, date: date("2026-12-24"), timeMinutes: DayMath.minutes(hour: 16, minute: 0),
title: "Familienchristmette", lectorsNeeded: 1, helpersNeeded: 1, kind: .special,
notes: "Kinder- und Familienchristmette"),
ServiceOccurrence(churchID: Church.herzJesuID, date: date("2026-12-24"), timeMinutes: DayMath.minutes(hour: 22, minute: 0),
title: "Christmette", lectorsNeeded: 1, helpersNeeded: 2, kind: .special),
ServiceOccurrence(churchID: Church.evergislusID, date: date("2027-03-27"), timeMinutes: DayMath.minutes(hour: 21, minute: 0),
title: "Osternacht", lectorsNeeded: 1, helpersNeeded: 1, kind: .special),
ServiceOccurrence(churchID: Church.herzJesuID, date: date("2027-06-04"), timeMinutes: DayMath.minutes(hour: 10, minute: 0),
title: "Fronleichnamsprozession", lectorsNeeded: 1, helpersNeeded: 2, kind: .special,
notes: "Gemeinsame Prozession der Pfarrgemeinschaft"),
ServiceOccurrence(churchID: Church.andreasID, date: date("2027-12-24"), timeMinutes: DayMath.minutes(hour: 16, minute: 0),
title: "Familienchristmette", lectorsNeeded: 1, helpersNeeded: 1, kind: .special),
ServiceOccurrence(churchID: Church.herzJesuID, date: date("2027-12-24"), timeMinutes: DayMath.minutes(hour: 22, minute: 0),
title: "Christmette", lectorsNeeded: 1, helpersNeeded: 2, kind: .special)
]
for service in specials { try db.upsert(service) }
}
}
@@ -0,0 +1,247 @@
import Foundation
// MARK: - Bundled offline snapshot
private struct SnapshotFile: Decodable {
struct Day: Decodable {
let date: String
let title: String
let rank: String
let color: String
let bem: String
let l1: String
let ap: String
let l2: String
let ev: String
let obligation: Bool
}
let version: Int
let source: String
let diocese: String
let years: [Int]
let days: [Day]
}
public enum LiturgicalSnapshot {
public static let sourceLabel = "Daten von www.eucharistiefeier.de"
public static func loadBundled() -> [LiturgicalDay] {
guard let url = bundledURL(),
let data = try? Data(contentsOf: url),
let file = try? JSONDecoder().decode(SnapshotFile.self, from: data)
else {
return []
}
return file.days.compactMap { day in
guard let date = DayMath.date(fromKey: day.date) else { return nil }
let rank = LiturgicalRank(rawValue: day.rank) ?? .weekday
return LiturgicalDay(
date: date,
title: day.title,
rank: rank,
color: LiturgicalColor(apiValue: day.color),
remark: day.bem,
readings: Readings(first: day.l1, psalm: day.ap, second: day.l2, gospel: day.ev),
isObligation: day.obligation,
source: sourceLabel
)
}
}
public static func bundledYears() -> [Int] {
guard let url = bundledURL(),
let data = try? Data(contentsOf: url),
let file = try? JSONDecoder().decode(SnapshotFile.self, from: data)
else { return [] }
return file.years
}
private static func bundledURL() -> URL? {
let candidates: [URL?] = [
Bundle.module.url(forResource: "liturgical-snapshot", withExtension: "json"),
Bundle.main.url(forResource: "liturgical-snapshot", withExtension: "json"),
Bundle.main.resourceURL?.appendingPathComponent("liturgical-snapshot.json")
]
return candidates.compactMap { $0 }.first { FileManager.default.fileExists(atPath: $0.path) }
}
}
// MARK: - Live API
public enum LiturgicalAPIError: LocalizedError {
case invalidURL
case badStatus(Int)
case invalidPayload(String)
case emptyYear(Int)
public var errorDescription: String? {
switch self {
case .invalidURL:
return "Die Kalender-URL konnte nicht erstellt werden."
case .badStatus(let code):
return "Der liturgische Kalender antwortete mit HTTP \(code)."
case .invalidPayload(let detail):
return "Die Kalenderdaten konnten nicht gelesen werden (\(detail))."
case .emptyYear(let year):
return "Für \(year) wurden keine liturgischen Daten geliefert."
}
}
}
public struct LiturgicalCalendarAPI: Sendable {
public var diocese: String
public var endpoint: URL
public init(diocese: String = "koeln", endpoint: URL = URL(string: "https://www.eucharistiefeier.de/lk/api.php")!) {
self.diocese = diocese
self.endpoint = endpoint
}
public func fetch(year: Int) async throws -> [LiturgicalDay] {
guard var components = URLComponents(url: endpoint, resolvingAgainstBaseURL: false) else {
throw LiturgicalAPIError.invalidURL
}
components.queryItems = [
URLQueryItem(name: "kal", value: diocese),
URLQueryItem(name: "jahr", value: String(year)),
URLQueryItem(name: "format", value: "json"),
URLQueryItem(name: "info", value: "wdtrflu"),
URLQueryItem(name: "dup", value: "e"),
URLQueryItem(name: "bahn", value: "j")
]
guard let url = components.url else { throw LiturgicalAPIError.invalidURL }
var request = URLRequest(url: url)
request.timeoutInterval = 45
request.setValue("LektorenPlan/0.1 (macOS; Pfarrei Bad Godesberg)", forHTTPHeaderField: "User-Agent")
request.setValue("application/json, text/plain, */*", forHTTPHeaderField: "Accept")
let (data, response) = try await URLSession.shared.data(for: request)
if let http = response as? HTTPURLResponse, !(200...299).contains(http.statusCode) {
throw LiturgicalAPIError.badStatus(http.statusCode)
}
return try Self.parse(data: data, year: year)
}
public static func parse(data: Data, year: Int) throws -> [LiturgicalDay] {
guard let object = try JSONSerialization.jsonObject(with: data) as? [String: Any],
let celebrations = object["Zelebrationen"]
else {
throw LiturgicalAPIError.invalidPayload("Zelebrationen fehlen")
}
var entries: [[String: Any]] = []
if let dict = celebrations as? [String: Any] {
entries = dict.values.compactMap { $0 as? [String: Any] }
} else if let array = celebrations as? [[String: Any]] {
entries = array
}
let grouped = Dictionary(grouping: entries) { ($0["Datum"] as? String) ?? "" }
var days: [LiturgicalDay] = []
for dateKey in grouped.keys.sorted() {
guard dateKey.hasPrefix(String(year)), let date = DayMath.date(fromKey: dateKey) else { continue }
let raw = grouped[dateKey] ?? []
let valid = raw.filter { entry in
let title = (entry["Tl"] as? String) ?? ""
let remark = (entry["Bem"] as? String) ?? ""
if title.contains("Bahnlesungen") { return false }
if title.hasPrefix("Kommemoration") { return false }
if title == "Weihe der eigenen Kirche" && remark.hasPrefix("Wenn") { return false }
return true
}
guard !valid.isEmpty else { continue }
let best = valid.max { score($0, date: date) < score($1, date: date) } ?? valid[0]
var readingEntry = best
let bestTitle = (best["Tl"] as? String) ?? ""
if ((best["L1"] as? String) ?? "").isEmpty && ((best["EV"] as? String) ?? "").isEmpty {
readingEntry = valid.max {
readingLength($0) < readingLength($1)
} ?? best
}
let title = bestTitle
let rank = LiturgicalRank(rawValue: (best["Rang"] as? String) ?? "") ?? .weekday
let colorValue = (best["Farbe"] as? String).flatMap { $0.isEmpty ? nil : $0 }
?? (readingEntry["Farbe"] as? String)
?? ""
let readings = Readings(
first: (readingEntry["L1"] as? String) ?? "",
psalm: (readingEntry["AP"] as? String) ?? "",
second: (readingEntry["L2"] as? String) ?? "",
gospel: (readingEntry["EV"] as? String) ?? ""
)
days.append(LiturgicalDay(
date: date,
title: title,
rank: rank,
color: LiturgicalColor(apiValue: colorValue),
remark: (best["Bem"] as? String) ?? "",
readings: readings,
isObligation: LiturgicalCalendarEngine.isObligation(date: date, title: title),
source: LiturgicalSnapshot.sourceLabel
))
}
guard !days.isEmpty else { throw LiturgicalAPIError.emptyYear(year) }
// Complete gaps with the local calendar so a plan never has empty rows.
let existing = Set(days.map(\.dateKey))
let start = DayMath.date(fromKey: DayMath.key(year: year, month: 1, day: 1))!
let end = DayMath.date(fromKey: DayMath.key(year: year, month: 12, day: 31))!
for day in DayMath.days(in: DayRange(start: start, end: end)) where !existing.contains(DayMath.key(day)) {
days.append(LiturgicalCalendarEngine.localDay(for: day))
}
return days.sorted { $0.date < $1.date }
}
private static func readingLength(_ entry: [String: Any]) -> Int {
["L1", "AP", "L2", "EV"].reduce(0) { total, key in
total + ((entry[key] as? String)?.count ?? 0)
}
}
private static func score(_ entry: [String: Any], date: Date) -> Int {
var value = 0
let rank = (entry["Rang"] as? String) ?? ""
switch rank {
case "H": value += 120
case "F": value += 110
case "G": value += 80
case "g": value += 60
default: value += 50
}
let title = (entry["Tl"] as? String) ?? ""
let remark = (entry["Bem"] as? String) ?? ""
let lowerTitle = title.lowercased()
if DayMath.isSunday(date) {
if lowerTitle.contains("sonntag") || lowerTitle.contains("taufe des herrn") {
value += 100
}
if rank.isEmpty { value += 30 }
}
if remark.contains("Am Tag") { value += 18 }
else if remark.contains("Am Morgen") { value += 12 }
else if remark.contains("Am Vorabend") { value -= 4 }
else if remark.contains("In der Heiligen Nacht") { value += 5 }
if remark.contains("Hochfest") { value += 10 }
if title.range(of: #"^\d{1,2}\.\s"#, options: .regularExpression) != nil { value -= 25 }
if !(((entry["L1"] as? String) ?? "").isEmpty && ((entry["EV"] as? String) ?? "").isEmpty) { value += 20 }
if lowerTitle.contains("im jahreskreis") || lowerTitle.contains("osterzeit") { value += 5 }
return value
}
}
// MARK: - Combined loader
public enum LiturgicalData {
/// Inserts the bundled snapshot when the database does not yet know these years.
public static func bundledDays(notOlderThan existing: Set<String>) -> [LiturgicalDay] {
LiturgicalSnapshot.loadBundled().filter { !existing.contains($0.dateKey) }
}
}
@@ -0,0 +1,348 @@
import Foundation
public enum LiturgicalCalendarEngine {
// MARK: - Moveable feasts
public static func easterSunday(year: Int) -> Date {
let a = year % 19
let b = year / 100
let c = year % 100
let d = b / 4
let e = b % 4
let f = (b + 8) / 25
let g = (b - f + 1) / 3
let h = (19 * a + b - d - g + 15) % 30
let i = c / 4
let k = c % 4
let l = (32 + 2 * e + 2 * i - h - k) % 7
let m = (a + 11 * h + 22 * l) / 451
let month = (h + l - 7 * m + 114) / 31
let day = ((h + l - 7 * m + 114) % 31) + 1
return DayMath.date(fromKey: DayMath.key(year: year, month: month, day: day)) ?? DayMath.today()
}
public static func easterOffset(_ offset: Int, year: Int) -> Date {
DayMath.adding(days: offset, to: easterSunday(year: year))
}
public static func ashWednesday(year: Int) -> Date { easterOffset(-46, year: year) }
public static func palmSunday(year: Int) -> Date { easterOffset(-7, year: year) }
public static func holyThursday(year: Int) -> Date { easterOffset(-3, year: year) }
public static func goodFriday(year: Int) -> Date { easterOffset(-2, year: year) }
public static func holySaturday(year: Int) -> Date { easterOffset(-1, year: year) }
public static func ascension(year: Int) -> Date { easterOffset(39, year: year) }
public static func pentecost(year: Int) -> Date { easterOffset(49, year: year) }
public static func corpusChristi(year: Int) -> Date { easterOffset(60, year: year) }
public static func sacredHeart(year: Int) -> Date { easterOffset(68, year: year) }
public static func trinitySunday(year: Int) -> Date { easterOffset(56, year: year) }
/// First Sunday of Advent (the Sunday between 27 November and 3 December).
public static func adventStart(year: Int) -> Date {
let christmasEve = DayMath.date(fromKey: DayMath.key(year: year, month: 12, day: 24)) ?? DayMath.today()
var sunday = christmasEve
while DayMath.weekday(sunday) != 1 {
sunday = DayMath.adding(days: -1, to: sunday)
}
return DayMath.adding(days: -21, to: sunday)
}
public static func christKing(year: Int) -> Date {
DayMath.adding(days: -7, to: adventStart(year: year))
}
public static func baptismOfTheLord(year: Int) -> Date {
let epiphany = DayMath.date(fromKey: DayMath.key(year: year, month: 1, day: 6)) ?? DayMath.today()
var sunday = DayMath.adding(days: 1, to: epiphany)
while DayMath.weekday(sunday) != 1 {
sunday = DayMath.adding(days: 1, to: sunday)
}
// If Epiphany itself falls on 7 or 8 January, the baptism is moved to the Monday.
if DayMath.month(epiphany) == 1, DayMath.dayNumber(epiphany) >= 7 {
return DayMath.adding(days: 1, to: epiphany)
}
return sunday
}
// MARK: - Seasons
public static func season(for date: Date) -> LiturgicalSeason {
let day = DayMath.normalize(date)
let y = DayMath.year(day)
let advent = adventStart(year: y)
let christmas = DayMath.date(fromKey: DayMath.key(year: y, month: 12, day: 25)) ?? day
let baptism = baptismOfTheLord(year: y)
let ash = ashWednesday(year: y)
let holyThursday = self.holyThursday(year: y)
let easter = easterSunday(year: y)
let pentecost = self.pentecost(year: y)
if day >= advent && day < christmas { return .advent }
if day >= christmas || day <= baptism { return .christmas }
if day >= ash && day < holyThursday { return .lent }
if day >= easter && day <= pentecost { return .easter }
if day > pentecost && day < advent { return .ordinary }
return .ordinary
}
public static func seasonName(for date: Date) -> String {
season(for: date).title
}
// MARK: - Obligation
public static func isObligation(date: Date, title: String = "") -> Bool {
if DayMath.isSunday(date) { return true }
let month = DayMath.month(date)
let day = DayMath.dayNumber(date)
switch (month, day) {
case (1, 1), (1, 6), (8, 15), (11, 1), (12, 25):
return true
default:
break
}
let lower = title.lowercased()
if lower.contains("fronleichnam") { return true }
if lower.contains("christi himmelfahrt") { return true }
if lower.contains("pfingsten") && !lower.contains("vorabend") { return true }
if lower.contains("ostersonntag") || lower.contains("osternacht") { return true }
return false
}
// MARK: - Symbols
public static func symbol(for title: String, rank: LiturgicalRank, date: Date) -> FeastSymbol {
let t = title.lowercased()
if t.contains("weihnacht") || t.contains("geburt des herrn") { return .star }
if t.contains("erscheinung") { return .star }
if t.contains("ostern") || t.contains("auferstehung") { return .sun }
if t.contains("pfingst") || t.contains("heiliger geist") { return .flame }
if t.contains("fronleichnam") || t.contains("abendmahl") || t.contains("gründonnerstag") { return .candle }
if t.contains("herz jesu") { return .heart }
if t.contains("christkönig") { return .crown }
if t.contains("allerheiligen") { return .crown }
if t.contains("maria") || t.contains("mariä") { return .lily }
if t.contains("kreuz") || t.contains("kreuzerhöhung") { return .cross }
if t.contains("taufe") { return .dove }
if t.contains("wort gottes") || t.contains("evangel") { return .book }
if t.contains("lichtmess") || t.contains("darstellung") { return .candle }
if t.contains("fronleichnam") { return .candle }
if rank == .solemnity { return .cross }
if rank == .feast { return .cross }
return .book
}
// MARK: - Local fallback
private static let fixedReadings: [String: Readings] = [
"01-01": Readings(first: "Num 6, 22-27", psalm: "Ps 67 (66), 2-3.5.6 u. 8 (R: 2a)", second: "Gal 4, 4-7", gospel: "Lk 2, 16-21"),
"01-06": Readings(first: "Jes 60, 1-6", psalm: "Ps 72 (71), 1-2.7-8.10-11.12-13 (R: 11)", second: "Eph 3, 2-3a.5-6", gospel: "Mt 2, 1-12"),
"02-02": Readings(first: "Mal 3, 1-4", psalm: "Ps 24 (23), 7-8.9-10 (R: 8a)", second: "Hebr 2, 14-18", gospel: "Lk 2, 22-40"),
"03-19": Readings(first: "2 Sam 7, 4-5a.12-14a.16", psalm: "Ps 89 (88), 2-3.4-5.27.29 (R: 37)", second: "Röm 4, 13.16-18.22", gospel: "Mt 1, 16.18-21.24a"),
"03-25": Readings(first: "Jes 7, 10-14", psalm: "Ps 40 (39), 5-6.7-8a.8b-10 (R: 8a.9a)", second: "Hebr 10, 4-10", gospel: "Lk 1, 26-38"),
"06-24": Readings(first: "Jes 49, 1-6", psalm: "Ps 139 (138), 1-3.13-14ab.14c-15 (R: 14a)", second: "Apg 13, 22-26", gospel: "Lk 1, 57-66.80"),
"06-29": Readings(first: "Apg 12, 1-11", psalm: "Ps 34 (33), 2-3.4-5.6-7.8-9 (R: 5b)", second: "2 Tim 4, 6-8.17-18", gospel: "Mt 16, 13-19"),
"08-15": Readings(first: "Offb 11, 19a; 12, 1-6a.10ab", psalm: "Ps 45 (44), 11-12.16-17 (R: 10b)", second: "1 Kor 15, 20-27", gospel: "Lk 1, 39-56"),
"09-14": Readings(first: "Num 21, 4b-9", psalm: "Ps 78 (77), 1-2.34-35.36-37.38 (R: 7b)", second: "Phil 2, 6-11", gospel: "Joh 3, 13-17"),
"11-01": Readings(first: "Offb 7, 2-4.9-14", psalm: "Ps 24 (23), 1-2.3-4.5-6 (R: vgl. 6)", second: "1 Joh 3, 1-3", gospel: "Mt 5, 1-12a"),
"11-02": Readings(first: "Jes 25, 6a.7-9", psalm: "Ps 23 (22), 1-3a.3b-4.5.6 (R: 1)", second: "Röm 8, 14-23", gospel: "Mt 25, 31-46"),
"12-08": Readings(first: "Gen 3, 9-15.20", psalm: "Ps 98 (97), 1.2-3ab.3cd-4 (R: 1a)", second: "Eph 1, 3-6.11-12", gospel: "Lk 1, 26-38"),
"12-24": Readings(first: "2 Sam 7, 1-5.8b-12.14a.16", psalm: "Ps 89 (88), 2-3.20a u. 4-5.27 u. 29 (R: 2a)", second: "", gospel: "Lk 1, 67-79"),
"12-25": Readings(first: "Jes 52, 7-10", psalm: "Ps 98 (97), 1.2-3b.3c-4.5-6 (R: vgl. 3cd)", second: "Hebr 1, 1-6", gospel: "Joh 1, 1-18"),
"12-26": Readings(first: "Apg 6, 8-10; 7, 54-59", psalm: "Ps 31 (30), 3-4.6.8.17 (R: 6a)", second: "", gospel: "Mt 10, 17-22")
]
private static let easterReadings: [Int: Readings] = [
-46: Readings(first: "Joel 2, 12-18", psalm: "Ps 51 (50), 3-4.5-6a.12-13.14 u. 17 (R: vgl. 3a)", second: "2 Kor 5, 20 - 6, 2", gospel: "Mt 6, 1-6.16-18"),
-7: Readings(first: "Jes 50, 4-7", psalm: "Ps 22 (21), 8-9.17-18a.19-20.23-24 (R: 2a)", second: "Phil 2, 6-11", gospel: "Mt 21, 1-11"),
-3: Readings(first: "Ex 12, 1-8.11-14", psalm: "Ps 116 (115), 12-13.15-16bc.17-18 (R: vgl. 1 Kor 10, 16)", second: "1 Kor 11, 23-26", gospel: "Joh 13, 1-15"),
-2: Readings(first: "Jes 52, 13 - 53, 12", psalm: "Ps 31 (30), 2 u. 6.12-13.15-16.17 u. 25 (R: Lk 23, 46)", second: "Hebr 4, 14-16; 5, 7-9", gospel: "Joh 18, 1 - 19, 42"),
0: Readings(first: "Apg 10, 34a.37-43", psalm: "Ps 118 (117), 1-2.16-17.22-23 (R: vgl. 24)", second: "Kol 3, 1-4 oder 1 Kor 5, 6b-8", gospel: "Joh 20, 1-9"),
39: Readings(first: "Apg 1, 1-11", psalm: "Ps 47 (46), 2-3.6-7.8-9 (R: 6)", second: "Eph 1, 17-23", gospel: "Mk 16, 15-20"),
49: Readings(first: "Apg 2, 1-11", psalm: "Ps 104 (103), 1-2.24-25.29-30.31 u. 34 (R: vgl. 30)", second: "1 Kor 12, 3b-7.12-13", gospel: "Joh 20, 19-23"),
56: Readings(first: "Spr 8, 22-31", psalm: "Ps 8, 4-5.6-7.8-9 (R: 2a)", second: "Röm 5, 1-5", gospel: "Joh 16, 12-15"),
60: Readings(first: "Dtn 8, 2-3.14-16a", psalm: "Ps 147, 12-13.14-15.19-20 (R: 12a)", second: "1 Kor 10, 16-17", gospel: "Joh 6, 51-58"),
68: Readings(first: "Hos 11, 1.3-4.8c-9", psalm: "Jes 12, 2-3.4bcd.5-6 (R: 3)", second: "Eph 3, 8-12.14-19", gospel: "Joh 19, 31-37")
]
public static func localDay(for date: Date) -> LiturgicalDay {
let day = DayMath.normalize(date)
let y = DayMath.year(day)
let m = DayMath.month(day)
let d = DayMath.dayNumber(day)
let key = String(format: "%02d-%02d", m, d)
let weekday = DayMath.weekday(day)
let easter = easterSunday(year: y)
let offset = DayMath.daysBetween(easter, day)
var title = ""
var rank: LiturgicalRank = .weekday
var color: LiturgicalColor = .green
var readings = Readings()
var remark = ""
// Moveable celebrations take precedence over fixed ones.
switch offset {
case -46:
title = "Aschermittwoch"; rank = .weekday; color = .violet
readings = easterReadings[-46] ?? Readings()
case -7:
title = "Palmsonntag"; rank = .feast; color = .red
readings = easterReadings[-7] ?? Readings()
case -3:
title = "Gründonnerstag"; rank = .solemnity; color = .white
readings = easterReadings[-3] ?? Readings()
case -2:
title = "Karfreitag"; rank = .solemnity; color = .red
readings = easterReadings[-2] ?? Readings()
case -1:
title = "Karsamstag"; rank = .weekday; color = .violet
case 0:
title = "Ostersonntag"; rank = .solemnity; color = .white
readings = easterReadings[0] ?? Readings()
remark = "Hochfest der Auferstehung des Herrn"
case 1:
title = "Ostermontag"; rank = .solemnity; color = .white
readings = Readings(first: "Apg 2, 14.22-33", psalm: "Ps 16 (15), 1-2a u. 5.7-8.9-10.11 (R: 11a)", second: "", gospel: "Mt 28, 8-15")
case 39:
title = "Christi Himmelfahrt"; rank = .solemnity; color = .white
readings = easterReadings[39] ?? Readings()
case 49:
title = "Pfingsten"; rank = .solemnity; color = .red
readings = easterReadings[49] ?? Readings()
remark = "Hochfest des Heiligen Geistes"
case 50:
title = "Pfingstmontag"; rank = .solemnity; color = .red
readings = Readings(first: "Apg 10, 34a.37-43", psalm: "Ps 118 (117), 1-2.16-17.22-23 (R: vgl. 24)", second: "Kol 3, 1-4", gospel: "Joh 20, 1-9")
case 56:
title = "Dreifaltigkeitssonntag"; rank = .solemnity; color = .white
readings = easterReadings[56] ?? Readings()
case 60:
title = "Fronleichnam"; rank = .solemnity; color = .white
readings = easterReadings[60] ?? Readings()
remark = "Hochfest des Leibes und Blutes Christi"
case 68:
title = "Heiligstes Herz Jesu"; rank = .solemnity; color = .white
readings = easterReadings[68] ?? Readings()
default:
break
}
if title.isEmpty {
switch key {
case "01-01": title = "Neujahr – Hochfest der Gottesmutter Maria"; rank = .solemnity; color = .white
case "01-06": title = "Erscheinung des Herrn"; rank = .solemnity; color = .white
case "02-02": title = "Darstellung des Herrn"; rank = .feast; color = .white
case "03-19": title = "Hl. Josef, Bräutigam der Gottesmutter"; rank = .solemnity; color = .white
case "03-25": title = "Verkündigung des Herrn"; rank = .solemnity; color = .white
case "06-24": title = "Geburt Johannes' des Täufers"; rank = .solemnity; color = .white
case "06-29": title = "Petrus und Paulus"; rank = .solemnity; color = .red
case "08-15": title = "Mariä Aufnahme in den Himmel"; rank = .solemnity; color = .white
case "09-14": title = "Kreuzerhöhung"; rank = .feast; color = .red
case "11-01": title = "Allerheiligen"; rank = .solemnity; color = .white
case "11-02": title = "Allerseelen"; rank = .weekday; color = .violet
case "12-08": title = "Mariä Empfängnis"; rank = .solemnity; color = .white
case "12-24": title = "Heiliger Abend"; rank = .weekday; color = .white
case "12-25": title = "Weihnachten – Hochfest der Geburt des Herrn"; rank = .solemnity; color = .white
case "12-26": title = "Hl. Stephanus"; rank = .feast; color = .red
default: break
}
if let r = fixedReadings[key] { readings = r }
}
if title.isEmpty {
if weekday == 1 {
title = sundayTitle(for: day)
color = DayMath.weekday(day) == 1 ? .green : .green
if let fest = seasonalSundayRank(for: day) {
rank = fest
}
} else {
title = weekdayTitle(for: day)
if season(for: day) == .advent || season(for: day) == .lent {
color = .violet
} else if season(for: day) == .christmas || season(for: day) == .easter {
color = .white
} else {
color = .green
}
}
}
if rank == .solemnity { color = .white }
if rank == .feast && color == .green { color = .red }
return LiturgicalDay(
date: day,
title: title,
rank: rank,
color: color,
remark: remark,
readings: readings,
isObligation: isObligation(date: day, title: title),
source: "lokale Berechnung"
)
}
public static func localDays(in range: DayRange) -> [LiturgicalDay] {
DayMath.days(in: range).map(localDay(for:))
}
private static func seasonalSundayRank(for day: Date) -> LiturgicalRank? {
let season = season(for: day)
if season == .advent || season == .christmas || season == .lent || season == .easter {
if season == .lent && DayMath.daysBetween(palmSunday(year: DayMath.year(day)), day) == 0 {
return .feast
}
return .weekday
}
return nil
}
private static func sundayTitle(for day: Date) -> String {
let y = DayMath.year(day)
let season = season(for: day)
switch season {
case .advent:
let start = adventStart(year: y)
let index = DayMath.daysBetween(start, day) / 7 + 1
return ["1. Adventssonntag", "2. Adventssonntag", "3. Adventssonntag", "4. Adventssonntag"].indices.contains(index - 1)
? ["1. Adventssonntag", "2. Adventssonntag", "3. Adventssonntag", "4. Adventssonntag"][index - 1]
: "Adventssonntag"
case .christmas:
let baptism = baptismOfTheLord(year: y)
if DayMath.daysBetween(baptism, day) == 0 {
return "Taufe des Herrn"
}
return "Sonntag in der Weihnachtszeit"
case .lent:
let ash = ashWednesday(year: y)
let index = DayMath.daysBetween(ash, day) / 7 + 1
if index >= 6 { return "Palmsonntag" }
return "\(index). Fastensonntag"
case .easter:
let easter = easterSunday(year: y)
let index = DayMath.daysBetween(easter, day) / 7 + 1
if index == 1 { return "Ostersonntag" }
if index == 8 { return "Pfingsten" }
return "\(index). Sonntag der Osterzeit"
case .ordinary:
return "Sonntag im Jahreskreis"
}
}
private static func weekdayTitle(for day: Date) -> String {
let name = DayMath.weekdayName(day)
switch season(for: day) {
case .advent:
return "\(name) im Advent"
case .christmas:
return "\(name) in der Weihnachtszeit"
case .lent:
return "\(name) in der Fastenzeit"
case .easter:
return "\(name) in der Osterzeit"
case .ordinary:
return "\(name) im Jahreskreis"
}
}
}
+913
View File
@@ -0,0 +1,913 @@
import Foundation
// MARK: - Roles
public enum Role: String, Codable, CaseIterable, Identifiable, Sendable, Hashable {
case lector
case helper
public var id: String { rawValue }
public var title: String {
switch self {
case .lector: "Lektor"
case .helper: "Kommunionhelfer"
}
}
public var plural: String {
switch self {
case .lector: "Lektoren"
case .helper: "Kommunionhelfer"
}
}
public var shortCode: String {
switch self {
case .lector: "L"
case .helper: "K"
}
}
public var symbolName: String {
switch self {
case .lector: "book.closed.fill"
case .helper: "hand.raised.fill"
}
}
}
// MARK: - Church
public enum ChurchSymbol: String, Codable, CaseIterable, Sendable {
case basilica
case gothic
case modern
case rotunda
case roundTower
case chapel
public var caption: String {
switch self {
case .basilica: "Romanische Basilika"
case .gothic: "Neugotische Kirche"
case .modern: "Moderner Kirchenbau"
case .rotunda: "Rundkirche"
case .roundTower: "Rundturm"
case .chapel: "Kapelle"
}
}
}
public struct Church: Identifiable, Codable, Hashable, Sendable {
public var id: String
public var name: String
public var shortName: String
public var symbol: ChurchSymbol
public var colorHex: String
public var address: String
public var sortIndex: Int
public var notes: String
public init(
id: String = UUID().uuidString,
name: String,
shortName: String,
symbol: ChurchSymbol,
colorHex: String,
address: String = "",
sortIndex: Int = 0,
notes: String = ""
) {
self.id = id
self.name = name
self.shortName = shortName
self.symbol = symbol
self.colorHex = colorHex
self.address = address
self.sortIndex = sortIndex
self.notes = notes
}
/// Stable demo identifiers so exported plans remain readable.
public static let andreasID = "church-andreas"
public static let evergislusID = "church-evergislus"
public static let herzJesuID = "church-herz-jesu"
public static let hildegardID = "church-hildegard"
}
// MARK: - People
public struct Person: Identifiable, Codable, Hashable, Sendable {
public var id: String
public var firstName: String
public var lastName: String
public var roles: Set<Role>
public var email: String
public var phone: String
public var preferredChurchIDs: Set<String>
public var preferredWeekdays: Set<Int> // 1 = Sunday … 7 = Saturday; empty = no preference
public var preferredServiceTitles: [String]
public var maxPerMonth: Int
public var active: Bool
public var notes: String
public init(
id: String = UUID().uuidString,
firstName: String,
lastName: String,
roles: Set<Role> = [.lector],
email: String = "",
phone: String = "",
preferredChurchIDs: Set<String> = [],
preferredWeekdays: Set<Int> = [],
preferredServiceTitles: [String] = [],
maxPerMonth: Int = 6,
active: Bool = true,
notes: String = ""
) {
self.id = id
self.firstName = firstName
self.lastName = lastName
self.roles = roles
self.email = email
self.phone = phone
self.preferredChurchIDs = preferredChurchIDs
self.preferredWeekdays = preferredWeekdays
self.preferredServiceTitles = preferredServiceTitles
self.maxPerMonth = maxPerMonth
self.active = active
self.notes = notes
}
public var fullName: String {
"\(firstName) \(lastName)".trimmingCharacters(in: .whitespaces)
}
public var initials: String {
let f = firstName.first.map(String.init) ?? ""
let l = lastName.first.map(String.init) ?? ""
return (f + l).uppercased()
}
public var firstNameWithInitial: String {
guard let initial = lastName.first else { return firstName }
return "\(firstName) \(initial)."
}
public var roleLabel: String {
let ordered = Role.allCases.filter { roles.contains($0) }
return ordered.map(\.title).joined(separator: " · ")
}
public func canFill(_ role: Role) -> Bool { roles.contains(role) }
}
public struct Absence: Identifiable, Codable, Hashable, Sendable {
public var id: String
public var personID: String
public var start: Date
public var end: Date
public var reason: String
public init(
id: String = UUID().uuidString,
personID: String,
start: Date,
end: Date,
reason: String = ""
) {
self.id = id
self.personID = personID
self.start = DayMath.normalize(start)
self.end = DayMath.normalize(end)
self.reason = reason
}
public var range: DayRange { DayRange(start: start, end: end) }
public func overlaps(_ day: Date) -> Bool {
range.contains(day)
}
public var label: String {
let start = DayMath.mediumString(start)
let end = DayMath.mediumString(end)
let base = start == end ? start : "\(start) – \(end)"
return reason.isEmpty ? base : "\(base) · \(reason)"
}
}
// MARK: - Service order
public struct ServiceTemplate: Identifiable, Codable, Hashable, Sendable {
public var id: String
public var churchID: String
public var weekday: Int // 1 = Sunday … 7 = Saturday
public var timeMinutes: Int
public var title: String
public var lectorsNeeded: Int
public var helpersNeeded: Int
public var validFrom: Date
public var validTo: Date?
public var active: Bool
public var notes: String
public init(
id: String = UUID().uuidString,
churchID: String,
weekday: Int,
timeMinutes: Int,
title: String,
lectorsNeeded: Int = 1,
helpersNeeded: Int = 1,
validFrom: Date = DayMath.date(fromKey: "2025-01-01") ?? DayMath.today(),
validTo: Date? = nil,
active: Bool = true,
notes: String = ""
) {
self.id = id
self.churchID = churchID
self.weekday = weekday
self.timeMinutes = timeMinutes
self.title = title
self.lectorsNeeded = lectorsNeeded
self.helpersNeeded = helpersNeeded
self.validFrom = DayMath.normalize(validFrom)
self.validTo = validTo.map(DayMath.normalize)
self.active = active
self.notes = notes
}
public var timeLabel: String { DayMath.timeString(minutes: timeMinutes) }
public var weekdayLabel: String {
let names = ["", "Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"]
return names.indices.contains(weekday) ? names[weekday] : "?"
}
public var requirementLabel: String {
var parts: [String] = []
if lectorsNeeded > 0 { parts.append("\(lectorsNeeded)× Lektor") }
if helpersNeeded > 0 { parts.append("\(helpersNeeded)× Kommunionhelfer") }
return parts.isEmpty ? "Keine Dienste" : parts.joined(separator: " · ")
}
public func isValid(on date: Date) -> Bool {
guard active else { return false }
let day = DayMath.normalize(date)
guard DayMath.weekday(day) == weekday else { return false }
guard day >= DayMath.normalize(validFrom) else { return false }
if let validTo, day > DayMath.normalize(validTo) { return false }
return true
}
}
public struct ServiceException: Identifiable, Codable, Hashable, Sendable {
public var id: String
public var templateID: String
public var date: Date
public var reason: String
public init(id: String = UUID().uuidString, templateID: String, date: Date, reason: String = "") {
self.id = id
self.templateID = templateID
self.date = DayMath.normalize(date)
self.reason = reason
}
}
public enum ServiceKind: String, Codable, CaseIterable, Sendable {
case regular
case special
public var title: String {
switch self {
case .regular: "Regulär"
case .special: "Sondergottesdienst"
}
}
}
public struct ServiceOccurrence: Identifiable, Codable, Hashable, Sendable {
public var id: String
public var churchID: String
public var templateID: String?
public var date: Date
public var timeMinutes: Int
public var title: String
public var lectorsNeeded: Int
public var helpersNeeded: Int
public var kind: ServiceKind
public var notes: String
public var locked: Bool
public var createdAt: Date
public init(
id: String = UUID().uuidString,
churchID: String,
templateID: String? = nil,
date: Date,
timeMinutes: Int,
title: String,
lectorsNeeded: Int = 1,
helpersNeeded: Int = 1,
kind: ServiceKind = .regular,
notes: String = "",
locked: Bool = false,
createdAt: Date = Date()
) {
self.id = id
self.churchID = churchID
self.templateID = templateID
self.date = DayMath.normalize(date)
self.timeMinutes = timeMinutes
self.title = title
self.lectorsNeeded = max(0, lectorsNeeded)
self.helpersNeeded = max(0, helpersNeeded)
self.kind = kind
self.notes = notes
self.locked = locked
self.createdAt = createdAt
}
public var timeLabel: String { DayMath.timeString(minutes: timeMinutes) }
public var dateKey: String { DayMath.key(date) }
public var requiredSlots: Int { lectorsNeeded + helpersNeeded }
public var rolesNeeded: [Role] {
var result: [Role] = []
if lectorsNeeded > 0 { result.append(.lector) }
if helpersNeeded > 0 { result.append(.helper) }
return result
}
public func requiredCount(for role: Role) -> Int {
switch role {
case .lector: lectorsNeeded
case .helper: helpersNeeded
}
}
}
public struct Assignment: Identifiable, Codable, Hashable, Sendable {
public var id: String
public var serviceID: String
public var personID: String
public var role: Role
public var locked: Bool
public var note: String
public var createdAt: Date
public init(
id: String = UUID().uuidString,
serviceID: String,
personID: String,
role: Role,
locked: Bool = false,
note: String = "",
createdAt: Date = Date()
) {
self.id = id
self.serviceID = serviceID
self.personID = personID
self.role = role
self.locked = locked
self.note = note
self.createdAt = createdAt
}
}
// MARK: - Liturgy
public enum LiturgicalRank: String, Codable, CaseIterable, Sendable, Comparable {
case weekday = ""
case memorial = "g"
case obligatoryMemorial = "G"
case feast = "F"
case solemnity = "H"
public var label: String {
switch self {
case .weekday: "Wochentag"
case .memorial: "Gedenktag"
case .obligatoryMemorial: "Gebotener Gedenktag"
case .feast: "Fest"
case .solemnity: "Hochfest"
}
}
public var shortLabel: String {
switch self {
case .weekday: ""
case .memorial: "g"
case .obligatoryMemorial: "G"
case .feast: "F"
case .solemnity: "H"
}
}
public var priority: Int {
switch self {
case .weekday: 0
case .memorial: 1
case .obligatoryMemorial: 2
case .feast: 3
case .solemnity: 4
}
}
public var isFeast: Bool { self == .feast || self == .solemnity }
public static func < (lhs: LiturgicalRank, rhs: LiturgicalRank) -> Bool {
lhs.priority < rhs.priority
}
}
public enum LiturgicalColor: String, Codable, CaseIterable, Sendable {
case white = "w"
case red = "r"
case green = "g"
case violet = "v"
case rose = "ros"
case black = "s"
case gold = "gold"
public var label: String {
switch self {
case .white: "Weiß"
case .red: "Rot"
case .green: "Grün"
case .violet: "Violett"
case .rose: "Rosa"
case .black: "Schwarz"
case .gold: "Gold"
}
}
public init(apiValue: String) {
switch apiValue.lowercased() {
case "r": self = .red
case "g": self = .green
case "v": self = .violet
case "ros", "rose": self = .rose
case "s", "sw": self = .black
case "gold": self = .gold
default: self = .white
}
}
}
public enum LiturgicalSeason: String, Codable, CaseIterable, Sendable, Identifiable {
case advent
case christmas
case ordinary
case lent
case easter
public var id: String { rawValue }
public var title: String {
switch self {
case .advent: "Advent"
case .christmas: "Weihnachtszeit"
case .ordinary: "Jahreskreis"
case .lent: "Österliche Bußzeit"
case .easter: "Osterzeit"
}
}
public var shortTitle: String {
switch self {
case .advent: "Advent"
case .christmas: "Weihnachten"
case .ordinary: "Jahreskreis"
case .lent: "Fastenzeit"
case .easter: "Osterzeit"
}
}
public var colorHex: String {
switch self {
case .advent: "#6E4B8E"
case .christmas: "#B58A3B"
case .ordinary: "#4F7D5A"
case .lent: "#75516F"
case .easter: "#C9A227"
}
}
}
public enum FeastSymbol: String, Codable, CaseIterable, Sendable {
case cross
case star
case flame
case sun
case lily
case crown
case heart
case book
case candle
case dove
public var symbolName: String {
switch self {
case .cross: "cross.fill"
case .star: "star.fill"
case .flame: "flame.fill"
case .sun: "sun.max.fill"
case .lily: "leaf.fill"
case .crown: "crown.fill"
case .heart: "heart.fill"
case .book: "book.closed.fill"
case .candle: "sparkles"
case .dove: "bird.fill"
}
}
public var label: String {
switch self {
case .cross: "Kreuz"
case .star: "Stern"
case .flame: "Feuer"
case .sun: "Sonne"
case .lily: "Lilie"
case .crown: "Krone"
case .heart: "Herz"
case .book: "Buch"
case .candle: "Licht"
case .dove: "Taube"
}
}
}
public struct Readings: Codable, Hashable, Sendable {
public var first: String
public var psalm: String
public var second: String
public var gospel: String
public init(first: String = "", psalm: String = "", second: String = "", gospel: String = "") {
self.first = first
self.psalm = psalm
self.second = second
self.gospel = gospel
}
public var isEmpty: Bool {
first.isEmpty && psalm.isEmpty && second.isEmpty && gospel.isEmpty
}
public var shortLabel: String {
var parts: [String] = []
if !first.isEmpty { parts.append(first) }
if !second.isEmpty { parts.append(second) }
if !gospel.isEmpty { parts.append(gospel) }
return parts.joined(separator: " · ")
}
public var fullLabel: String {
var lines: [String] = []
if !first.isEmpty { lines.append("1. Lesung: \(first)") }
if !psalm.isEmpty { lines.append("Psalm: \(psalm)") }
if !second.isEmpty { lines.append("2. Lesung: \(second)") }
if !gospel.isEmpty { lines.append("Evangelium: \(gospel)") }
return lines.joined(separator: "\n")
}
}
public struct LiturgicalDay: Identifiable, Codable, Hashable, Sendable {
public var date: Date
public var title: String
public var rank: LiturgicalRank
public var color: LiturgicalColor
public var remark: String
public var readings: Readings
public var isObligation: Bool
public var source: String
public var updatedAt: Date
public var id: String { DayMath.key(date) }
public var dateKey: String { DayMath.key(date) }
public init(
date: Date,
title: String,
rank: LiturgicalRank = .weekday,
color: LiturgicalColor = .green,
remark: String = "",
readings: Readings = Readings(),
isObligation: Bool = false,
source: String = "eucharistiefeier.de",
updatedAt: Date = Date()
) {
self.date = DayMath.normalize(date)
self.title = title
self.rank = rank
self.color = color
self.remark = remark
self.readings = readings
self.isObligation = isObligation
self.source = source
self.updatedAt = updatedAt
}
public var isSunday: Bool { DayMath.isSunday(date) }
public var isHighFeast: Bool { rank == .solemnity || title.localizedCaseInsensitiveContains("Hochfest") }
public var isFeast: Bool { rank.isFeast || isHighFeast }
public var season: LiturgicalSeason { LiturgicalCalendarEngine.season(for: date) }
public var symbol: FeastSymbol {
LiturgicalCalendarEngine.symbol(for: title, rank: rank, date: date)
}
public var displayTitle: String {
if title.isEmpty {
return isSunday ? "Sonntag" : DayMath.longString(date)
}
return title
}
public var badgeText: String {
if isSunday, isObligation { return "Sonntag" }
if rank != .weekday { return rank.label }
if isObligation { return "Gebotener Feiertag" }
return ""
}
}
// MARK: - Views / statistics support
public struct ServiceWithAssignments: Identifiable, Hashable, Sendable {
public var service: ServiceOccurrence
public var church: Church
public var assignments: [Assignment]
public var id: String { service.id }
public init(service: ServiceOccurrence, church: Church, assignments: [Assignment]) {
self.service = service
self.church = church
self.assignments = assignments
}
public func assignments(for role: Role) -> [Assignment] {
assignments.filter { $0.role == role }
}
public func openSlots(for role: Role) -> Int {
max(0, service.requiredCount(for: role) - assignments(for: role).count)
}
public var filledSlots: Int {
assignments.count
}
public var openSlots: Int {
max(0, service.requiredSlots - assignments.count)
}
public var isFullyStaffed: Bool { openSlots == 0 }
}
public struct DayPlanRow: Identifiable, Hashable, Sendable {
public var date: Date
public var liturgicalDay: LiturgicalDay?
public var services: [ServiceWithAssignments]
public var id: String { DayMath.key(date) }
public init(date: Date, liturgicalDay: LiturgicalDay?, services: [ServiceWithAssignments]) {
self.date = DayMath.normalize(date)
self.liturgicalDay = liturgicalDay
self.services = services
}
public var openSlots: Int { services.reduce(0) { $0 + $1.openSlots } }
public var assignmentCount: Int { services.reduce(0) { $0 + $1.assignments.count } }
public var hasServices: Bool { !services.isEmpty }
}
public struct UnfilledSlot: Identifiable, Hashable, Sendable {
public var service: ServiceOccurrence
public var churchName: String
public var role: Role
public var reason: String
public var id: String { "\(service.id)-\(role.rawValue)" }
}
public struct PersonStat: Identifiable, Hashable, Sendable {
public var person: Person
public var total: Int
public var lectors: Int
public var helpers: Int
public var churchCounts: [String: Int]
public var preferredHits: Int
public var sundayCount: Int
public var lastAssignment: Date?
public var id: String { person.id }
public var preferenceRate: Double {
total == 0 ? 0 : Double(preferredHits) / Double(total)
}
}
public struct ChurchStat: Identifiable, Hashable, Sendable {
public var church: Church
public var assignments: Int
public var services: Int
public var openSlots: Int
public var personCount: Int
public var id: String { church.id }
}
public struct RangeStatistics: Hashable, Sendable {
public var range: DayRange
public var serviceCount: Int
public var assignmentCount: Int
public var openSlots: Int
public var requiredSlots: Int
public var personStats: [PersonStat]
public var churchStats: [ChurchStat]
public var monthlyCounts: [String: Int]
public var sundayServiceCount: Int
public var sundayFilled: Int
public var preferenceHits: Int
public var preferenceEligible: Int
public var absenceDays: Int
public static let empty = RangeStatistics(
range: DayRange(start: DayMath.today(), end: DayMath.today()),
serviceCount: 0,
assignmentCount: 0,
openSlots: 0,
requiredSlots: 0,
personStats: [],
churchStats: [],
monthlyCounts: [:],
sundayServiceCount: 0,
sundayFilled: 0,
preferenceHits: 0,
preferenceEligible: 0,
absenceDays: 0
)
public var coverageRate: Double {
requiredSlots == 0 ? 1 : Double(assignmentCount) / Double(requiredSlots)
}
public var preferenceRate: Double {
preferenceEligible == 0 ? 0 : Double(preferenceHits) / Double(preferenceEligible)
}
public var activePeople: Int { personStats.filter { $0.total > 0 }.count }
public var averageAssignments: Double {
let active = personStats.filter { $0.total > 0 }
guard !active.isEmpty else { return 0 }
return Double(active.reduce(0) { $0 + $1.total }) / Double(active.count)
}
}
// MARK: - Import / export
public enum ExchangeScope: String, Codable, CaseIterable, Sendable {
case resources
case plan
public var title: String {
switch self {
case .resources: "Ressourcen"
case .plan: "Planungsabschnitt"
}
}
}
public struct ResourceBundle: Codable, Hashable, Sendable {
public var churches: [Church]
public var people: [Person]
public var absences: [Absence]
public var templates: [ServiceTemplate]
public var exceptions: [ServiceException]
public init(
churches: [Church] = [],
people: [Person] = [],
absences: [Absence] = [],
templates: [ServiceTemplate] = [],
exceptions: [ServiceException] = []
) {
self.churches = churches
self.people = people
self.absences = absences
self.templates = templates
self.exceptions = exceptions
}
}
public struct PlanExchange: Codable, Sendable {
public var formatVersion: Int
public var exportedAt: Date
public var appName: String
public var scope: ExchangeScope
public var range: DayRange
public var resources: ResourceBundle
public var services: [ServiceOccurrence]
public var assignments: [Assignment]
public var liturgicalDays: [LiturgicalDay]
public var note: String
public init(
formatVersion: Int = 1,
exportedAt: Date = Date(),
appName: String = "LektorenPlan",
scope: ExchangeScope,
range: DayRange,
resources: ResourceBundle,
services: [ServiceOccurrence] = [],
assignments: [Assignment] = [],
liturgicalDays: [LiturgicalDay] = [],
note: String = ""
) {
self.formatVersion = formatVersion
self.exportedAt = exportedAt
self.appName = appName
self.scope = scope
self.range = range
self.resources = resources
self.services = services
self.assignments = assignments
self.liturgicalDays = liturgicalDays
self.note = note
}
public var summary: ExchangeSummary {
ExchangeSummary(
scope: scope,
range: range,
churches: resources.churches.count,
people: resources.people.count,
templates: resources.templates.count,
services: services.count,
assignments: assignments.count,
liturgicalDays: liturgicalDays.count
)
}
}
public struct ExchangeSummary: Hashable, Sendable {
public var scope: ExchangeScope
public var range: DayRange
public var churches: Int
public var people: Int
public var templates: Int
public var services: Int
public var assignments: Int
public var liturgicalDays: Int
}
// MARK: - Planning
public struct PlannerOptions: Codable, Hashable, Sendable {
public var replaceExisting: Bool
public var respectPreferredWeekdays: Bool
public var allowDoubleRolesOnSameDay: Bool
public var weightChurchPreference: Double
public var weightServicePreference: Double
public var weightFairness: Double
public var maxAssignmentsPerDay: Int
public init(
replaceExisting: Bool = false,
respectPreferredWeekdays: Bool = true,
allowDoubleRolesOnSameDay: Bool = false,
weightChurchPreference: Double = 8,
weightServicePreference: Double = 4,
weightFairness: Double = 2.2,
maxAssignmentsPerDay: Int = 1
) {
self.replaceExisting = replaceExisting
self.respectPreferredWeekdays = respectPreferredWeekdays
self.allowDoubleRolesOnSameDay = allowDoubleRolesOnSameDay
self.weightChurchPreference = weightChurchPreference
self.weightServicePreference = weightServicePreference
self.weightFairness = weightFairness
self.maxAssignmentsPerDay = maxAssignmentsPerDay
}
}
public struct PlanResult: Sendable {
public var assignments: [Assignment]
public var unfilled: [UnfilledSlot]
public var filledCount: Int
public var message: String
public init(assignments: [Assignment] = [], unfilled: [UnfilledSlot] = [], filledCount: Int = 0, message: String = "") {
self.assignments = assignments
self.unfilled = unfilled
self.filledCount = filledCount
self.message = message
}
}
+236
View File
@@ -0,0 +1,236 @@
import Foundation
public struct ServicePlanner {
public var people: [Person]
public var absences: [Absence]
public var services: [ServiceOccurrence]
public var existingAssignments: [Assignment]
public var churches: [Church]
public var options: PlannerOptions
public init(
people: [Person],
absences: [Absence],
services: [ServiceOccurrence],
existingAssignments: [Assignment] = [],
churches: [Church] = [],
options: PlannerOptions = PlannerOptions()
) {
self.people = people
self.absences = absences
self.services = services
self.existingAssignments = existingAssignments
self.churches = churches
self.options = options
}
public func plan() -> PlanResult {
let activePeople = people.filter(\.active)
let peopleByID = Dictionary(uniqueKeysWithValues: activePeople.map { ($0.id, $0) })
let absencesByPerson = Dictionary(grouping: absences, by: \.personID)
let churchNames = Dictionary(uniqueKeysWithValues: churches.map { ($0.id, $0.name) })
var working: [Assignment]
if options.replaceExisting {
working = existingAssignments.filter(\.locked)
} else {
working = existingAssignments
}
var totalByPerson: [String: Int] = [:]
var monthByPerson: [String: Int] = [:]
var dayByPerson: [String: Int] = [:]
var churchByPerson: [String: [String: Int]] = [:]
var lastDateByPerson: [String: Date] = [:]
for assignment in working {
guard let service = services.first(where: { $0.id == assignment.serviceID }) else { continue }
let month = DayMath.monthKey(service.date)
totalByPerson[assignment.personID, default: 0] += 1
monthByPerson["\(assignment.personID)|\(month)", default: 0] += 1
dayByPerson["\(assignment.personID)|\(service.dateKey)", default: 0] += 1
churchByPerson[assignment.personID, default: [:]][service.churchID, default: 0] += 1
let previous = lastDateByPerson[assignment.personID]
if previous == nil || service.date > previous! {
lastDateByPerson[assignment.personID] = service.date
}
}
let sortedServices = services.sorted {
if $0.date != $1.date { return $0.date < $1.date }
if $0.timeMinutes != $1.timeMinutes { return $0.timeMinutes < $1.timeMinutes }
return $0.id < $1.id
}
var unfilled: [UnfilledSlot] = []
var newAssignments: [Assignment] = []
for service in sortedServices {
for role in Role.allCases {
let required = service.requiredCount(for: role)
guard required > 0 else { continue }
let existingForRole = working.filter { $0.serviceID == service.id && $0.role == role }.count
if existingForRole >= required { continue }
for _ in existingForRole..<required {
let alreadyAssigned = Set(working.filter { $0.serviceID == service.id }.map(\.personID))
let result = bestCandidate(
for: service,
role: role,
people: activePeople,
peopleByID: peopleByID,
absencesByPerson: absencesByPerson,
totalByPerson: totalByPerson,
monthByPerson: monthByPerson,
dayByPerson: dayByPerson,
churchByPerson: churchByPerson,
lastDateByPerson: lastDateByPerson,
alreadyAssigned: alreadyAssigned
)
switch result {
case .success(let person):
let assignment = Assignment(
serviceID: service.id,
personID: person.id,
role: role
)
newAssignments.append(assignment)
working.append(assignment)
totalByPerson[person.id, default: 0] += 1
monthByPerson["\(person.id)|\(DayMath.monthKey(service.date))", default: 0] += 1
dayByPerson["\(person.id)|\(service.dateKey)", default: 0] += 1
churchByPerson[person.id, default: [:]][service.churchID, default: 0] += 1
lastDateByPerson[person.id] = service.date
case .failure(let reason):
unfilled.append(UnfilledSlot(
service: service,
churchName: churchNames[service.churchID] ?? "",
role: role,
reason: reason
))
}
}
}
}
let filled = newAssignments.count
let message: String
if filled == 0 && unfilled.isEmpty {
message = "Alle Dienste im Zeitraum sind bereits vollständig besetzt."
} else if unfilled.isEmpty {
message = "\(filled) Dienst\(filled == 1 ? "" : "e") erfolgreich besetzt. Alle Lücken geschlossen."
} else {
message = "\(filled) Dienst\(filled == 1 ? "" : "e") besetzt, \(unfilled.count) Lücke\(unfilled.count == 1 ? "" : "n") bleiben offen."
}
if options.replaceExisting {
let locked = working.filter(\.locked)
let combined = locked + newAssignments
return PlanResult(assignments: combined, unfilled: unfilled, filledCount: filled, message: message)
}
return PlanResult(assignments: working, unfilled: unfilled, filledCount: filled, message: message)
}
private enum CandidateResult {
case success(Person)
case failure(String)
}
private func bestCandidate(
for service: ServiceOccurrence,
role: Role,
people: [Person],
peopleByID: [String: Person],
absencesByPerson: [String: [Absence]],
totalByPerson: [String: Int],
monthByPerson: [String: Int],
dayByPerson: [String: Int],
churchByPerson: [String: [String: Int]],
lastDateByPerson: [String: Date],
alreadyAssigned: Set<String>
) -> CandidateResult {
var candidates: [(Person, Double)] = []
var blockedReasons: [String: Int] = [:]
for person in people where person.canFill(role) {
guard !alreadyAssigned.contains(person.id) else {
blockedReasons["bereits im Gottesdienst", default: 0] += 1
continue
}
if let absences = absencesByPerson[person.id], absences.contains(where: { $0.overlaps(service.date) }) {
blockedReasons["abwesend", default: 0] += 1
continue
}
if options.respectPreferredWeekdays,
!person.preferredWeekdays.isEmpty,
!person.preferredWeekdays.contains(DayMath.weekday(service.date)) {
blockedReasons["Einsatztag passt nicht", default: 0] += 1
continue
}
let month = DayMath.monthKey(service.date)
let usedThisMonth = monthByPerson["\(person.id)|\(month)", default: 0]
if person.maxPerMonth > 0, usedThisMonth >= person.maxPerMonth {
blockedReasons["Monatslimit erreicht", default: 0] += 1
continue
}
let usedThisDay = dayByPerson["\(person.id)|\(service.dateKey)", default: 0]
if usedThisDay >= options.maxAssignmentsPerDay {
blockedReasons["bereits an diesem Tag", default: 0] += 1
continue
}
var score = 10.0
if person.preferredChurchIDs.contains(service.churchID) {
score += options.weightChurchPreference
}
if !person.preferredChurchIDs.isEmpty && !person.preferredChurchIDs.contains(service.churchID) {
score -= 1.5
}
if !person.preferredServiceTitles.isEmpty {
let title = service.title.lowercased()
for preference in person.preferredServiceTitles where !preference.isEmpty {
if title.contains(preference.lowercased()) {
score += options.weightServicePreference
}
}
}
if person.preferredWeekdays.contains(DayMath.weekday(service.date)) {
score += 3
}
let total = totalByPerson[person.id, default: 0]
score -= Double(total) * options.weightFairness
let churchCount = churchByPerson[person.id]?[service.churchID, default: 0] ?? 0
score -= Double(churchCount) * 0.4
if let last = lastDateByPerson[person.id] {
let gap = DayMath.daysBetween(last, service.date)
if gap >= 14 { score += 1.8 } else if gap >= 7 { score += 0.8 }
} else {
score += 2.5
}
score += stableTieBreak("\(person.id)|\(service.id)|\(role.rawValue)")
candidates.append((person, score))
}
guard let best = candidates.max(by: { $0.1 < $1.1 }) else {
let reason: String
if blockedReasons.isEmpty {
reason = "Keine geeignete Person mit Rolle \(role.title)"
} else if let top = blockedReasons.max(by: { $0.value < $1.value }) {
reason = "\(top.key) (\(top.value) ausgeschlossen)"
} else {
reason = "Keine geeignete Person"
}
return .failure(reason)
}
return .success(best.0)
}
private func stableTieBreak(_ value: String) -> Double {
var hash = 5381
for byte in value.utf8 {
hash = ((hash << 5) &+ hash) &+ Int(byte)
}
return Double(abs(hash % 997)) / 100_000
}
}
@@ -0,0 +1 @@
{"version":1,"source":"www.eucharistiefeier.de","diocese":"Erzbistum Köln","years":[2025,2026,2027,2028],"days":[{"date":"2025-01-01","title":"1. Januar - Neujahr","rank":"H","color":"w","bem":"Hochfest der Gottesmutter Maria","l1":"Num 6, 22-27","ap":"Ps 67 (66), 2-3.5.6 u. 8 (R: 2a)","l2":"Gal 4, 4-7","ev":"Lk 2, 16-21","obligation":true},{"date":"2025-01-02","title":"Hl. Basilius der Große (379) und hl. Gregor von Nazianz (um 390), Bischöfe, Kirchenlehrer","rank":"G","color":"w","bem":"","l1":"Eph 4, 1-7.11-13","ap":"Ps 23 (22), 1-3.4.5.6 (R: 1)","l2":"","ev":"Mt 23, 8-12","obligation":false},{"date":"2025-01-03","title":"Heiligster Name Jesu","rank":"g","color":"w","bem":"","l1":"Phil 2, 1-11","ap":"Ps 8, 4-5.6-7.8-9 (R: 2a)","l2":"","ev":"Lk 2, 21-24","obligation":false},{"date":"2025-01-04","title":"4. Januar","rank":"","color":"w","bem":"","l1":"1 Joh 3, 7-10","ap":"Ps 98 (97), 1.7-8.9 (R: vgl. 3cd)","l2":"","ev":"Joh 1, 35-42","obligation":false},{"date":"2025-01-05","title":"2. Sonntag nach Weihnachten","rank":"","color":"w","bem":"","l1":"Sir 24, 1-2.8-12 (1-4.12-16)","ap":"Ps 147, 12-13.14-15.19-20 (R: Joh 1, 14)","l2":"Eph 1, 3-6.15-18","ev":"Joh 1, 1-18","obligation":true},{"date":"2025-01-06","title":"Erscheinung des Herrn","rank":"H","color":"w","bem":"","l1":"Jes 60, 1-6","ap":"Ps 72 (71), 1-2.7-8.10-11.12-13 (R: 11)","l2":"Eph 3, 2-3a.5-6","ev":"Mt 2, 1-12","obligation":true},{"date":"2025-01-07","title":"Hl. Raimund von Peñafort, Ordensgründer (1275)","rank":"g","color":"w","bem":"","l1":"2 Kor 5, 14-20","ap":"Ps 103 (102), 1-2.3-4.8-9.13-14.17-18a (R: 11)","l2":"","ev":"Lk 12, 35-40","obligation":false},{"date":"2025-01-08","title":"Hl. Severin, Mönch in Norikum (482)","rank":"g","color":"w","bem":"","l1":"Jak 2, 14-17","ap":"Ps 107 (106), 1-2a u. 3.4-5.6-7.8-9 (R: vgl. Spr 31, 20)","l2":"","ev":"Mt 25, 31-46","obligation":false},{"date":"2025-01-09","title":"9. Januar","rank":"","color":"w","bem":"","l1":"1 Joh 4, 11-18","ap":"Ps 72 (71), 1-2.10-11.12-13 (R: 11)","l2":"","ev":"Mk 6, 45-52","obligation":false},{"date":"2025-01-10","title":"10. Januar","rank":"","color":"w","bem":"","l1":"1 Joh 4, 19 - 5, 4","ap":"Ps 72 (71), 1-2.14 u. 15bc.17 (R: 11)","l2":"","ev":"Lk 4, 14-22a","obligation":false},{"date":"2025-01-11","title":"11. Januar","rank":"","color":"w","bem":"","l1":"1 Joh 5, 5-13","ap":"Ps 147, 12-13.14-15.19-20 (R: 12a)","l2":"","ev":"Lk 5, 12-16","obligation":false},{"date":"2025-01-12","title":"Taufe des Herrn","rank":"F","color":"w","bem":"Sonntag nach dem 6. Januar","l1":"Jes 42, 5a.1-4.6-7 oder Jes 40, 1-5.9-11","ap":"Ps 29 (28), 1-2.3ac-4.3b u. 9b-10 (R: vgl. 11b) oder Ps 104 (103), 1-2.3-4.24-25.27-28.29-30 (R: 1ab)","l2":"Apg 10, 34-38 oder Tit 2, 11-14; 3, 4-7","ev":"Lk 3, 15-16.21-22","obligation":true},{"date":"2025-01-13","title":"Hl. Hilarius, Bischof von Poitiers, Kirchenlehrer (um 367)","rank":"g","color":"w","bem":"","l1":"1 Joh 2, 18-25","ap":"Ps 110 (109), 1-2.3.4-5 (R: 4b)","l2":"","ev":"Mt 5, 13-19","obligation":false},{"date":"2025-01-14","title":"Dienstag der 1. Woche im Jahreskreis","rank":"","color":"g","bem":"","l1":"Hebr 2, 5-12","ap":"Ps 8, 2 u. 5.6-7.8-9 (R: vgl. 7)","l2":"","ev":"Mk 1, 21-28","obligation":false},{"date":"2025-01-15","title":"Mittwoch der 1. Woche im Jahreskreis","rank":"","color":"g","bem":"","l1":"Hebr 2, 11-12.13c-18","ap":"Ps 105 (104), 1-2.3-4.6-7.8-9 (R: 7a.8a)","l2":"","ev":"Mk 1, 29-39","obligation":false},{"date":"2025-01-16","title":"Donnerstag der 1. Woche im Jahreskreis","rank":"","color":"g","bem":"","l1":"Hebr 3, 7-14","ap":"Ps 95 (94), 6-7b.7c-9.10-11 (R: vgl. 7c.8a)","l2":"","ev":"Mk 1, 40-45","obligation":false},{"date":"2025-01-17","title":"Hl. Antonius, Mönchsvater in Ägypten (356)","rank":"G","color":"w","bem":"","l1":"Eph 6, 10-13.18","ap":"Ps 16 (15), 1-2 u. 5.7-8.9 u. 11 (R: vgl. 5a)","l2":"","ev":"Mt 19, 16-26","obligation":false},{"date":"2025-01-18","title":"Samstag der 1. Woche im Jahreskreis","rank":"","color":"g","bem":"","l1":"Hebr 4, 12-16","ap":"Ps 19 (18B), 8.9.10.11 u. 15 (R: vgl. Joh 6, 63b)","l2":"","ev":"Mk 2, 13-17","obligation":false},{"date":"2025-01-19","title":"2. Sonntag im Jahreskreis","rank":"","color":"g","bem":"","l1":"Jes 62, 1-5","ap":"Ps 96 (95), 1-2.3-4.6-7.10 (R: vgl. 3a)","l2":"1 Kor 12, 4-11","ev":"Joh 2, 1-11","obligation":true},{"date":"2025-01-20","title":"Hl. Fabian, Papst, Märtyrer (250)","rank":"g","color":"r","bem":"","l1":"1 Petr 5, 1-4","ap":"Ps 40 (39), 2 u. 4ab.7-8.9-10 (R: vgl. 8a.9a)","l2":"","ev":"Joh 21, 1.15-17","obligation":false},{"date":"2025-01-21","title":"Hl. Agnes, Jungfrau, Märtyrin in Rom (304)","rank":"g","color":"r","bem":"","l1":"1 Kor 1, 26-31","ap":"Ps 23 (22), 1-3.4.5.6 (R: 1)","l2":"","ev":"Mt 13, 44-46","obligation":false},{"date":"2025-01-22","title":"Hl. Vinzenz, Diakon, Märtyrer in Spanien (304)","rank":"g","color":"r","bem":"","l1":"2 Kor 4, 7-15","ap":"Ps 34 (33), 2-3.4-5.6-7.8-9 (R: vgl. 5b)","l2":"","ev":"Mt 10, 17-22","obligatioLine truncated
@@ -0,0 +1,221 @@
import Foundation
import SQLite3
private let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
public enum SQLiteValue: Sendable, Hashable {
case text(String)
case int(Int)
case double(Double)
case null
public static func bool(_ value: Bool) -> SQLiteValue { .int(value ? 1 : 0) }
public static func dateKey(_ date: Date) -> SQLiteValue { .text(DayMath.key(date)) }
public static func optionalText(_ value: String?) -> SQLiteValue { value.map { .text($0) } ?? .null }
}
public struct SQLiteRow: Sendable {
public let values: [String: SQLiteValue]
public func string(_ key: String) -> String? {
guard case .text(let value)? = values[key] else { return nil }
return value
}
public func string(_ key: String, default defaultValue: String) -> String {
string(key) ?? defaultValue
}
public func int(_ key: String) -> Int? {
switch values[key] {
case .int(let value): return value
case .text(let value): return Int(value)
case .double(let value): return Int(value)
default: return nil
}
}
public func int(_ key: String, default defaultValue: Int) -> Int {
int(key) ?? defaultValue
}
public func double(_ key: String) -> Double? {
switch values[key] {
case .double(let value): return value
case .int(let value): return Double(value)
case .text(let value): return Double(value)
default: return nil
}
}
public func bool(_ key: String, default defaultValue: Bool = false) -> Bool {
guard let value = int(key) else { return defaultValue }
return value != 0
}
public func date(_ key: String) -> Date? {
guard let raw = string(key) else { return nil }
return DayMath.date(fromKey: raw)
}
}
public struct SQLiteError: LocalizedError {
public var message: String
public var code: Int32
public var errorDescription: String? { "SQLite \(code): \(message)" }
}
public final class SQLiteDatabase {
private var handle: OpaquePointer?
private let lock = NSRecursiveLock()
public let path: String
public init(path: String) throws {
self.path = path
var db: OpaquePointer?
let flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX
let result = sqlite3_open_v2(path, &db, flags, nil)
guard result == SQLITE_OK, let db else {
let message = db.map { String(cString: sqlite3_errmsg($0)) } ?? "Unbekannter Fehler"
if let db { sqlite3_close(db) }
throw SQLiteError(message: message, code: result)
}
self.handle = db
sqlite3_busy_timeout(db, 5_000)
if path != ":memory:" {
try execute("PRAGMA journal_mode=WAL;")
}
try execute("PRAGMA foreign_keys=ON;")
try execute("PRAGMA synchronous=NORMAL;")
}
deinit {
if let handle {
sqlite3_close(handle)
}
}
public func execute(_ sql: String) throws {
lock.lock()
defer { lock.unlock() }
guard let handle else { throw SQLiteError(message: "Datenbank geschlossen", code: SQLITE_MISUSE) }
var errorMessage: UnsafeMutablePointer<CChar>?
let result = sqlite3_exec(handle, sql, nil, nil, &errorMessage)
if result != SQLITE_OK {
let message = errorMessage.map { String(cString: $0) } ?? "Unbekannter Fehler"
sqlite3_free(errorMessage)
throw SQLiteError(message: message, code: result)
}
}
public func run(_ sql: String, _ params: [SQLiteValue] = []) throws {
lock.lock()
defer { lock.unlock() }
let statement = try prepare(sql)
defer { sqlite3_finalize(statement) }
try bind(params, to: statement)
let result = sqlite3_step(statement)
guard result == SQLITE_DONE || result == SQLITE_ROW else {
throw currentError(code: result)
}
}
public func query(_ sql: String, _ params: [SQLiteValue] = []) throws -> [SQLiteRow] {
lock.lock()
defer { lock.unlock() }
let statement = try prepare(sql)
defer { sqlite3_finalize(statement) }
try bind(params, to: statement)
var rows: [SQLiteRow] = []
while true {
let result = sqlite3_step(statement)
if result == SQLITE_DONE { break }
guard result == SQLITE_ROW else { throw currentError(code: result) }
var values: [String: SQLiteValue] = [:]
for index in 0..<sqlite3_column_count(statement) {
let name = String(cString: sqlite3_column_name(statement, index))
switch sqlite3_column_type(statement, index) {
case SQLITE_INTEGER:
values[name] = .int(Int(sqlite3_column_int64(statement, index)))
case SQLITE_FLOAT:
values[name] = .double(sqlite3_column_double(statement, index))
case SQLITE_TEXT:
if let text = sqlite3_column_text(statement, index) {
values[name] = .text(String(cString: text))
} else {
values[name] = .null
}
default:
values[name] = .null
}
}
rows.append(SQLiteRow(values: values))
}
return rows
}
public func scalarInt(_ sql: String, _ params: [SQLiteValue] = []) throws -> Int {
guard let row = try query(sql, params).first else { return 0 }
if let value = row.int("value") { return value }
guard case .int(let first)? = row.values.values.first else { return 0 }
return first
}
public var lastInsertRowID: Int64 {
lock.lock()
defer { lock.unlock() }
guard let handle else { return 0 }
return sqlite3_last_insert_rowid(handle)
}
@discardableResult
public func transaction<T>(_ body: () throws -> T) throws -> T {
lock.lock()
defer { lock.unlock() }
try execute("BEGIN IMMEDIATE;")
do {
let value = try body()
try execute("COMMIT;")
return value
} catch {
try? execute("ROLLBACK;")
throw error
}
}
private func prepare(_ sql: String) throws -> OpaquePointer {
guard let handle else { throw SQLiteError(message: "Datenbank geschlossen", code: SQLITE_MISUSE) }
var statement: OpaquePointer?
let result = sqlite3_prepare_v2(handle, sql, -1, &statement, nil)
guard result == SQLITE_OK, let statement else {
throw currentError(code: result)
}
return statement
}
private func bind(_ params: [SQLiteValue], to statement: OpaquePointer) throws {
for (offset, value) in params.enumerated() {
let index = Int32(offset + 1)
let result: Int32
switch value {
case .text(let string):
result = sqlite3_bind_text(statement, index, string, -1, SQLITE_TRANSIENT)
case .int(let int):
result = sqlite3_bind_int64(statement, index, Int64(int))
case .double(let double):
result = sqlite3_bind_double(statement, index, double)
case .null:
result = sqlite3_bind_null(statement, index)
}
guard result == SQLITE_OK else { throw currentError(code: result) }
}
}
private func currentError(code: Int32) -> SQLiteError {
let message = handle.map { String(cString: sqlite3_errmsg($0)) } ?? "Unbekannter Fehler"
return SQLiteError(message: message, code: code)
}
}
+149
View File
@@ -0,0 +1,149 @@
import Foundation
public enum StatisticsCalculator {
public static func compute(
range: DayRange,
services: [ServiceOccurrence],
assignments: [Assignment],
people: [Person],
churches: [Church],
absences: [Absence] = []
) -> RangeStatistics {
let servicesByID = Dictionary(uniqueKeysWithValues: services.map { ($0.id, $0) })
let peopleByID = Dictionary(uniqueKeysWithValues: people.map { ($0.id, $0) })
let assignmentsByPerson = Dictionary(grouping: assignments, by: \.personID)
let assignmentsByService = Dictionary(grouping: assignments, by: \.serviceID)
var personStats: [PersonStat] = people.map { person in
let own = assignmentsByPerson[person.id] ?? []
var lectors = 0
var helpers = 0
var churchCounts: [String: Int] = [:]
var preferredHits = 0
var sundays = 0
var lastDate: Date?
for assignment in own {
guard let service = servicesByID[assignment.serviceID] else { continue }
if assignment.role == .lector { lectors += 1 } else { helpers += 1 }
churchCounts[service.churchID, default: 0] += 1
if DayMath.isSunday(service.date) { sundays += 1 }
if lastDate == nil || service.date > lastDate! { lastDate = service.date }
if preferenceHit(person: person, service: service) { preferredHits += 1 }
}
return PersonStat(
person: person,
total: own.count,
lectors: lectors,
helpers: helpers,
churchCounts: churchCounts,
preferredHits: preferredHits,
sundayCount: sundays,
lastAssignment: lastDate
)
}
personStats.sort {
if $0.total != $1.total { return $0.total > $1.total }
return $0.person.lastName < $1.person.lastName
}
var churchStats: [ChurchStat] = churches.map { church in
let churchServices = services.filter { $0.churchID == church.id }
let serviceIDs = Set(churchServices.map(\.id))
let churchAssignments = assignments.filter { serviceIDs.contains($0.serviceID) }
let open = churchServices.reduce(0) { partial, service in
partial + max(0, service.requiredSlots - (assignmentsByService[service.id]?.count ?? 0))
}
return ChurchStat(
church: church,
assignments: churchAssignments.count,
services: churchServices.count,
openSlots: open,
personCount: Set(churchAssignments.map(\.personID)).count
)
}
churchStats.sort { $0.church.sortIndex < $1.church.sortIndex }
var monthly: [String: Int] = [:]
for assignment in assignments {
guard let service = servicesByID[assignment.serviceID] else { continue }
monthly[DayMath.monthKey(service.date), default: 0] += 1
}
let sundayServices = services.filter { DayMath.isSunday($0.date) }
let sundayServiceIDs = Set(sundayServices.map(\.id))
let sundayFilled = assignments.filter { sundayServiceIDs.contains($0.serviceID) }.count
let requiredSlots = services.reduce(0) { $0 + $1.requiredSlots }
let openSlots = max(0, requiredSlots - assignments.count)
var preferenceHits = 0
var preferenceEligible = 0
for assignment in assignments {
guard let service = servicesByID[assignment.serviceID],
let person = peopleByID[assignment.personID] else { continue }
if hasAnyPreference(person) {
preferenceEligible += 1
if preferenceHit(person: person, service: service) { preferenceHits += 1 }
}
}
let activePeople = Set(people.filter(\.active).map(\.id))
var absenceDays = 0
for absence in absences where activePeople.contains(absence.personID) {
let clamped = absence.range.clamped(to: range)
if clamped.start <= clamped.end { absenceDays += clamped.dayCount }
}
return RangeStatistics(
range: range,
serviceCount: services.count,
assignmentCount: assignments.count,
openSlots: openSlots,
requiredSlots: requiredSlots,
personStats: personStats,
churchStats: churchStats,
monthlyCounts: monthly,
sundayServiceCount: sundayServices.count,
sundayFilled: sundayFilled,
preferenceHits: preferenceHits,
preferenceEligible: preferenceEligible,
absenceDays: absenceDays
)
}
public static func hasAnyPreference(_ person: Person) -> Bool {
!person.preferredChurchIDs.isEmpty || !person.preferredWeekdays.isEmpty || !person.preferredServiceTitles.isEmpty
}
public static func preferenceHit(person: Person, service: ServiceOccurrence) -> Bool {
if person.preferredChurchIDs.contains(service.churchID) { return true }
if person.preferredWeekdays.contains(DayMath.weekday(service.date)) { return true }
let title = service.title.lowercased()
for preference in person.preferredServiceTitles where !preference.isEmpty {
if title.contains(preference.lowercased()) { return true }
}
return false
}
public static func candidateReasons(
person: Person,
service: ServiceOccurrence,
absences: [Absence],
assignments: [Assignment]
) -> [String] {
var reasons: [String] = []
if !person.active { reasons.append("inaktiv") }
if !person.canFill(.lector) && !person.canFill(.helper) { reasons.append("keine Rolle") }
if absences.contains(where: { $0.personID == person.id && $0.overlaps(service.date) }) {
reasons.append("abwesend")
}
if !person.preferredWeekdays.isEmpty && !person.preferredWeekdays.contains(DayMath.weekday(service.date)) {
reasons.append("Einsatztag passt nicht")
}
if assignments.contains(where: { $0.serviceID == service.id && $0.personID == person.id }) {
reasons.append("bereits eingeteilt")
}
return reasons
}
}