Files
2026-11-12 20:00:33 +01:00

146 lines
3.5 KiB
Go

package liturgy
import (
_ "embed"
"encoding/json"
"fmt"
"sort"
"time"
"lektorenplan/domain"
)
// SourceLabel is the attribution required by the data source.
const SourceLabel = "Daten von www.eucharistiefeier.de"
//go:embed liturgical-snapshot.json
var snapshotJSON []byte
type snapshotFile struct {
Version int `json:"version"`
Source string `json:"source"`
Diocese string `json:"diocese"`
Years []int `json:"years"`
Days []snapshotDay `json:"days"`
}
type snapshotDay struct {
Date string `json:"date"`
Title string `json:"title"`
Rank string `json:"rank"`
Color string `json:"color"`
Remark string `json:"bem"`
First string `json:"l1"`
Psalm string `json:"ap"`
Second string `json:"l2"`
Gospel string `json:"ev"`
Obligation bool `json:"obligation"`
}
var (
cachedSnapshot []domain.LiturgicalDay
cachedSnapshotOnce bool
)
func loadSnapshot() (snapshotFile, error) {
var file snapshotFile
if err := json.Unmarshal(snapshotJSON, &file); err != nil {
return file, fmt.Errorf("liturgical snapshot: %w", err)
}
return file, nil
}
// SnapshotLoaded reports whether the embedded JSON could be decoded.
func SnapshotLoaded() bool {
_, err := loadSnapshot()
return err == nil
}
// SnapshotYears returns the years covered by the embedded snapshot.
func SnapshotYears() []int {
file, err := loadSnapshot()
if err != nil {
return nil
}
return file.Years
}
// SnapshotDays returns the bundled offline calendar.
func SnapshotDays() []domain.LiturgicalDay {
if cachedSnapshotOnce {
return cachedSnapshot
}
cachedSnapshotOnce = true
file, err := loadSnapshot()
if err != nil {
return nil
}
days := make([]domain.LiturgicalDay, 0, len(file.Days))
for _, entry := range file.Days {
date, ok := domain.DateFromKey(entry.Date)
if !ok {
continue
}
days = append(days, domain.LiturgicalDay{
Date: date,
Title: entry.Title,
Rank: domain.LiturgicalRank(entry.Rank),
Color: domain.LiturgicalColorFromAPI(entry.Color),
Remark: entry.Remark,
Readings: domain.Readings{
First: entry.First,
Psalm: entry.Psalm,
Second: entry.Second,
Gospel: entry.Gospel,
},
IsObligation: entry.Obligation,
Source: SourceLabel,
UpdatedAt: domain.Normalize(time.Now()),
})
}
cachedSnapshot = days
return days
}
// SnapshotDaysForYear returns the bundled days of one calendar year.
func SnapshotDaysForYear(year int) []domain.LiturgicalDay {
var out []domain.LiturgicalDay
for _, day := range SnapshotDays() {
if domain.Year(day.Date) == year {
out = append(out, day)
}
}
return out
}
// SnapshotMissing returns bundled days whose date keys are not yet present.
func SnapshotMissing(existing map[string]bool) []domain.LiturgicalDay {
var out []domain.LiturgicalDay
for _, day := range SnapshotDays() {
if !existing[day.DateKey()] {
out = append(out, day)
}
}
return out
}
// FillLocalGaps completes a year with the local calendar so a plan never has
// empty rows when the online source omits days.
func FillLocalGaps(year int, days []domain.LiturgicalDay) []domain.LiturgicalDay {
seen := make(map[string]bool, len(days))
for _, day := range days {
seen[day.DateKey()] = true
}
for _, day := range domain.YearRange(year).Days() {
if !seen[domain.Key(day)] {
days = append(days, LocalDay(day))
}
}
sortDays(days)
return days
}
func sortDays(days []domain.LiturgicalDay) {
sort.Slice(days, func(i, j int) bool { return days[i].Date.Before(days[j].Date) })
}