341 lines
7.6 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
}
77
}
78
79
func NewPages() *Pages {
80
templates := make(map[string]*template.Template)
81
82
// Walk through embedded templates directory and parse all .html files
83
err := fs.WalkDir(files, "templates", func(path string, d fs.DirEntry, err error) error {
84
if err != nil {
85
return err
86
}
87
88
if !d.IsDir() && strings.HasSuffix(path, ".html") {
89
name := strings.TrimPrefix(path, "templates/")
90
name = strings.TrimSuffix(name, ".html")
91
92
if !strings.HasPrefix(path, "templates/layouts/") {
93
// Add the page template on top of the base
94
tmpl, err := template.New(name).
95
Funcs(funcMap()).
96
ParseFS(files, "templates/layouts/*.html", path)
97
if err != nil {
98
return fmt.Errorf("setting up template: %w", err)
99
}
100
101
templates[name] = tmpl
102
log.Printf("loaded template: %s", name)
103
}
104
105
return nil
106
}
107
return nil
108
})
109
if err != nil {
110
log.Fatalf("walking template dir: %v", err)
111
}
112
113
log.Printf("total templates loaded: %d", len(templates))
114
115
return &Pages{
116
t: templates,
117
}
118
}
119
120
type LoginParams struct {
121
}
122
123
func (p *Pages) execute(name string, w io.Writer, params any) error {
124
return p.t[name].ExecuteTemplate(w, "layouts/base", params)
125
}
126
127
func (p *Pages) executePlain(name string, w io.Writer, params any) error {
128
return p.t[name].Execute(w, params)
129
}
130
131
func (p *Pages) executeRepo(name string, w io.Writer, params any) error {
132
return p.t[name].ExecuteTemplate(w, "layouts/repobase", params)
133
}
134
135
func (p *Pages) Login(w io.Writer, params LoginParams) error {
136
return p.executePlain("user/login", w, params)
137
}
138
139
type TimelineParams struct {
140
LoggedInUser *auth.User
141
}
142
143
func (p *Pages) Timeline(w io.Writer, params TimelineParams) error {
144
return p.execute("timeline", w, params)
145
}
146
147
type SettingsParams struct {
148
LoggedInUser *auth.User
149
PubKeys []db.PublicKey
150
}
151
152
func (p *Pages) Settings(w io.Writer, params SettingsParams) error {
153
return p.execute("settings/keys", w, params)
154
}
155
156
type KnotsParams struct {
157
LoggedInUser *auth.User
158
Registrations []db.Registration
159
}
160
161
func (p *Pages) Knots(w io.Writer, params KnotsParams) error {
162
return p.execute("knots", w, params)
163
}
164
165
type KnotParams struct {
166
LoggedInUser *auth.User
167
Registration *db.Registration
168
Members []string
169
IsOwner bool
170
}
171
172
func (p *Pages) Knot(w io.Writer, params KnotParams) error {
173
return p.execute("knot", w, params)
174
}
175
176
type NewRepoParams struct {
177
LoggedInUser *auth.User
178
Knots []string
179
}
180
181
func (p *Pages) NewRepo(w io.Writer, params NewRepoParams) error {
182
return p.execute("repo/new", w, params)
183
}
184
185
type ProfilePageParams struct {
186
LoggedInUser *auth.User
187
UserDid string
188
UserHandle string
189
Repos []db.Repo
190
}
191
192
func (p *Pages) ProfilePage(w io.Writer, params ProfilePageParams) error {
193
return p.execute("user/profile", w, params)
194
}
195
196
type RepoInfo struct {
197
Name string
198
OwnerDid string
199
OwnerHandle string
200
Description string
201
SettingsAllowed bool
202
}
203
204
func (r RepoInfo) OwnerWithAt() string {
205
if r.OwnerHandle != "" {
206
return fmt.Sprintf("@%s", r.OwnerHandle)
207
} else {
208
return r.OwnerDid
209
}
210
}
211
212
func (r RepoInfo) FullName() string {
213
return path.Join(r.OwnerWithAt(), r.Name)
214
}
215
216
func (r RepoInfo) GetTabs() [][]string {
217
tabs := [][]string{
218
{"overview", "/"},
219
{"issues", "/issues"},
220
{"pulls", "/pulls"},
221
}
222
223
if r.SettingsAllowed {
224
tabs = append(tabs, []string{"settings", "/settings"})
225
}
226
227
return tabs
228
}
229
230
type RepoIndexParams struct {
231
LoggedInUser *auth.User
232
RepoInfo RepoInfo
233
Active string
234
types.RepoIndexResponse
235
}
236
237
func (p *Pages) RepoIndexPage(w io.Writer, params RepoIndexParams) error {
238
params.Active = "overview"
239
return p.executeRepo("repo/index", w, params)
240
}
241
242
type RepoLogParams struct {
243
LoggedInUser *auth.User
244
RepoInfo RepoInfo
245
types.RepoLogResponse
246
}
247
248
func (p *Pages) RepoLog(w io.Writer, params RepoLogParams) error {
249
return p.execute("repo/log", w, params)
250
}
251
252
type RepoCommitParams struct {
253
LoggedInUser *auth.User
254
RepoInfo RepoInfo
255
types.RepoCommitResponse
256
}
257
258
func (p *Pages) RepoCommit(w io.Writer, params RepoCommitParams) error {
259
return p.executeRepo("repo/commit", w, params)
260
}
261
262
type RepoTreeParams struct {
263
LoggedInUser *auth.User
264
RepoInfo RepoInfo
265
Active string
266
BreadCrumbs [][]string
267
BaseTreeLink string
268
BaseBlobLink string
269
types.RepoTreeResponse
270
}
271
272
func (p *Pages) RepoTree(w io.Writer, params RepoTreeParams) error {
273
params.Active = "overview"
274
return p.execute("repo/tree", w, params)
275
}
276
277
type RepoBranchesParams struct {
278
LoggedInUser *auth.User
279
RepoInfo RepoInfo
280
types.RepoBranchesResponse
281
}
282
283
func (p *Pages) RepoBranches(w io.Writer, params RepoBranchesParams) error {
284
return p.executeRepo("repo/branches", w, params)
285
}
286
287
type RepoTagsParams struct {
288
LoggedInUser *auth.User
289
RepoInfo RepoInfo
290
types.RepoTagsResponse
291
}
292
293
func (p *Pages) RepoTags(w io.Writer, params RepoTagsParams) error {
294
return p.executeRepo("repo/tags", w, params)
295
}
296
297
type RepoBlobParams struct {
298
LoggedInUser *auth.User
299
RepoInfo RepoInfo
300
Active string
301
BreadCrumbs [][]string
302
types.RepoBlobResponse
303
}
304
305
func (p *Pages) RepoBlob(w io.Writer, params RepoBlobParams) error {
306
params.Active = "overview"
307
return p.executeRepo("repo/blob", w, params)
308
}
309
310
type RepoSettingsParams struct {
311
LoggedInUser *auth.User
312
RepoInfo RepoInfo
313
Collaborators [][]string
314
Active string
315
IsCollaboratorInviteAllowed bool
316
}
317
318
func (p *Pages) RepoSettings(w io.Writer, params RepoSettingsParams) error {
319
params.Active = "settings"
320
return p.executeRepo("repo/settings", w, params)
321
}
322
323
func (p *Pages) Static() http.Handler {
324
sub, err := fs.Sub(files, "static")
325
if err != nil {
326
log.Fatalf("no static dir found? that's crazy: %v", err)
327
}
328
return http.StripPrefix("/static/", http.FileServer(http.FS(sub)))
329
}
330
331
func (p *Pages) Error500(w io.Writer) error {
332
return p.execute("errors/500", w, nil)
333
}
334
335
func (p *Pages) Error404(w io.Writer) error {
336
return p.execute("errors/404", w, nil)
337
}
338
339
func (p *Pages) Error503(w io.Writer) error {
340
return p.execute("errors/503", w, nil)
341
}
342