1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
// Copyright 2017 Frédéric Guillot. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package template
import (
"bytes"
"html/template"
"io"
"log"
"net/url"
"strings"
"time"
"github.com/miniflux/miniflux2/errors"
"github.com/miniflux/miniflux2/locale"
"github.com/miniflux/miniflux2/server/route"
"github.com/miniflux/miniflux2/server/template/helper"
"github.com/miniflux/miniflux2/server/ui/filter"
"github.com/gorilla/mux"
)
type TemplateEngine struct {
templates map[string]*template.Template
router *mux.Router
translator *locale.Translator
currentLocale *locale.Language
}
func (t *TemplateEngine) ParseAll() {
funcMap := template.FuncMap{
"route": func(name string, args ...interface{}) string {
return route.GetRoute(t.router, name, args...)
},
"noescape": func(str string) template.HTML {
return template.HTML(str)
},
"proxyFilter": func(data string) string {
return filter.ImageProxyFilter(t.router, data)
},
"domain": func(websiteURL string) string {
parsedURL, err := url.Parse(websiteURL)
if err != nil {
return websiteURL
}
return parsedURL.Host
},
"hasPrefix": func(str, prefix string) bool {
return strings.HasPrefix(str, prefix)
},
"contains": func(str, substr string) bool {
return strings.Contains(str, substr)
},
"isodate": func(ts time.Time) string {
return ts.Format("2006-01-02 15:04:05")
},
"elapsed": func(ts time.Time) string {
return helper.GetElapsedTime(t.currentLocale, ts)
},
"t": func(key interface{}, args ...interface{}) string {
switch key.(type) {
case string:
return t.currentLocale.Get(key.(string), args...)
case errors.LocalizedError:
err := key.(errors.LocalizedError)
return err.Localize(t.currentLocale)
case error:
return key.(error).Error()
default:
return ""
}
},
"plural": func(key string, n int, args ...interface{}) string {
return t.currentLocale.Plural(key, n, args...)
},
}
commonTemplates := ""
for _, content := range templateCommonMap {
commonTemplates += content
}
for name, content := range templateViewsMap {
log.Println("Parsing template:", name)
t.templates[name] = template.Must(template.New("main").Funcs(funcMap).Parse(commonTemplates + content))
}
}
func (t *TemplateEngine) SetLanguage(language string) {
t.currentLocale = t.translator.GetLanguage(language)
}
func (t *TemplateEngine) Execute(w io.Writer, name string, data interface{}) {
tpl, ok := t.templates[name]
if !ok {
log.Fatalf("The template %s does not exists.\n", name)
}
var b bytes.Buffer
err := tpl.ExecuteTemplate(&b, "base", data)
if err != nil {
log.Fatalf("Unable to render template: %v\n", err)
}
b.WriteTo(w)
}
func NewTemplateEngine(router *mux.Router, translator *locale.Translator) *TemplateEngine {
tpl := &TemplateEngine{
templates: make(map[string]*template.Template),
router: router,
translator: translator,
}
tpl.ParseAll()
return tpl
}
|
