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

+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
}
}