122 lines
3.8 KiB
Go
122 lines
3.8 KiB
Go
package mail
|
|
|
|
import (
|
|
"embed"
|
|
"fmt"
|
|
htmltmpl "html/template"
|
|
"io/fs"
|
|
"strings"
|
|
texttmpl "text/template"
|
|
"time"
|
|
)
|
|
|
|
//go:embed templates
|
|
var files embed.FS
|
|
|
|
// A message is rendered from three files: the shared layout, which owns every
|
|
// colour and every piece of chrome, and the message's own html/txt pair, which
|
|
// owns only its subject and its content. There is one template set per message
|
|
// rather than one big set, because each message defines "subject" and "body"
|
|
// under the same names and they would otherwise collide.
|
|
type set struct {
|
|
html *htmltmpl.Template
|
|
text *texttmpl.Template
|
|
}
|
|
|
|
var sets = map[string]set{}
|
|
|
|
func init() {
|
|
entries, err := fs.Glob(files, "templates/*.html.tmpl")
|
|
if err != nil {
|
|
panic("mail: glob templates: " + err.Error())
|
|
}
|
|
for _, e := range entries {
|
|
name := strings.TrimSuffix(strings.TrimPrefix(e, "templates/"), ".html.tmpl")
|
|
if name == "layout" {
|
|
continue
|
|
}
|
|
h, err := htmltmpl.New("layout.html.tmpl").Funcs(htmltmpl.FuncMap(funcs)).
|
|
ParseFS(files, "templates/layout.html.tmpl", e)
|
|
if err != nil {
|
|
panic("mail: parse " + e + ": " + err.Error())
|
|
}
|
|
t, err := texttmpl.New("layout.txt.tmpl").Funcs(texttmpl.FuncMap(funcs)).
|
|
ParseFS(files, "templates/layout.txt.tmpl", "templates/"+name+".txt.tmpl")
|
|
if err != nil {
|
|
panic("mail: parse " + name + ".txt.tmpl: " + err.Error())
|
|
}
|
|
sets[name] = set{html: h, text: t}
|
|
}
|
|
}
|
|
|
|
// render produces the subject and both bodies for one message.
|
|
//
|
|
// The subject comes from the text set, not the HTML one: html/template would
|
|
// escape an ampersand in an instance name into "&" and mail clients show
|
|
// subjects verbatim.
|
|
func render(name string, data any) (message, error) {
|
|
s, ok := sets[name]
|
|
if !ok {
|
|
return message{}, fmt.Errorf("no such template")
|
|
}
|
|
|
|
var subject, text, html strings.Builder
|
|
if err := s.text.ExecuteTemplate(&subject, "subject", data); err != nil {
|
|
return message{}, err
|
|
}
|
|
if err := s.text.Execute(&text, data); err != nil {
|
|
return message{}, err
|
|
}
|
|
if err := s.html.Execute(&html, data); err != nil {
|
|
return message{}, err
|
|
}
|
|
|
|
return message{
|
|
Subject: strings.TrimSpace(subject.String()),
|
|
Text: normaliseText(text.String()),
|
|
HTML: html.String(),
|
|
}, nil
|
|
}
|
|
|
|
// normaliseText gives the plain part CRLF line endings and collapses the blank
|
|
// runs that fall out of templating whitespace.
|
|
func normaliseText(s string) string {
|
|
s = strings.ReplaceAll(s, "\r\n", "\n")
|
|
for strings.Contains(s, "\n\n\n") {
|
|
s = strings.ReplaceAll(s, "\n\n\n", "\n\n")
|
|
}
|
|
s = strings.TrimSpace(s) + "\n"
|
|
return strings.ReplaceAll(s, "\n", "\r\n")
|
|
}
|
|
|
|
// funcs are shared by both template flavours. They exist so that a message
|
|
// template never formats a date or builds a structure itself — two templates
|
|
// formatting the same date two ways is exactly the drift this package removes.
|
|
var funcs = map[string]any{
|
|
// dict builds a map for the layout's helper templates, which take more
|
|
// than one argument. Go templates have no literal for this.
|
|
"dict": func(kv ...any) (map[string]any, error) {
|
|
if len(kv)%2 != 0 {
|
|
return nil, fmt.Errorf("dict: odd argument count")
|
|
}
|
|
m := make(map[string]any, len(kv)/2)
|
|
for i := 0; i < len(kv); i += 2 {
|
|
k, ok := kv[i].(string)
|
|
if !ok {
|
|
return nil, fmt.Errorf("dict: key %d is not a string", i)
|
|
}
|
|
m[k] = kv[i+1]
|
|
}
|
|
return m, nil
|
|
},
|
|
"list": func(v ...any) []any { return v },
|
|
|
|
// date is the one long-date format used across every Vantage email.
|
|
"date": func(t time.Time) string { return t.Format("2 January 2006") },
|
|
// shortDate drops the year, for subject lines where it is obvious.
|
|
"shortDate": func(t time.Time) string { return t.Format("2 January") },
|
|
"stamp": func(t time.Time) string { return t.Format("2006-01-02 15:04:05 MST") },
|
|
"hours": func(d time.Duration) int { return int(d.Hours()) },
|
|
"upper": strings.ToUpper,
|
|
}
|