143 lines
3 KiB
Go
143 lines
3 KiB
Go
package templates
|
|
|
|
import (
|
|
"bytes"
|
|
"embed"
|
|
"fmt"
|
|
"io/fs"
|
|
"slices"
|
|
"sync"
|
|
"text/template"
|
|
|
|
"github.com/evcc-io/evcc/templates/definition"
|
|
"github.com/samber/lo"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
var (
|
|
//go:embed includes/*.tpl
|
|
includeFS embed.FS
|
|
|
|
// baseTmpl holds all included template definitions
|
|
baseTmpl *template.Template
|
|
|
|
templates = make(map[Class][]Template)
|
|
ConfigDefaults configDefaults
|
|
mu sync.Mutex
|
|
encoderLanguage string
|
|
)
|
|
|
|
func init() {
|
|
ConfigDefaults.Load()
|
|
|
|
baseTmpl = template.Must(template.ParseFS(includeFS, "includes/*.tpl"))
|
|
|
|
for _, class := range []Class{Charger, Meter, Vehicle, Tariff} {
|
|
templates[class] = load(class)
|
|
}
|
|
}
|
|
|
|
func FromBytes(b []byte) (Template, error) {
|
|
// panic if template definition contains unknown fields
|
|
dec := yaml.NewDecoder(bytes.NewReader(b))
|
|
dec.KnownFields(true)
|
|
|
|
var definition TemplateDefinition
|
|
if err := dec.Decode(&definition); err != nil {
|
|
return Template{}, err
|
|
}
|
|
|
|
tmpl := Template{
|
|
TemplateDefinition: definition,
|
|
}
|
|
|
|
err := tmpl.ResolvePresets()
|
|
if err == nil {
|
|
err = tmpl.ResolveGroup()
|
|
}
|
|
if err == nil {
|
|
err = tmpl.UpdateParamsWithDefaults()
|
|
}
|
|
if err == nil {
|
|
err = tmpl.Validate()
|
|
}
|
|
|
|
return tmpl, err
|
|
}
|
|
|
|
func load(class Class) (res []Template) {
|
|
err := fs.WalkDir(definition.YamlTemplates, class.String(), func(filepath string, d fs.DirEntry, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if d.IsDir() {
|
|
return nil
|
|
}
|
|
|
|
b, err := fs.ReadFile(definition.YamlTemplates, filepath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
tmpl, err := FromBytes(b)
|
|
if err != nil {
|
|
return fmt.Errorf("processing template '%s' failed: %w", filepath, err)
|
|
}
|
|
|
|
if slices.ContainsFunc(res, func(t Template) bool { return t.Template == tmpl.Template }) {
|
|
return fmt.Errorf("duplicate template name '%s' found in file '%s'", tmpl.Template, filepath)
|
|
}
|
|
|
|
res = append(res, tmpl)
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
// EncoderLanguage sets the template language for encoding json
|
|
func EncoderLanguage(lang string) {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
encoderLanguage = lang
|
|
}
|
|
|
|
type filterFunc func([]Template) []Template
|
|
|
|
// WithDeprecated returns a filterFunc that includes all templates
|
|
func WithDeprecated() filterFunc {
|
|
return func(t []Template) []Template {
|
|
return t
|
|
}
|
|
}
|
|
|
|
// ByClass returns templates for class excluding deprecated templates
|
|
func ByClass(class Class, opt ...filterFunc) []Template {
|
|
res := templates[class]
|
|
if len(opt) == 0 {
|
|
opt = append(opt, func(t []Template) []Template {
|
|
return lo.Filter(t, func(t Template, _ int) bool {
|
|
return !t.Deprecated
|
|
})
|
|
})
|
|
}
|
|
for _, o := range opt {
|
|
res = o(res)
|
|
}
|
|
return res
|
|
}
|
|
|
|
// ByClass returns templates for class and name including deprecated templates
|
|
func ByName(class Class, name string) (Template, error) {
|
|
for _, tmpl := range templates[class] {
|
|
if tmpl.Template == name || slices.Contains(tmpl.Covers, name) {
|
|
return tmpl, nil
|
|
}
|
|
}
|
|
|
|
return Template{}, fmt.Errorf("template not found: %s", name)
|
|
}
|