349 lines
7.8 kB
1
package pages
2
3
import (
4
"embed"
5
"fmt"
6
"html/template"
7
"io"
8
"io/fs"
9
"log"
10
"net/http"
11
"path"
12
"strings"
13
14
"github.com/dustin/go-humanize"
15
"github.com/sotangled/tangled/appview/auth"
16
"github.com/sotangled/tangled/appview/db"
17
"github.com/sotangled/tangled/types"
18
)
19
20
//go:embed templates/* static/*
21
var files embed.FS
22
23
type Pages struct {
24
t map[string]*template.Template
25
}
26
27
func funcMap() template.FuncMap {
28
return template.FuncMap{
29
"split": func(s string) []string {
30
return strings.Split(s, "\n")
31
},
32
"add": func(a, b int) int {
33
return a + b
34
},
35
"sub": func(a, b int) int {
36
return a - b
37
},
38
"cond": func(cond interface{}, a, b string) string {
39
if cond == nil {
40
return b
41
}
42
43
if boolean, ok := cond.(bool); boolean && ok {
44
return a
45
}
46
47
return b
48
},
49
"didOrHandle": func(did, handle string) string {
50
if handle != "" {
51
return fmt.Sprintf("@%s", handle)
52
} else {
53
return did
54
}
55
},
56
"assoc": func(values ...string) ([][]string, error) {
57
if len(values)%2 != 0 {
58
return nil, fmt.Errorf("invalid assoc call, must have an even number of arguments")
59
}
60
pairs := make([][]string, 0)
61
for i := 0; i < len(values); i += 2 {
62
pairs = append(pairs, []string{values[i], values[i+1]})
63
}
64
return pairs, nil
65
},
66
"append": func(s []string, values ...string) []string {
67
for _, v := range values {
68
s = append(s, v)
69
}
70
return s
71
},
72
"timeFmt": humanize.Time,
73
"length": func(v []string) int {
74
return len(v)
75
},
76
"splitN": func(s, sep string, n int) []string {
77
return strings.SplitN(s, sep, n)
78
},
79
"unescapeHtml": func(s string) template.HTML {
80
return template.HTML(s)
81
},
82
}
83
}
84
85
func NewPages() *Pages {
86
templates := make(map[string]*template.Template)
87
88
// Walk through embedded templates directory and parse all .html files
89
err := fs.WalkDir(files, "templates", func(path string, d fs.DirEntry, err error) error {
90
if err != nil {
91
return err
92
}
93
94
if !d.IsDir() && strings.HasSuffix(path, ".html") {
95
name := strings.TrimPrefix(path, "templates/")
96
name = strings.TrimSuffix(name, ".html")
97
98
if !strings.HasPrefix(path, "templates/layouts/") {
99
// Add the page template on top of the base
100
tmpl, err := template.New(name).
101
Funcs(funcMap()).
102
ParseFS(files, "templates/layouts/*.html", path)
103
if err != nil {
104
return fmt.Errorf("setting up template: %w", err)
105
}
106
107
templates[name] = tmpl
108
log.Printf("loaded template: %s", name)
109
}
110
111
return nil
112
}
113
return nil
114
})
115
if err != nil {
116
log.Fatalf("walking template dir: %v", err)
117
}
118
119
log.Printf("total templates loaded: %d", len(templates))
120
121
return &Pages{
122
t: templates,
123
}
124
}
125
126
type LoginParams struct {
127
}
128
129
func (p *Pages) execute(name string, w io.Writer, params any) error {
130
return p.t[name].ExecuteTemplate(w, "layouts/base", params)
131
}
132
133
func (p *Pages) executePlain(name string, w io.Writer, params any) error {
134
return p.t[name].Execute(w, params)
135
}
136
137
func (p *Pages) executeRepo(name string, w io.Writer, params any) error {
138
return p.t[name].ExecuteTemplate(w, "layouts/repobase", params)
139
}
140
141
func (p *Pages) Login(w io.Writer, params LoginParams) error {
142
return p.executePlain("user/login", w, params)
143
}
144
145
type TimelineParams struct {
146
LoggedInUser *auth.User
147
}
148
149
func (p *Pages) Timeline(w io.Writer, params TimelineParams) error {
150
return p.execute("timeline", w, params)
151
}
152
153
type SettingsParams struct {
154
LoggedInUser *auth.User
155
PubKeys []db.PublicKey
156
}
157
158
func (p *Pages) Settings(w io.Writer, params SettingsParams) error {
159
return p.execute("settings/keys", w, params)
160
}
161
162
type KnotsParams struct {
163
LoggedInUser *auth.User
164
Registrations []db.Registration
165
}
166
167
func (p *Pages) Knots(w io.Writer, params KnotsParams) error {
168
return p.execute("knots", w, params)
169
}
170
171
type KnotParams struct {
172
LoggedInUser *auth.User
173
Registration *db.Registration
174
Members []string
175
IsOwner bool
176
}
177
178
func (p *Pages) Knot(w io.Writer, params KnotParams) error {
179
return p.execute("knot", w, params)
180
}
181
182
type NewRepoParams struct {
183
LoggedInUser *auth.User
184
Knots []string
185
}
186
187
func (p *Pages) NewRepo(w io.Writer, params NewRepoParams) error {
188
return p.execute("repo/new", w, params)
189
}
190
191
type ProfilePageParams struct {
192
LoggedInUser *auth.User
193
UserDid string
194
UserHandle string
195
Repos []db.Repo
196
}
197
198
func (p *Pages) ProfilePage(w io.Writer, params ProfilePageParams) error {
199
return p.execute("user/profile", w, params)
200
}
201
202
type RepoInfo struct {
203
Name string
204
OwnerDid string
205
OwnerHandle string
206
Description string
207
SettingsAllowed bool
208
}
209
210
func (r RepoInfo) OwnerWithAt() string {
211
if r.OwnerHandle != "" {
212
return fmt.Sprintf("@%s", r.OwnerHandle)
213
} else {
214
return r.OwnerDid
215
}
216
}
217
218
func (r RepoInfo) FullName() string {
219
return path.Join(r.OwnerWithAt(), r.Name)
220
}
221
222
func (r RepoInfo) GetTabs() [][]string {
223
tabs := [][]string{
224
{"overview", "/"},
225
{"issues", "/issues"},
226
{"pulls", "/pulls"},
227
}
228
229
if r.SettingsAllowed {
230
tabs = append(tabs, []string{"settings", "/settings"})
231
}
232
233
return tabs
234
}
235
236
type RepoIndexParams struct {
237
LoggedInUser *auth.User
238
RepoInfo RepoInfo
239
Active string
240
Branches []types.Branch
241
Tags []*types.TagReference
242
types.RepoIndexResponse
243
}
244
245
func (p *Pages) RepoIndexPage(w io.Writer, params RepoIndexParams) error {
246
params.Active = "overview"
247
return p.executeRepo("repo/index", w, params)
248
}
249
250
type RepoLogParams struct {
251
LoggedInUser *auth.User
252
RepoInfo RepoInfo
253
types.RepoLogResponse
254
}
255
256
func (p *Pages) RepoLog(w io.Writer, params RepoLogParams) error {
257
return p.execute("repo/log", w, params)
258
}
259
260
type RepoCommitParams struct {
261
LoggedInUser *auth.User
262
RepoInfo RepoInfo
263
types.RepoCommitResponse
264
}
265
266
func (p *Pages) RepoCommit(w io.Writer, params RepoCommitParams) error {
267
return p.executeRepo("repo/commit", w, params)
268
}
269
270
type RepoTreeParams struct {
271
LoggedInUser *auth.User
272
RepoInfo RepoInfo
273
Active string
274
BreadCrumbs [][]string
275
BaseTreeLink string
276
BaseBlobLink string
277
types.RepoTreeResponse
278
}
279
280
func (p *Pages) RepoTree(w io.Writer, params RepoTreeParams) error {
281
params.Active = "overview"
282
return p.execute("repo/tree", w, params)
283
}
284
285
type RepoBranchesParams struct {
286
LoggedInUser *auth.User
287
RepoInfo RepoInfo
288
types.RepoBranchesResponse
289
}
290
291
func (p *Pages) RepoBranches(w io.Writer, params RepoBranchesParams) error {
292
return p.executeRepo("repo/branches", w, params)
293
}
294
295
type RepoTagsParams struct {
296
LoggedInUser *auth.User
297
RepoInfo RepoInfo
298
types.RepoTagsResponse
299
}
300
301
func (p *Pages) RepoTags(w io.Writer, params RepoTagsParams) error {
302
return p.executeRepo("repo/tags", w, params)
303
}
304
305
type RepoBlobParams struct {
306
LoggedInUser *auth.User
307
RepoInfo RepoInfo
308
Active string
309
BreadCrumbs [][]string
310
types.RepoBlobResponse
311
}
312
313
func (p *Pages) RepoBlob(w io.Writer, params RepoBlobParams) error {
314
params.Active = "overview"
315
return p.executeRepo("repo/blob", w, params)
316
}
317
318
type RepoSettingsParams struct {
319
LoggedInUser *auth.User
320
RepoInfo RepoInfo
321
Collaborators [][]string
322
Active string
323
IsCollaboratorInviteAllowed bool
324
}
325
326
func (p *Pages) RepoSettings(w io.Writer, params RepoSettingsParams) error {
327
params.Active = "settings"
328
return p.executeRepo("repo/settings", w, params)
329
}
330
331
func (p *Pages) Static() http.Handler {
332
sub, err := fs.Sub(files, "static")
333
if err != nil {
334
log.Fatalf("no static dir found? that's crazy: %v", err)
335
}
336
return http.StripPrefix("/static/", http.FileServer(http.FS(sub)))
337
}
338
339
func (p *Pages) Error500(w io.Writer) error {
340
return p.execute("errors/500", w, nil)
341
}
342
343
func (p *Pages) Error404(w io.Writer) error {
344
return p.execute("errors/404", w, nil)
345
}
346
347
func (p *Pages) Error503(w io.Writer) error {
348
return p.execute("errors/503", w, nil)
349
}
350