this repo has no description
tangled.org
1package pages
2
3import (
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/*
21var files embed.FS
22
23type Pages struct {
24 t map[string]*template.Template
25}
26
27func 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
85func 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
126type LoginParams struct {
127}
128
129func (p *Pages) execute(name string, w io.Writer, params any) error {
130 return p.t[name].ExecuteTemplate(w, "layouts/base", params)
131}
132
133func (p *Pages) executePlain(name string, w io.Writer, params any) error {
134 return p.t[name].Execute(w, params)
135}
136
137func (p *Pages) executeRepo(name string, w io.Writer, params any) error {
138 return p.t[name].ExecuteTemplate(w, "layouts/repobase", params)
139}
140
141func (p *Pages) Login(w io.Writer, params LoginParams) error {
142 return p.executePlain("user/login", w, params)
143}
144
145type TimelineParams struct {
146 LoggedInUser *auth.User
147}
148
149func (p *Pages) Timeline(w io.Writer, params TimelineParams) error {
150 return p.execute("timeline", w, params)
151}
152
153type SettingsParams struct {
154 LoggedInUser *auth.User
155 PubKeys []db.PublicKey
156}
157
158func (p *Pages) Settings(w io.Writer, params SettingsParams) error {
159 return p.execute("settings/keys", w, params)
160}
161
162type KnotsParams struct {
163 LoggedInUser *auth.User
164 Registrations []db.Registration
165}
166
167func (p *Pages) Knots(w io.Writer, params KnotsParams) error {
168 return p.execute("knots", w, params)
169}
170
171type KnotParams struct {
172 LoggedInUser *auth.User
173 Registration *db.Registration
174 Members []string
175 IsOwner bool
176}
177
178func (p *Pages) Knot(w io.Writer, params KnotParams) error {
179 return p.execute("knot", w, params)
180}
181
182type NewRepoParams struct {
183 LoggedInUser *auth.User
184 Knots []string
185}
186
187func (p *Pages) NewRepo(w io.Writer, params NewRepoParams) error {
188 return p.execute("repo/new", w, params)
189}
190
191type ProfilePageParams struct {
192 LoggedInUser *auth.User
193 UserDid string
194 UserHandle string
195 Repos []db.Repo
196}
197
198func (p *Pages) ProfilePage(w io.Writer, params ProfilePageParams) error {
199 return p.execute("user/profile", w, params)
200}
201
202type RepoInfo struct {
203 Name string
204 OwnerDid string
205 OwnerHandle string
206 Description string
207 SettingsAllowed bool
208}
209
210func (r RepoInfo) OwnerWithAt() string {
211 if r.OwnerHandle != "" {
212 return fmt.Sprintf("@%s", r.OwnerHandle)
213 } else {
214 return r.OwnerDid
215 }
216}
217
218func (r RepoInfo) FullName() string {
219 return path.Join(r.OwnerWithAt(), r.Name)
220}
221
222func (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
236type RepoIndexParams struct {
237 LoggedInUser *auth.User
238 RepoInfo RepoInfo
239 Active string
240 types.RepoIndexResponse
241}
242
243func (p *Pages) RepoIndexPage(w io.Writer, params RepoIndexParams) error {
244 params.Active = "overview"
245 return p.executeRepo("repo/index", w, params)
246}
247
248type RepoLogParams struct {
249 LoggedInUser *auth.User
250 RepoInfo RepoInfo
251 types.RepoLogResponse
252}
253
254func (p *Pages) RepoLog(w io.Writer, params RepoLogParams) error {
255 return p.execute("repo/log", w, params)
256}
257
258type RepoCommitParams struct {
259 LoggedInUser *auth.User
260 RepoInfo RepoInfo
261 types.RepoCommitResponse
262}
263
264func (p *Pages) RepoCommit(w io.Writer, params RepoCommitParams) error {
265 return p.executeRepo("repo/commit", w, params)
266}
267
268type RepoTreeParams struct {
269 LoggedInUser *auth.User
270 RepoInfo RepoInfo
271 Active string
272 BreadCrumbs [][]string
273 BaseTreeLink string
274 BaseBlobLink string
275 types.RepoTreeResponse
276}
277
278func (p *Pages) RepoTree(w io.Writer, params RepoTreeParams) error {
279 params.Active = "overview"
280 return p.execute("repo/tree", w, params)
281}
282
283type RepoBranchesParams struct {
284 LoggedInUser *auth.User
285 RepoInfo RepoInfo
286 types.RepoBranchesResponse
287}
288
289func (p *Pages) RepoBranches(w io.Writer, params RepoBranchesParams) error {
290 return p.executeRepo("repo/branches", w, params)
291}
292
293type RepoTagsParams struct {
294 LoggedInUser *auth.User
295 RepoInfo RepoInfo
296 types.RepoTagsResponse
297}
298
299func (p *Pages) RepoTags(w io.Writer, params RepoTagsParams) error {
300 return p.executeRepo("repo/tags", w, params)
301}
302
303type RepoBlobParams struct {
304 LoggedInUser *auth.User
305 RepoInfo RepoInfo
306 Active string
307 BreadCrumbs [][]string
308 types.RepoBlobResponse
309}
310
311func (p *Pages) RepoBlob(w io.Writer, params RepoBlobParams) error {
312 params.Active = "overview"
313 return p.executeRepo("repo/blob", w, params)
314}
315
316type RepoSettingsParams struct {
317 LoggedInUser *auth.User
318 RepoInfo RepoInfo
319 Collaborators [][]string
320 Active string
321 IsCollaboratorInviteAllowed bool
322}
323
324func (p *Pages) RepoSettings(w io.Writer, params RepoSettingsParams) error {
325 params.Active = "settings"
326 return p.executeRepo("repo/settings", w, params)
327}
328
329func (p *Pages) Static() http.Handler {
330 sub, err := fs.Sub(files, "static")
331 if err != nil {
332 log.Fatalf("no static dir found? that's crazy: %v", err)
333 }
334 return http.StripPrefix("/static/", http.FileServer(http.FS(sub)))
335}
336
337func (p *Pages) Error500(w io.Writer) error {
338 return p.execute("errors/500", w, nil)
339}
340
341func (p *Pages) Error404(w io.Writer) error {
342 return p.execute("errors/404", w, nil)
343}
344
345func (p *Pages) Error503(w io.Writer) error {
346 return p.execute("errors/503", w, nil)
347}