Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming. Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
228 lines
6.7 KiB
Go
228 lines
6.7 KiB
Go
// Package calendar implements file-backed calendars. SQLite is a disposable index.
|
|
package calendar
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
ical "github.com/emersion/go-ical"
|
|
)
|
|
|
|
const MaxResource = 256 << 10
|
|
|
|
var ErrInvalid = errors.New("invalid or unsupported iCalendar data")
|
|
|
|
type Event struct {
|
|
UID string `json:"uid"`
|
|
Summary string `json:"summary"`
|
|
Description string `json:"description"`
|
|
Location string `json:"location"`
|
|
Start time.Time `json:"start"`
|
|
End time.Time `json:"end"`
|
|
AllDay bool `json:"all_day"`
|
|
ETag string `json:"etag"`
|
|
Data string `json:"-"`
|
|
}
|
|
|
|
func digest(data []byte) string { h := sha256.Sum256(data); return hex.EncodeToString(h[:]) }
|
|
func envelope(events ...*ical.Component) *ical.Calendar {
|
|
c := ical.NewCalendar()
|
|
c.Props.SetText("VERSION", "2.0")
|
|
c.Props.SetText("PRODID", "-//PagesWiki//Calendar 1//EN")
|
|
c.Children = events
|
|
return c
|
|
}
|
|
func encode(c *ical.Calendar) (string, error) {
|
|
var b bytes.Buffer
|
|
err := ical.NewEncoder(&b).Encode(c)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
// RFC 5545 3.1: fold at 75 octets without splitting a UTF-8 sequence.
|
|
var out strings.Builder
|
|
for _, line := range strings.Split(strings.TrimSuffix(b.String(), "\r\n"), "\r\n") {
|
|
limit := 75
|
|
for len(line) > limit {
|
|
n := limit
|
|
for n > 0 && !utf8.RuneStart(line[n]) {
|
|
n--
|
|
}
|
|
out.WriteString(line[:n])
|
|
out.WriteString("\r\n ")
|
|
line = line[n:]
|
|
limit = 74
|
|
}
|
|
out.WriteString(line)
|
|
out.WriteString("\r\n")
|
|
}
|
|
return out.String(), nil
|
|
}
|
|
|
|
// Parse deliberately accepts a declared, lossless subset. Unsupported temporal
|
|
// semantics are rejected, never accepted and silently omitted from REPORT.
|
|
func Parse(data string) (Event, error) {
|
|
bad := func(reason string) (Event, error) { return Event{}, fmt.Errorf("%w: %s", ErrInvalid, reason) }
|
|
if len(data) > MaxResource || !utf8.ValidString(data) || strings.ContainsRune(data, 0) {
|
|
return bad("size or encoding")
|
|
}
|
|
for _, ch := range data {
|
|
if ch < 32 && ch != '\r' && ch != '\n' && ch != '\t' || ch == 127 {
|
|
return bad("control character")
|
|
}
|
|
}
|
|
dec := ical.NewDecoder(strings.NewReader(data))
|
|
c, err := dec.Decode()
|
|
if err != nil {
|
|
return bad(err.Error())
|
|
}
|
|
if _, err = dec.Decode(); err != io.EOF {
|
|
return bad("one VCALENDAR required")
|
|
}
|
|
if len(c.Children) != 1 || c.Children[0].Name != "VEVENT" {
|
|
return bad("exactly one VEVENT required; recurrence and VTIMEZONE are not yet supported")
|
|
}
|
|
if c.Props.Get("METHOD") != nil {
|
|
return bad("scheduling METHOD is not supported")
|
|
}
|
|
v, _ := c.Props.Text("VERSION")
|
|
if v != "2.0" {
|
|
return bad("VERSION must be 2.0")
|
|
}
|
|
if product, err := c.Props.Text("PRODID"); err != nil || product == "" {
|
|
return bad("PRODID is required")
|
|
}
|
|
// Collection-level properties cannot be merged losslessly into monthly files.
|
|
for name := range c.Props {
|
|
if name != "VERSION" && name != "PRODID" && name != "CALSCALE" {
|
|
return bad("unsupported VCALENDAR property: " + name)
|
|
}
|
|
}
|
|
if scale, _ := c.Props.Text("CALSCALE"); scale != "" && scale != "GREGORIAN" {
|
|
return bad("unsupported calendar scale")
|
|
}
|
|
e := ical.Event{Component: c.Children[0]}
|
|
for _, key := range []string{"RRULE", "RDATE", "EXDATE", "RECURRENCE-ID", "DURATION"} {
|
|
if e.Props.Get(key) != nil {
|
|
return bad(key + " is not yet supported")
|
|
}
|
|
}
|
|
if len(e.Children) > 0 {
|
|
return bad("VALARM delivery is not yet supported")
|
|
}
|
|
for _, key := range []string{"UID", "DTSTAMP", "DTSTART"} {
|
|
if len(e.Props[key]) != 1 {
|
|
return bad(key + " must occur exactly once")
|
|
}
|
|
}
|
|
uid, err := e.Props.Text("UID")
|
|
if err != nil || uid == "" || len(uid) > 512 || strings.ContainsAny(uid, "\r\n\x00") {
|
|
return bad("invalid UID")
|
|
}
|
|
startProp := e.Props.Get("DTSTART")
|
|
allDay := startProp.ValueType() == ical.ValueDate
|
|
for _, key := range []string{"DTSTART", "DTEND", "DTSTAMP", "CREATED", "LAST-MODIFIED"} {
|
|
p := e.Props.Get(key)
|
|
if p == nil {
|
|
continue
|
|
}
|
|
date := p.ValueType() == ical.ValueDate
|
|
if p.Params.Get("TZID") != "" || (!date && !strings.HasSuffix(p.Value, "Z")) {
|
|
return bad("only UTC DATE-TIME or DATE supported")
|
|
}
|
|
if (key == "DTEND" && date != allDay) || (key != "DTSTART" && key != "DTEND" && date) {
|
|
return bad("inconsistent date types")
|
|
}
|
|
t, err := p.DateTime(time.UTC)
|
|
if err != nil || t.Year() < 1 || t.Year() > 9998 {
|
|
return bad("invalid " + key)
|
|
}
|
|
}
|
|
start, err := e.DateTimeStart(time.UTC)
|
|
if err != nil {
|
|
return bad("invalid DTSTART")
|
|
}
|
|
end, err := e.DateTimeEnd(time.UTC)
|
|
if err != nil || end.Before(start) || (e.Props.Get("DTEND") != nil && !end.After(start)) {
|
|
return bad("DTEND must follow DTSTART")
|
|
}
|
|
if _, err = e.Status(); err != nil {
|
|
return bad(err.Error())
|
|
}
|
|
// Encoder validates required properties, cardinality and child components.
|
|
canonical, err := encode(c)
|
|
if err != nil {
|
|
return bad(err.Error())
|
|
}
|
|
// Normalize the envelope, preserving every accepted event property/parameter.
|
|
canonical, err = encode(envelope(e.Component))
|
|
if err != nil {
|
|
return bad(err.Error())
|
|
}
|
|
result := Event{UID: uid, Start: start, End: end, AllDay: allDay, Data: canonical, ETag: "\"" + digest([]byte(canonical)) + "\""}
|
|
for key, dst := range map[string]*string{"SUMMARY": &result.Summary, "DESCRIPTION": &result.Description, "LOCATION": &result.Location} {
|
|
s, err := e.Props.Text(key)
|
|
if err != nil {
|
|
return bad(key)
|
|
}
|
|
*dst = s
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func component(data string) (*ical.Component, error) {
|
|
c, e := ical.NewDecoder(strings.NewReader(data)).Decode()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return c.Children[0], nil
|
|
}
|
|
|
|
// Build changes only UI-owned fields. Unknown properties survive browser edits.
|
|
func Build(old string, item Event) (Event, error) {
|
|
e := ical.NewEvent()
|
|
if old != "" {
|
|
c, err := component(old)
|
|
if err != nil {
|
|
return Event{}, err
|
|
}
|
|
e.Component = c
|
|
}
|
|
e.Props.SetText("UID", item.UID)
|
|
e.Props.SetText("SUMMARY", item.Summary)
|
|
e.Props.SetText("DESCRIPTION", item.Description)
|
|
e.Props.SetText("LOCATION", item.Location)
|
|
e.Props.SetDateTime("DTSTAMP", time.Now().UTC().Truncate(time.Second))
|
|
e.Props.SetDateTime("LAST-MODIFIED", time.Now().UTC().Truncate(time.Second))
|
|
for name, t := range map[string]time.Time{"DTSTART": item.Start, "DTEND": item.End} {
|
|
p := ical.NewProp(name)
|
|
if item.AllDay {
|
|
p.SetDate(t.UTC())
|
|
} else {
|
|
p.SetDateTime(t.UTC())
|
|
}
|
|
e.Props.Set(p)
|
|
}
|
|
if old != "" {
|
|
n := 0
|
|
if p := e.Props.Get("SEQUENCE"); p != nil {
|
|
n, _ = strconv.Atoi(p.Value)
|
|
}
|
|
p := ical.NewProp("SEQUENCE")
|
|
p.Value = strconv.Itoa(n + 1)
|
|
e.Props.Set(p)
|
|
}
|
|
data, err := encode(envelope(e.Component))
|
|
if err != nil {
|
|
return Event{}, err
|
|
}
|
|
return Parse(data)
|
|
}
|