146 lines
3.5 KiB
Go
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) })
|
|
}
|