appview/pages: include LoggedInUser on error pages #845

···

       
83
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
84
       
 
       
	if !ok {

     

       
85
       
 
       
		l.Error("failed to get issue")

     

       
86
       
-
       
		rp.pages.Error404(w)

     

       
87
       
 
       
		return

     

       
88
       
 
       
	}

     

       
89
       
 
       


     
···

       
104
       
 
       
	)

     

       
105
       
 
       
	if err != nil {

     

       
106
       
 
       
		l.Error("failed to fetch labels", "err", err)

     

       
107
       
-
       
		rp.pages.Error503(w)

     

       
108
       
 
       
		return

     

       
109
       
 
       
	}

     

       
110
       
 
       


     
···

       
137
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
138
       
 
       
	if !ok {

     

       
139
       
 
       
		l.Error("failed to get issue")

     

       
140
       
-
       
		rp.pages.Error404(w)

     

       
141
       
 
       
		return

     

       
142
       
 
       
	}

     

       
143
       
 
       


     
···

       
282
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
283
       
 
       
	if !ok {

     

       
284
       
 
       
		l.Error("failed to get issue")

     

       
285
       
-
       
		rp.pages.Error404(w)

     

       
286
       
 
       
		return

     

       
287
       
 
       
	}

     

       
288
       
 
       


     
···

       
333
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
334
       
 
       
	if !ok {

     

       
335
       
 
       
		l.Error("failed to get issue")

     

       
336
       
-
       
		rp.pages.Error404(w)

     

       
337
       
 
       
		return

     

       
338
       
 
       
	}

     

       
339
       
 
       


     
···

       
383
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
384
       
 
       
	if !ok {

     

       
385
       
 
       
		l.Error("failed to get issue")

     

       
386
       
-
       
		rp.pages.Error404(w)

     

       
387
       
 
       
		return

     

       
388
       
 
       
	}

     

       
389
       
 
       


     
···

       
481
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
482
       
 
       
	if !ok {

     

       
483
       
 
       
		l.Error("failed to get issue")

     

       
484
       
-
       
		rp.pages.Error404(w)

     

       
485
       
 
       
		return

     

       
486
       
 
       
	}

     

       
487
       
 
       


     
···

       
522
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
523
       
 
       
	if !ok {

     

       
524
       
 
       
		l.Error("failed to get issue")

     

       
525
       
-
       
		rp.pages.Error404(w)

     

       
526
       
 
       
		return

     

       
527
       
 
       
	}

     

       
528
       
 
       


     
···

       
626
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
627
       
 
       
	if !ok {

     

       
628
       
 
       
		l.Error("failed to get issue")

     

       
629
       
-
       
		rp.pages.Error404(w)

     

       
630
       
 
       
		return

     

       
631
       
 
       
	}

     

       
632
       
 
       


     
···

       
667
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
668
       
 
       
	if !ok {

     

       
669
       
 
       
		l.Error("failed to get issue")

     

       
670
       
-
       
		rp.pages.Error404(w)

     

       
671
       
 
       
		return

     

       
672
       
 
       
	}

     

       
673
       
 
       


     
···

       
708
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
709
       
 
       
	if !ok {

     

       
710
       
 
       
		l.Error("failed to get issue")

     

       
711
       
-
       
		rp.pages.Error404(w)

     

       
712
       
 
       
		return

     

       
713
       
 
       
	}

     

       
714
       
 
       


     
···

       
864
       
 
       
	)

     

       
865
       
 
       
	if err != nil {

     

       
866
       
 
       
		l.Error("failed to fetch labels", "err", err)

     

       
867
       
-
       
		rp.pages.Error503(w)

     

       
868
       
 
       
		return

     

       
869
       
 
       
	}

     

       
870
       
 
       


     

···

       
83
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
84
       
 
       
	if !ok {

     

       
85
       
 
       
		l.Error("failed to get issue")

     

       
86
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
87
       
 
       
		return

     

       
88
       
 
       
	}

     

       
89
       
 
       


     
···

       
104
       
 
       
	)

     

       
105
       
 
       
	if err != nil {

     

       
106
       
 
       
		l.Error("failed to fetch labels", "err", err)

     

       
107
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
108
       
 
       
		return

     

       
109
       
 
       
	}

     

       
110
       
 
       


     
···

       
137
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
138
       
 
       
	if !ok {

     

       
139
       
 
       
		l.Error("failed to get issue")

     

       
140
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
141
       
 
       
		return

     

       
142
       
 
       
	}

     

       
143
       
 
       


     
···

       
282
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
283
       
 
       
	if !ok {

     

       
284
       
 
       
		l.Error("failed to get issue")

     

       
285
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
286
       
 
       
		return

     

       
287
       
 
       
	}

     

       
288
       
 
       


     
···

       
333
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
334
       
 
       
	if !ok {

     

       
335
       
 
       
		l.Error("failed to get issue")

     

       
336
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
337
       
 
       
		return

     

       
338
       
 
       
	}

     

       
339
       
 
       


     
···

       
383
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
384
       
 
       
	if !ok {

     

       
385
       
 
       
		l.Error("failed to get issue")

     

       
386
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
387
       
 
       
		return

     

       
388
       
 
       
	}

     

       
389
       
 
       


     
···

       
481
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
482
       
 
       
	if !ok {

     

       
483
       
 
       
		l.Error("failed to get issue")

     

       
484
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
485
       
 
       
		return

     

       
486
       
 
       
	}

     

       
487
       
 
       


     
···

       
522
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
523
       
 
       
	if !ok {

     

       
524
       
 
       
		l.Error("failed to get issue")

     

       
525
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
526
       
 
       
		return

     

       
527
       
 
       
	}

     

       
528
       
 
       


     
···

       
626
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
627
       
 
       
	if !ok {

     

       
628
       
 
       
		l.Error("failed to get issue")

     

       
629
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
630
       
 
       
		return

     

       
631
       
 
       
	}

     

       
632
       
 
       


     
···

       
667
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
668
       
 
       
	if !ok {

     

       
669
       
 
       
		l.Error("failed to get issue")

     

       
670
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
671
       
 
       
		return

     

       
672
       
 
       
	}

     

       
673
       
 
       


     
···

       
708
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
709
       
 
       
	if !ok {

     

       
710
       
 
       
		l.Error("failed to get issue")

     

       
711
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
712
       
 
       
		return

     

       
713
       
 
       
	}

     

       
714
       
 
       


     
···

       
864
       
 
       
	)

     

       
865
       
 
       
	if err != nil {

     

       
866
       
 
       
		l.Error("failed to fetch labels", "err", err)

     

       
867
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
868
       
 
       
		return

     

       
869
       
 
       
	}

     

       
870
       
 
       


     

···

       
191
       
 
       
			if err != nil {

     

       
192
       
 
       
				// invalid did or handle

     

       
193
       
 
       
				log.Printf("failed to resolve did/handle '%s': %s\n", didOrHandle, err)

     

       
194
       
-
       
				mw.pages.Error404(w)

     

       
195
       
 
       
				return

     

       
196
       
 
       
			}

     

       
197
       
 
       


     
···

       
222
       
 
       
			)

     

       
223
       
 
       
			if err != nil {

     

       
224
       
 
       
				log.Println("failed to resolve repo", "err", err)

     

       
225
       
-
       
				mw.pages.ErrorKnot404(w)

     

       
226
       
 
       
				return

     

       
227
       
 
       
			}

     

       
228
       
 
       


     
···

       
239
       
 
       
			f, err := mw.repoResolver.Resolve(r)

     

       
240
       
 
       
			if err != nil {

     

       
241
       
 
       
				log.Println("failed to fully resolve repo", err)

     

       
242
       
-
       
				mw.pages.ErrorKnot404(w)

     

       
243
       
 
       
				return

     

       
244
       
 
       
			}

     

       
245
       
 
       


     
···

       
247
       
 
       
			prIdInt, err := strconv.Atoi(prId)

     

       
248
       
 
       
			if err != nil {

     

       
249
       
 
       
				log.Println("failed to parse pr id", err)

     

       
250
       
-
       
				mw.pages.Error404(w)

     

       
251
       
 
       
				return

     

       
252
       
 
       
			}

     

       
253
       
 
       


     

       
254
       
 
       
			pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt)

     

       
255
       
 
       
			if err != nil {

     

       
256
       
 
       
				log.Println("failed to get pull and comments", err)

     

       
257
       
-
       
				mw.pages.Error404(w)

     

       
258
       
 
       
				return

     

       
259
       
 
       
			}

     

       
260
       
 
       


     
···

       
287
       
 
       
		f, err := mw.repoResolver.Resolve(r)

     

       
288
       
 
       
		if err != nil {

     

       
289
       
 
       
			log.Println("failed to fully resolve repo", err)

     

       
290
       
-
       
			mw.pages.ErrorKnot404(w)

     

       
291
       
 
       
			return

     

       
292
       
 
       
		}

     

       
293
       
 
       


     
···

       
295
       
 
       
		issueId, err := strconv.Atoi(issueIdStr)

     

       
296
       
 
       
		if err != nil {

     

       
297
       
 
       
			log.Println("failed to fully resolve issue ID", err)

     

       
298
       
-
       
			mw.pages.Error404(w)

     

       
299
       
 
       
			return

     

       
300
       
 
       
		}

     

       
301
       
 
       


     

       
302
       
 
       
		issue, err := db.GetIssue(mw.db, f.RepoAt(), issueId)

     

       
303
       
 
       
		if err != nil {

     

       
304
       
 
       
			log.Println("failed to get issues", "err", err)

     

       
305
       
-
       
			mw.pages.Error404(w)

     

       
306
       
 
       
			return

     

       
307
       
 
       
		}

     

       
308
       
 
       


     
···

       
323
       
 
       
			f, err := mw.repoResolver.Resolve(r)

     

       
324
       
 
       
			if err != nil {

     

       
325
       
 
       
				log.Println("failed to fully resolve repo", err)

     

       
326
       
-
       
				mw.pages.ErrorKnot404(w)

     

       
327
       
 
       
				return

     

       
328
       
 
       
			}

     

       
329
       
 
       


     

···

       
191
       
 
       
			if err != nil {

     

       
192
       
 
       
				// invalid did or handle

     

       
193
       
 
       
				log.Printf("failed to resolve did/handle '%s': %s\n", didOrHandle, err)

     

       
194
       
+
       
				mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(req)})

     

       
195
       
 
       
				return

     

       
196
       
 
       
			}

     

       
197
       
 
       


     
···

       
222
       
 
       
			)

     

       
223
       
 
       
			if err != nil {

     

       
224
       
 
       
				log.Println("failed to resolve repo", "err", err)

     

       
225
       
+
       
				mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(req)})

     

       
226
       
 
       
				return

     

       
227
       
 
       
			}

     

       
228
       
 
       


     
···

       
239
       
 
       
			f, err := mw.repoResolver.Resolve(r)

     

       
240
       
 
       
			if err != nil {

     

       
241
       
 
       
				log.Println("failed to fully resolve repo", err)

     

       
242
       
+
       
				mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})

     

       
243
       
 
       
				return

     

       
244
       
 
       
			}

     

       
245
       
 
       


     
···

       
247
       
 
       
			prIdInt, err := strconv.Atoi(prId)

     

       
248
       
 
       
			if err != nil {

     

       
249
       
 
       
				log.Println("failed to parse pr id", err)

     

       
250
       
+
       
				mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})

     

       
251
       
 
       
				return

     

       
252
       
 
       
			}

     

       
253
       
 
       


     

       
254
       
 
       
			pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt)

     

       
255
       
 
       
			if err != nil {

     

       
256
       
 
       
				log.Println("failed to get pull and comments", err)

     

       
257
       
+
       
				mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})

     

       
258
       
 
       
				return

     

       
259
       
 
       
			}

     

       
260
       
 
       


     
···

       
287
       
 
       
		f, err := mw.repoResolver.Resolve(r)

     

       
288
       
 
       
		if err != nil {

     

       
289
       
 
       
			log.Println("failed to fully resolve repo", err)

     

       
290
       
+
       
			mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})

     

       
291
       
 
       
			return

     

       
292
       
 
       
		}

     

       
293
       
 
       


     
···

       
295
       
 
       
		issueId, err := strconv.Atoi(issueIdStr)

     

       
296
       
 
       
		if err != nil {

     

       
297
       
 
       
			log.Println("failed to fully resolve issue ID", err)

     

       
298
       
+
       
			mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})

     

       
299
       
 
       
			return

     

       
300
       
 
       
		}

     

       
301
       
 
       


     

       
302
       
 
       
		issue, err := db.GetIssue(mw.db, f.RepoAt(), issueId)

     

       
303
       
 
       
		if err != nil {

     

       
304
       
 
       
			log.Println("failed to get issues", "err", err)

     

       
305
       
+
       
			mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})

     

       
306
       
 
       
			return

     

       
307
       
 
       
		}

     

       
308
       
 
       


     
···

       
323
       
 
       
			f, err := mw.repoResolver.Resolve(r)

     

       
324
       
 
       
			if err != nil {

     

       
325
       
 
       
				log.Println("failed to fully resolve repo", err)

     

       
326
       
+
       
				mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})

     

       
327
       
 
       
				return

     

       
328
       
 
       
			}

     

       
329
       
 
       


     

···

       
57
       
 
       
	)

     

       
58
       
 
       
	if err != nil {

     

       
59
       
 
       
		l.Error("failed to get total notifications", "err", err)

     

       
60
       
-
       
		n.pages.Error500(w)

     

       
61
       
 
       
		return

     

       
62
       
 
       
	}

     

       
63
       
 
       


     
···

       
68
       
 
       
	)

     

       
69
       
 
       
	if err != nil {

     

       
70
       
 
       
		l.Error("failed to get notifications", "err", err)

     

       
71
       
-
       
		n.pages.Error500(w)

     

       
72
       
 
       
		return

     

       
73
       
 
       
	}

     

       
74
       
 
       


     

···

       
57
       
 
       
	)

     

       
58
       
 
       
	if err != nil {

     

       
59
       
 
       
		l.Error("failed to get total notifications", "err", err)

     

       
60
       
+
       
		n.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
61
       
 
       
		return

     

       
62
       
 
       
	}

     

       
63
       
 
       


     
···

       
68
       
 
       
	)

     

       
69
       
 
       
	if err != nil {

     

       
70
       
 
       
		l.Error("failed to get notifications", "err", err)

     

       
71
       
+
       
		n.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
72
       
 
       
		return

     

       
73
       
 
       
	}

     

       
74
       
 
       


     

···

       
1437
       
 
       
	return hex.EncodeToString(hasher.Sum(nil))[:8] // Use first 8 chars of hash

     

       
1438
       
 
       
}

     

       
1439
       
 
       


     

       
1440
       
-
       
func (p *Pages) Error500(w io.Writer) error {

     

       
1441
       
-
       
	return p.execute("errors/500", w, nil)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1442
       
 
       
}

     

       
1443
       
 
       


     

       
1444
       
-
       
func (p *Pages) Error404(w io.Writer) error {

     

       
1445
       
-
       
	return p.execute("errors/404", w, nil)

     

       
1446
       
 
       
}

     

       
1447
       
 
       


     

       
1448
       
-
       
func (p *Pages) ErrorKnot404(w io.Writer) error {

     

       
1449
       
-
       
	return p.execute("errors/knot404", w, nil)

     

       
1450
       
 
       
}

     

       
1451
       
 
       


     

       
1452
       
-
       
func (p *Pages) Error503(w io.Writer) error {

     

       
1453
       
-
       
	return p.execute("errors/503", w, nil)

     

       
1454
       
 
       
}

     

···

       
1437
       
 
       
	return hex.EncodeToString(hasher.Sum(nil))[:8] // Use first 8 chars of hash

     

       
1438
       
 
       
}

     

       
1439
       
 
       


     

       
1440
       
+
       
type ErrorPageParams struct {

     

       
1441
       
+
       
	LoggedInUser *oauth.User

     

       
1442
       
+
       
}

     

       
1443
       
+
       


     

       
1444
       
+
       
func (p *Pages) Error500(w io.Writer, params ErrorPageParams) error {

     

       
1445
       
+
       
	return p.execute("errors/500", w, params)

     

       
1446
       
 
       
}

     

       
1447
       
 
       


     

       
1448
       
+
       
func (p *Pages) Error404(w io.Writer, params ErrorPageParams) error {

     

       
1449
       
+
       
	return p.execute("errors/404", w, params)

     

       
1450
       
 
       
}

     

       
1451
       
 
       


     

       
1452
       
+
       
func (p *Pages) ErrorKnot404(w io.Writer, params ErrorPageParams) error {

     

       
1453
       
+
       
	return p.execute("errors/knot404", w, params)

     

       
1454
       
 
       
}

     

       
1455
       
 
       


     

       
1456
       
+
       
func (p *Pages) Error503(w io.Writer, params ErrorPageParams) error {

     

       
1457
       
+
       
	return p.execute("errors/503", w, params)

     

       
1458
       
 
       
}

     

···

       
211
       
 
       
	)

     

       
212
       
 
       
	if err != nil {

     

       
213
       
 
       
		log.Println("failed to fetch labels", err)

     

       
214
       
-
       
		s.pages.Error503(w)

     

       
215
       
 
       
		return

     

       
216
       
 
       
	}

     

       
217
       
 
       


     
···

       
671
       
 
       
	)

     

       
672
       
 
       
	if err != nil {

     

       
673
       
 
       
		log.Println("failed to fetch labels", err)

     

       
674
       
-
       
		s.pages.Error503(w)

     

       
675
       
 
       
		return

     

       
676
       
 
       
	}

     

       
677
       
 
       


     
···

       
831
       
 
       
		if err != nil {

     

       
832
       
 
       
			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
833
       
 
       
				log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       
834
       
-
       
				s.pages.Error503(w)

     

       
835
       
 
       
				return

     

       
836
       
 
       
			}

     

       
837
       
 
       
			log.Println("failed to fetch branches", err)

     
···

       
841
       
 
       
		var result types.RepoBranchesResponse

     

       
842
       
 
       
		if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
843
       
 
       
			log.Println("failed to decode XRPC response", err)

     

       
844
       
-
       
			s.pages.Error503(w)

     

       
845
       
 
       
			return

     

       
846
       
 
       
		}

     

       
847
       
 
       


     
···

       
1438
       
 
       
	if err != nil {

     

       
1439
       
 
       
		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
1440
       
 
       
			log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       
1441
       
-
       
			s.pages.Error503(w)

     

       
1442
       
 
       
			return

     

       
1443
       
 
       
		}

     

       
1444
       
 
       
		log.Println("failed to fetch branches", err)

     
···

       
1448
       
 
       
	var result types.RepoBranchesResponse

     

       
1449
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
1450
       
 
       
		log.Println("failed to decode XRPC response", err)

     

       
1451
       
-
       
		s.pages.Error503(w)

     

       
1452
       
 
       
		return

     

       
1453
       
 
       
	}

     

       
1454
       
 
       


     
···

       
1530
       
 
       
	if err != nil {

     

       
1531
       
 
       
		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
1532
       
 
       
			log.Println("failed to call XRPC repo.branches for source", xrpcerr)

     

       
1533
       
-
       
			s.pages.Error503(w)

     

       
1534
       
 
       
			return

     

       
1535
       
 
       
		}

     

       
1536
       
 
       
		log.Println("failed to fetch source branches", err)

     
···

       
1541
       
 
       
	var sourceBranches types.RepoBranchesResponse

     

       
1542
       
 
       
	if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {

     

       
1543
       
 
       
		log.Println("failed to decode source branches XRPC response", err)

     

       
1544
       
-
       
		s.pages.Error503(w)

     

       
1545
       
 
       
		return

     

       
1546
       
 
       
	}

     

       
1547
       
 
       


     
···

       
1559
       
 
       
	if err != nil {

     

       
1560
       
 
       
		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
1561
       
 
       
			log.Println("failed to call XRPC repo.branches for target", xrpcerr)

     

       
1562
       
-
       
			s.pages.Error503(w)

     

       
1563
       
 
       
			return

     

       
1564
       
 
       
		}

     

       
1565
       
 
       
		log.Println("failed to fetch target branches", err)

     
···

       
1570
       
 
       
	var targetBranches types.RepoBranchesResponse

     

       
1571
       
 
       
	if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {

     

       
1572
       
 
       
		log.Println("failed to decode target branches XRPC response", err)

     

       
1573
       
-
       
		s.pages.Error503(w)

     

       
1574
       
 
       
		return

     

       
1575
       
 
       
	}

     

       
1576
       
 
       


     

···

       
211
       
 
       
	)

     

       
212
       
 
       
	if err != nil {

     

       
213
       
 
       
		log.Println("failed to fetch labels", err)

     

       
214
       
+
       
		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
215
       
 
       
		return

     

       
216
       
 
       
	}

     

       
217
       
 
       


     
···

       
671
       
 
       
	)

     

       
672
       
 
       
	if err != nil {

     

       
673
       
 
       
		log.Println("failed to fetch labels", err)

     

       
674
       
+
       
		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
675
       
 
       
		return

     

       
676
       
 
       
	}

     

       
677
       
 
       


     
···

       
831
       
 
       
		if err != nil {

     

       
832
       
 
       
			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
833
       
 
       
				log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       
834
       
+
       
				s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
835
       
 
       
				return

     

       
836
       
 
       
			}

     

       
837
       
 
       
			log.Println("failed to fetch branches", err)

     
···

       
841
       
 
       
		var result types.RepoBranchesResponse

     

       
842
       
 
       
		if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
843
       
 
       
			log.Println("failed to decode XRPC response", err)

     

       
844
       
+
       
			s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
845
       
 
       
			return

     

       
846
       
 
       
		}

     

       
847
       
 
       


     
···

       
1438
       
 
       
	if err != nil {

     

       
1439
       
 
       
		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
1440
       
 
       
			log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       
1441
       
+
       
			s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
1442
       
 
       
			return

     

       
1443
       
 
       
		}

     

       
1444
       
 
       
		log.Println("failed to fetch branches", err)

     
···

       
1448
       
 
       
	var result types.RepoBranchesResponse

     

       
1449
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
1450
       
 
       
		log.Println("failed to decode XRPC response", err)

     

       
1451
       
+
       
		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
1452
       
 
       
		return

     

       
1453
       
 
       
	}

     

       
1454
       
 
       


     
···

       
1530
       
 
       
	if err != nil {

     

       
1531
       
 
       
		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
1532
       
 
       
			log.Println("failed to call XRPC repo.branches for source", xrpcerr)

     

       
1533
       
+
       
			s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
1534
       
 
       
			return

     

       
1535
       
 
       
		}

     

       
1536
       
 
       
		log.Println("failed to fetch source branches", err)

     
···

       
1541
       
 
       
	var sourceBranches types.RepoBranchesResponse

     

       
1542
       
 
       
	if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {

     

       
1543
       
 
       
		log.Println("failed to decode source branches XRPC response", err)

     

       
1544
       
+
       
		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
1545
       
 
       
		return

     

       
1546
       
 
       
	}

     

       
1547
       
 
       


     
···

       
1559
       
 
       
	if err != nil {

     

       
1560
       
 
       
		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
1561
       
 
       
			log.Println("failed to call XRPC repo.branches for target", xrpcerr)

     

       
1562
       
+
       
			s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
1563
       
 
       
			return

     

       
1564
       
 
       
		}

     

       
1565
       
 
       
		log.Println("failed to fetch target branches", err)

     
···

       
1570
       
 
       
	var targetBranches types.RepoBranchesResponse

     

       
1571
       
 
       
	if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {

     

       
1572
       
 
       
		log.Println("failed to decode target branches XRPC response", err)

     

       
1573
       
+
       
		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
1574
       
 
       
		return

     

       
1575
       
 
       
	}

     

       
1576
       
 
       


     

···

       
7
       
 
       
	"strings"

     

       
8
       
 
       


     

       
9
       
 
       
	"tangled.org/core/api/tangled"

     

       
0
       
 
       

     

       
10
       
 
       
	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       
11
       
 
       


     

       
12
       
 
       
	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     
···

       
35
       
 
       
	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)

     

       
36
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
37
       
 
       
		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)

     

       
38
       
-
       
		rp.pages.Error503(w)

     

       
39
       
 
       
		return

     

       
40
       
 
       
	}

     

       
41
       
 
       
	// Set headers for file download, just pass along whatever the knot specifies

     

···

       
7
       
 
       
	"strings"

     

       
8
       
 
       


     

       
9
       
 
       
	"tangled.org/core/api/tangled"

     

       
10
       
+
       
	"tangled.org/core/appview/pages"

     

       
11
       
 
       
	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       
12
       
 
       


     

       
13
       
 
       
	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     
···

       
36
       
 
       
	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)

     

       
37
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
38
       
 
       
		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)

     

       
39
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: rp.oauth.GetUser(r)})

     

       
40
       
 
       
		return

     

       
41
       
 
       
	}

     

       
42
       
 
       
	// Set headers for file download, just pass along whatever the knot specifies

     

···

       
33
       
 
       
// - rest      :      |          |

     

       
34
       
 
       
func (rp *Repo) Blob(w http.ResponseWriter, r *http.Request) {

     

       
35
       
 
       
	l := rp.logger.With("handler", "RepoBlob")

     

       
0
       
 
       

     

       
36
       
 
       


     

       
37
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
38
       
 
       
	if err != nil {

     
···

       
58
       
 
       
	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       
59
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
60
       
 
       
		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     

       
61
       
-
       
		rp.pages.Error503(w)

     

       
62
       
 
       
		return

     

       
63
       
 
       
	}

     

       
64
       
 
       


     
···

       
74
       
 
       
	// Create the blob view

     

       
75
       
 
       
	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())

     

       
76
       
 
       


     

       
77
       
-
       
	user := rp.oauth.GetUser(r)

     

       
78
       
-
       


     

       
79
       
 
       
	rp.pages.RepoBlob(w, pages.RepoBlobParams{

     

       
80
       
 
       
		LoggedInUser:    user,

     

       
81
       
 
       
		RepoInfo:        f.RepoInfo(user),

     
···

       
133
       
 
       
	resp, err := client.Do(req)

     

       
134
       
 
       
	if err != nil {

     

       
135
       
 
       
		l.Error("failed to reach knotserver", "err", err)

     

       
136
       
-
       
		rp.pages.Error503(w)

     

       
137
       
 
       
		return

     

       
138
       
 
       
	}

     

       
139
       
 
       


     

···

       
33
       
 
       
// - rest      :      |          |

     

       
34
       
 
       
func (rp *Repo) Blob(w http.ResponseWriter, r *http.Request) {

     

       
35
       
 
       
	l := rp.logger.With("handler", "RepoBlob")

     

       
36
       
+
       
	user := rp.oauth.GetUser(r)

     

       
37
       
 
       


     

       
38
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
39
       
 
       
	if err != nil {

     
···

       
59
       
 
       
	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       
60
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
61
       
 
       
		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     

       
62
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
63
       
 
       
		return

     

       
64
       
 
       
	}

     

       
65
       
 
       


     
···

       
75
       
 
       
	// Create the blob view

     

       
76
       
 
       
	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())

     

       
77
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
78
       
 
       
	rp.pages.RepoBlob(w, pages.RepoBlobParams{

     

       
79
       
 
       
		LoggedInUser:    user,

     

       
80
       
 
       
		RepoInfo:        f.RepoInfo(user),

     
···

       
132
       
 
       
	resp, err := client.Do(req)

     

       
133
       
 
       
	if err != nil {

     

       
134
       
 
       
		l.Error("failed to reach knotserver", "err", err)

     

       
135
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: rp.oauth.GetUser(r)})

     

       
136
       
 
       
		return

     

       
137
       
 
       
	}

     

       
138
       
 
       


     

···

       
16
       
 
       


     

       
17
       
 
       
func (rp *Repo) Branches(w http.ResponseWriter, r *http.Request) {

     

       
18
       
 
       
	l := rp.logger.With("handler", "RepoBranches")

     

       
0
       
 
       

     

       
19
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
20
       
 
       
	if err != nil {

     

       
21
       
 
       
		l.Error("failed to get repo and knot", "err", err)

     
···

       
33
       
 
       
	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
34
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
35
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
36
       
-
       
		rp.pages.Error503(w)

     

       
37
       
 
       
		return

     

       
38
       
 
       
	}

     

       
39
       
 
       
	var result types.RepoBranchesResponse

     

       
40
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
41
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
42
       
-
       
		rp.pages.Error503(w)

     

       
43
       
 
       
		return

     

       
44
       
 
       
	}

     

       
45
       
 
       
	sortBranches(result.Branches)

     

       
46
       
-
       
	user := rp.oauth.GetUser(r)

     

       
47
       
 
       
	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       
48
       
 
       
		LoggedInUser:         user,

     

       
49
       
 
       
		RepoInfo:             f.RepoInfo(user),

     

···

       
16
       
 
       


     

       
17
       
 
       
func (rp *Repo) Branches(w http.ResponseWriter, r *http.Request) {

     

       
18
       
 
       
	l := rp.logger.With("handler", "RepoBranches")

     

       
19
       
+
       
	user := rp.oauth.GetUser(r)

     

       
20
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
21
       
 
       
	if err != nil {

     

       
22
       
 
       
		l.Error("failed to get repo and knot", "err", err)

     
···

       
34
       
 
       
	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
35
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
36
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
37
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
38
       
 
       
		return

     

       
39
       
 
       
	}

     

       
40
       
 
       
	var result types.RepoBranchesResponse

     

       
41
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
42
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
43
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
44
       
 
       
		return

     

       
45
       
 
       
	}

     

       
46
       
 
       
	sortBranches(result.Branches)

     

       
0
       
 
       

     

       
47
       
 
       
	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       
48
       
 
       
		LoggedInUser:         user,

     

       
49
       
 
       
		RepoInfo:             f.RepoInfo(user),

     

···

       
40
       
 
       
	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
41
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
42
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
43
       
-
       
		rp.pages.Error503(w)

     

       
44
       
 
       
		return

     

       
45
       
 
       
	}

     

       
46
       
 
       


     
···

       
77
       
 
       
	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
78
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
79
       
 
       
		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       
80
       
-
       
		rp.pages.Error503(w)

     

       
81
       
 
       
		return

     

       
82
       
 
       
	}

     

       
83
       
 
       


     
···

       
138
       
 
       


     

       
139
       
 
       
	if base == "" || head == "" {

     

       
140
       
 
       
		l.Error("invalid comparison")

     

       
141
       
-
       
		rp.pages.Error404(w)

     

       
142
       
 
       
		return

     

       
143
       
 
       
	}

     

       
144
       
 
       


     
···

       
156
       
 
       
	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
157
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
158
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
159
       
-
       
		rp.pages.Error503(w)

     

       
160
       
 
       
		return

     

       
161
       
 
       
	}

     

       
162
       
 
       


     
···

       
170
       
 
       
	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
171
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
172
       
 
       
		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       
173
       
-
       
		rp.pages.Error503(w)

     

       
174
       
 
       
		return

     

       
175
       
 
       
	}

     

       
176
       
 
       


     
···

       
184
       
 
       
	compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)

     

       
185
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
186
       
 
       
		l.Error("failed to call XRPC repo.compare", "err", xrpcerr)

     

       
187
       
-
       
		rp.pages.Error503(w)

     

       
188
       
 
       
		return

     

       
189
       
 
       
	}

     

       
190
       
 
       


     

···

       
40
       
 
       
	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
41
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
42
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
43
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
44
       
 
       
		return

     

       
45
       
 
       
	}

     

       
46
       
 
       


     
···

       
77
       
 
       
	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
78
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
79
       
 
       
		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       
80
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
81
       
 
       
		return

     

       
82
       
 
       
	}

     

       
83
       
 
       


     
···

       
138
       
 
       


     

       
139
       
 
       
	if base == "" || head == "" {

     

       
140
       
 
       
		l.Error("invalid comparison")

     

       
141
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
142
       
 
       
		return

     

       
143
       
 
       
	}

     

       
144
       
 
       


     
···

       
156
       
 
       
	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
157
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
158
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
159
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
160
       
 
       
		return

     

       
161
       
 
       
	}

     

       
162
       
 
       


     
···

       
170
       
 
       
	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
171
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
172
       
 
       
		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       
173
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
174
       
 
       
		return

     

       
175
       
 
       
	}

     

       
176
       
 
       


     
···

       
184
       
 
       
	compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)

     

       
185
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
186
       
 
       
		l.Error("failed to call XRPC repo.compare", "err", xrpcerr)

     

       
187
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
188
       
 
       
		return

     

       
189
       
 
       
	}

     

       
190
       
 
       


     

···

       
10
       
 
       


     

       
11
       
 
       
	"tangled.org/core/appview/db"

     

       
12
       
 
       
	"tangled.org/core/appview/models"

     

       
0
       
 
       

     

       
13
       
 
       
	"tangled.org/core/appview/pagination"

     

       
14
       
 
       
	"tangled.org/core/appview/reporesolver"

     

       
15
       
 
       


     
···

       
156
       
 
       
	feed, err := rp.getRepoFeed(r.Context(), f)

     

       
157
       
 
       
	if err != nil {

     

       
158
       
 
       
		log.Println("failed to get repo feed:", err)

     

       
159
       
-
       
		rp.pages.Error500(w)

     

       
160
       
 
       
		return

     

       
161
       
 
       
	}

     

       
162
       
 
       


     

       
163
       
 
       
	atom, err := feed.ToAtom()

     

       
164
       
 
       
	if err != nil {

     

       
165
       
-
       
		rp.pages.Error500(w)

     

       
166
       
 
       
		return

     

       
167
       
 
       
	}

     

       
168
       
 
       


     

···

       
10
       
 
       


     

       
11
       
 
       
	"tangled.org/core/appview/db"

     

       
12
       
 
       
	"tangled.org/core/appview/models"

     

       
13
       
+
       
	"tangled.org/core/appview/pages"

     

       
14
       
 
       
	"tangled.org/core/appview/pagination"

     

       
15
       
 
       
	"tangled.org/core/appview/reporesolver"

     

       
16
       
 
       


     
···

       
157
       
 
       
	feed, err := rp.getRepoFeed(r.Context(), f)

     

       
158
       
 
       
	if err != nil {

     

       
159
       
 
       
		log.Println("failed to get repo feed:", err)

     

       
160
       
+
       
		rp.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil})

     

       
161
       
 
       
		return

     

       
162
       
 
       
	}

     

       
163
       
 
       


     

       
164
       
 
       
	atom, err := feed.ToAtom()

     

       
165
       
 
       
	if err != nil {

     

       
166
       
+
       
		rp.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil})

     

       
167
       
 
       
		return

     

       
168
       
 
       
	}

     

       
169
       
 
       


     

···

       
67
       
 
       
			return

     

       
68
       
 
       
		}

     

       
69
       
 
       


     

       
70
       
-
       
		rp.pages.Error503(w)

     

       
71
       
 
       
		l.Error("failed to build index response", "err", err)

     

       
72
       
 
       
		return

     

       
73
       
 
       
	}

     

···

       
67
       
 
       
			return

     

       
68
       
 
       
		}

     

       
69
       
 
       


     

       
70
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
71
       
 
       
		l.Error("failed to build index response", "err", err)

     

       
72
       
 
       
		return

     

       
73
       
 
       
	}

     

···

       
22
       
 
       


     

       
23
       
 
       
func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) {

     

       
24
       
 
       
	l := rp.logger.With("handler", "RepoLog")

     

       
0
       
 
       

     

       
25
       
 
       


     

       
26
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
27
       
 
       
	if err != nil {

     
···

       
61
       
 
       
	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)

     

       
62
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
63
       
 
       
		l.Error("failed to call XRPC repo.log", "err", xrpcerr)

     

       
64
       
-
       
		rp.pages.Error503(w)

     

       
65
       
 
       
		return

     

       
66
       
 
       
	}

     

       
67
       
 
       


     

       
68
       
 
       
	var xrpcResp types.RepoLogResponse

     

       
69
       
 
       
	if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {

     

       
70
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
71
       
-
       
		rp.pages.Error503(w)

     

       
72
       
 
       
		return

     

       
73
       
 
       
	}

     

       
74
       
 
       


     

       
75
       
 
       
	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
76
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
77
       
 
       
		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       
78
       
-
       
		rp.pages.Error503(w)

     

       
79
       
 
       
		return

     

       
80
       
 
       
	}

     

       
81
       
 
       


     
···

       
96
       
 
       
	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
97
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
98
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
99
       
-
       
		rp.pages.Error503(w)

     

       
100
       
 
       
		return

     

       
101
       
 
       
	}

     

       
102
       
 
       


     
···

       
109
       
 
       
		}

     

       
110
       
 
       
	}

     

       
111
       
 
       


     

       
112
       
-
       
	user := rp.oauth.GetUser(r)

     

       
113
       
-
       


     

       
114
       
 
       
	emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)

     

       
115
       
 
       
	if err != nil {

     

       
116
       
 
       
		l.Error("failed to fetch email to did mapping", "err", err)

     
···

       
146
       
 
       


     

       
147
       
 
       
func (rp *Repo) Commit(w http.ResponseWriter, r *http.Request) {

     

       
148
       
 
       
	l := rp.logger.With("handler", "RepoCommit")

     

       
0
       
 
       

     

       
149
       
 
       


     

       
150
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
151
       
 
       
	if err != nil {

     
···

       
161
       
 
       
	}

     

       
162
       
 
       


     

       
163
       
 
       
	if !plumbing.IsHash(ref) {

     

       
164
       
-
       
		rp.pages.Error404(w)

     

       
165
       
 
       
		return

     

       
166
       
 
       
	}

     

       
167
       
 
       


     
···

       
178
       
 
       
	xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)

     

       
179
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
180
       
 
       
		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)

     

       
181
       
-
       
		rp.pages.Error503(w)

     

       
182
       
 
       
		return

     

       
183
       
 
       
	}

     

       
184
       
 
       


     

       
185
       
 
       
	var result types.RepoCommitResponse

     

       
186
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
187
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
188
       
-
       
		rp.pages.Error503(w)

     

       
189
       
 
       
		return

     

       
190
       
 
       
	}

     

       
191
       
 
       


     
···

       
199
       
 
       
		l.Error("failed to GetVerifiedCommits", "err", err)

     

       
200
       
 
       
	}

     

       
201
       
 
       


     

       
202
       
-
       
	user := rp.oauth.GetUser(r)

     

       
203
       
 
       
	repoInfo := f.RepoInfo(user)

     

       
204
       
 
       
	pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})

     

       
205
       
 
       
	if err != nil {

     

···

       
22
       
 
       


     

       
23
       
 
       
func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) {

     

       
24
       
 
       
	l := rp.logger.With("handler", "RepoLog")

     

       
25
       
+
       
	user := rp.oauth.GetUser(r)

     

       
26
       
 
       


     

       
27
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
28
       
 
       
	if err != nil {

     
···

       
62
       
 
       
	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)

     

       
63
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
64
       
 
       
		l.Error("failed to call XRPC repo.log", "err", xrpcerr)

     

       
65
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
66
       
 
       
		return

     

       
67
       
 
       
	}

     

       
68
       
 
       


     

       
69
       
 
       
	var xrpcResp types.RepoLogResponse

     

       
70
       
 
       
	if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {

     

       
71
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
72
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
73
       
 
       
		return

     

       
74
       
 
       
	}

     

       
75
       
 
       


     

       
76
       
 
       
	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
77
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
78
       
 
       
		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       
79
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
80
       
 
       
		return

     

       
81
       
 
       
	}

     

       
82
       
 
       


     
···

       
97
       
 
       
	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
98
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
99
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
100
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
101
       
 
       
		return

     

       
102
       
 
       
	}

     

       
103
       
 
       


     
···

       
110
       
 
       
		}

     

       
111
       
 
       
	}

     

       
112
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
113
       
 
       
	emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)

     

       
114
       
 
       
	if err != nil {

     

       
115
       
 
       
		l.Error("failed to fetch email to did mapping", "err", err)

     
···

       
145
       
 
       


     

       
146
       
 
       
func (rp *Repo) Commit(w http.ResponseWriter, r *http.Request) {

     

       
147
       
 
       
	l := rp.logger.With("handler", "RepoCommit")

     

       
148
       
+
       
	user := rp.oauth.GetUser(r)

     

       
149
       
 
       


     

       
150
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
151
       
 
       
	if err != nil {

     
···

       
161
       
 
       
	}

     

       
162
       
 
       


     

       
163
       
 
       
	if !plumbing.IsHash(ref) {

     

       
164
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
165
       
 
       
		return

     

       
166
       
 
       
	}

     

       
167
       
 
       


     
···

       
178
       
 
       
	xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)

     

       
179
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
180
       
 
       
		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)

     

       
181
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
182
       
 
       
		return

     

       
183
       
 
       
	}

     

       
184
       
 
       


     

       
185
       
 
       
	var result types.RepoCommitResponse

     

       
186
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
187
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
188
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
189
       
 
       
		return

     

       
190
       
 
       
	}

     

       
191
       
 
       


     
···

       
199
       
 
       
		l.Error("failed to GetVerifiedCommits", "err", err)

     

       
200
       
 
       
	}

     

       
201
       
 
       


     

       
0
       
 
       

     

       
202
       
 
       
	repoInfo := f.RepoInfo(user)

     

       
203
       
 
       
	pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})

     

       
204
       
 
       
	if err != nil {

     

···

       
198
       
 
       
	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
199
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
200
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
201
       
-
       
		rp.pages.Error503(w)

     

       
202
       
 
       
		return

     

       
203
       
 
       
	}

     

       
204
       
 
       


     

       
205
       
 
       
	var result types.RepoBranchesResponse

     

       
206
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
207
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
208
       
-
       
		rp.pages.Error503(w)

     

       
209
       
 
       
		return

     

       
210
       
 
       
	}

     

       
211
       
 
       


     

       
212
       
 
       
	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs))

     

       
213
       
 
       
	if err != nil {

     

       
214
       
 
       
		l.Error("failed to fetch labels", "err", err)

     

       
215
       
-
       
		rp.pages.Error503(w)

     

       
216
       
 
       
		return

     

       
217
       
 
       
	}

     

       
218
       
 
       


     

       
219
       
 
       
	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       
220
       
 
       
	if err != nil {

     

       
221
       
 
       
		l.Error("failed to fetch labels", "err", err)

     

       
222
       
-
       
		rp.pages.Error503(w)

     

       
223
       
 
       
		return

     

       
224
       
 
       
	}

     

       
225
       
 
       
	// remove default labels from the labels list, if present

     

···

       
198
       
 
       
	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
199
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
200
       
 
       
		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       
201
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
202
       
 
       
		return

     

       
203
       
 
       
	}

     

       
204
       
 
       


     

       
205
       
 
       
	var result types.RepoBranchesResponse

     

       
206
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
207
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
208
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
209
       
 
       
		return

     

       
210
       
 
       
	}

     

       
211
       
 
       


     

       
212
       
 
       
	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs))

     

       
213
       
 
       
	if err != nil {

     

       
214
       
 
       
		l.Error("failed to fetch labels", "err", err)

     

       
215
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
216
       
 
       
		return

     

       
217
       
 
       
	}

     

       
218
       
 
       


     

       
219
       
 
       
	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       
220
       
 
       
	if err != nil {

     

       
221
       
 
       
		l.Error("failed to fetch labels", "err", err)

     

       
222
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
223
       
 
       
		return

     

       
224
       
 
       
	}

     

       
225
       
 
       
	// remove default labels from the labels list, if present

     

···

       
18
       
 
       


     

       
19
       
 
       
func (rp *Repo) Tags(w http.ResponseWriter, r *http.Request) {

     

       
20
       
 
       
	l := rp.logger.With("handler", "RepoTags")

     

       
0
       
 
       

     

       
21
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
22
       
 
       
	if err != nil {

     

       
23
       
 
       
		l.Error("failed to get repo and knot", "err", err)

     
···

       
35
       
 
       
	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
36
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
37
       
 
       
		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       
38
       
-
       
		rp.pages.Error503(w)

     

       
39
       
 
       
		return

     

       
40
       
 
       
	}

     

       
41
       
 
       
	var result types.RepoTagsResponse

     

       
42
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
43
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
44
       
-
       
		rp.pages.Error503(w)

     

       
45
       
 
       
		return

     

       
46
       
 
       
	}

     

       
47
       
 
       
	artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))

     
···

       
68
       
 
       
			danglingArtifacts = append(danglingArtifacts, a)

     

       
69
       
 
       
		}

     

       
70
       
 
       
	}

     

       
71
       
-
       
	user := rp.oauth.GetUser(r)

     

       
72
       
 
       
	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       
73
       
 
       
		LoggedInUser:      user,

     

       
74
       
 
       
		RepoInfo:          f.RepoInfo(user),

     

···

       
18
       
 
       


     

       
19
       
 
       
func (rp *Repo) Tags(w http.ResponseWriter, r *http.Request) {

     

       
20
       
 
       
	l := rp.logger.With("handler", "RepoTags")

     

       
21
       
+
       
	user := rp.oauth.GetUser(r)

     

       
22
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
23
       
 
       
	if err != nil {

     

       
24
       
 
       
		l.Error("failed to get repo and knot", "err", err)

     
···

       
36
       
 
       
	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
37
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
38
       
 
       
		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       
39
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
40
       
 
       
		return

     

       
41
       
 
       
	}

     

       
42
       
 
       
	var result types.RepoTagsResponse

     

       
43
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
44
       
 
       
		l.Error("failed to decode XRPC response", "err", err)

     

       
45
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
46
       
 
       
		return

     

       
47
       
 
       
	}

     

       
48
       
 
       
	artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))

     
···

       
69
       
 
       
			danglingArtifacts = append(danglingArtifacts, a)

     

       
70
       
 
       
		}

     

       
71
       
 
       
	}

     

       
0
       
 
       

     

       
72
       
 
       
	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       
73
       
 
       
		LoggedInUser:      user,

     

       
74
       
 
       
		RepoInfo:          f.RepoInfo(user),

     

···

       
19
       
 
       


     

       
20
       
 
       
func (rp *Repo) Tree(w http.ResponseWriter, r *http.Request) {

     

       
21
       
 
       
	l := rp.logger.With("handler", "RepoTree")

     

       
0
       
 
       

     

       
22
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
23
       
 
       
	if err != nil {

     

       
24
       
 
       
		l.Error("failed to fully resolve repo", "err", err)

     
···

       
43
       
 
       
	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)

     

       
44
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
45
       
 
       
		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)

     

       
46
       
-
       
		rp.pages.Error503(w)

     

       
47
       
 
       
		return

     

       
48
       
 
       
	}

     

       
49
       
 
       
	// Convert XRPC response to internal types.RepoTreeResponse

     
···

       
86
       
 
       
		http.Redirect(w, r, redirectTo, http.StatusFound)

     

       
87
       
 
       
		return

     

       
88
       
 
       
	}

     

       
89
       
-
       
	user := rp.oauth.GetUser(r)

     

       
90
       
 
       
	var breadcrumbs [][]string

     

       
91
       
 
       
	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       
92
       
 
       
	if treePath != "" {

     

···

       
19
       
 
       


     

       
20
       
 
       
func (rp *Repo) Tree(w http.ResponseWriter, r *http.Request) {

     

       
21
       
 
       
	l := rp.logger.With("handler", "RepoTree")

     

       
22
       
+
       
	user := rp.oauth.GetUser(r)

     

       
23
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
24
       
 
       
	if err != nil {

     

       
25
       
 
       
		l.Error("failed to fully resolve repo", "err", err)

     
···

       
44
       
 
       
	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)

     

       
45
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
46
       
 
       
		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)

     

       
47
       
+
       
		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
48
       
 
       
		return

     

       
49
       
 
       
	}

     

       
50
       
 
       
	// Convert XRPC response to internal types.RepoTreeResponse

     
···

       
87
       
 
       
		http.Redirect(w, r, redirectTo, http.StatusFound)

     

       
88
       
 
       
		return

     

       
89
       
 
       
	}

     

       
0
       
 
       

     

       
90
       
 
       
	var breadcrumbs [][]string

     

       
91
       
 
       
	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       
92
       
 
       
	if treePath != "" {

     

···

       
23
       
 
       
	gfiLabelDef, err := db.GetLabelDefinition(s.db, db.FilterEq("at_uri", goodFirstIssueLabel))

     

       
24
       
 
       
	if err != nil {

     

       
25
       
 
       
		log.Println("failed to get gfi label def", err)

     

       
26
       
-
       
		s.pages.Error500(w)

     

       
27
       
 
       
		return

     

       
28
       
 
       
	}

     

       
29
       
 
       


     

       
30
       
 
       
	repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel))

     

       
31
       
 
       
	if err != nil {

     

       
32
       
 
       
		log.Println("failed to get repo labels", err)

     

       
33
       
-
       
		s.pages.Error503(w)

     

       
34
       
 
       
		return

     

       
35
       
 
       
	}

     

       
36
       
 
       


     
···

       
60
       
 
       
	)

     

       
61
       
 
       
	if err != nil {

     

       
62
       
 
       
		log.Println("failed to get issues", err)

     

       
63
       
-
       
		s.pages.Error503(w)

     

       
64
       
 
       
		return

     

       
65
       
 
       
	}

     

       
66
       
 
       


     

···

       
23
       
 
       
	gfiLabelDef, err := db.GetLabelDefinition(s.db, db.FilterEq("at_uri", goodFirstIssueLabel))

     

       
24
       
 
       
	if err != nil {

     

       
25
       
 
       
		log.Println("failed to get gfi label def", err)

     

       
26
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
27
       
 
       
		return

     

       
28
       
 
       
	}

     

       
29
       
 
       


     

       
30
       
 
       
	repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel))

     

       
31
       
 
       
	if err != nil {

     

       
32
       
 
       
		log.Println("failed to get repo labels", err)

     

       
33
       
+
       
		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
34
       
 
       
		return

     

       
35
       
 
       
	}

     

       
36
       
 
       


     
···

       
60
       
 
       
	)

     

       
61
       
 
       
	if err != nil {

     

       
62
       
 
       
		log.Println("failed to get issues", err)

     

       
63
       
+
       
		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
64
       
 
       
		return

     

       
65
       
 
       
	}

     

       
66
       
 
       


     

···

       
112
       
 
       


     

       
113
       
 
       
func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) {

     

       
114
       
 
       
	l := s.logger.With("handler", "profileHomePage")

     

       
0
       
 
       

     

       
115
       
 
       


     

       
116
       
 
       
	profile, err := s.profile(r)

     

       
117
       
 
       
	if err != nil {

     

       
118
       
 
       
		l.Error("failed to build profile card", "err", err)

     

       
119
       
-
       
		s.pages.Error500(w)

     

       
120
       
 
       
		return

     

       
121
       
 
       
	}

     

       
122
       
 
       
	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       
163
       
 
       
	}

     

       
164
       
 
       


     

       
165
       
 
       
	s.pages.ProfileOverview(w, pages.ProfileOverviewParams{

     

       
166
       
-
       
		LoggedInUser:       s.oauth.GetUser(r),

     

       
167
       
 
       
		Card:               profile,

     

       
168
       
 
       
		Repos:              pinnedRepos,

     

       
169
       
 
       
		CollaboratingRepos: pinnedCollaboratingRepos,

     
···

       
173
       
 
       


     

       
174
       
 
       
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {

     

       
175
       
 
       
	l := s.logger.With("handler", "reposPage")

     

       
0
       
 
       

     

       
176
       
 
       


     

       
177
       
 
       
	profile, err := s.profile(r)

     

       
178
       
 
       
	if err != nil {

     

       
179
       
 
       
		l.Error("failed to build profile card", "err", err)

     

       
180
       
-
       
		s.pages.Error500(w)

     

       
181
       
 
       
		return

     

       
182
       
 
       
	}

     

       
183
       
 
       
	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       
189
       
 
       
	)

     

       
190
       
 
       
	if err != nil {

     

       
191
       
 
       
		l.Error("failed to get repos", "err", err)

     

       
192
       
-
       
		s.pages.Error500(w)

     

       
193
       
 
       
		return

     

       
194
       
 
       
	}

     

       
195
       
 
       


     

       
196
       
 
       
	err = s.pages.ProfileRepos(w, pages.ProfileReposParams{

     

       
197
       
-
       
		LoggedInUser: s.oauth.GetUser(r),

     

       
198
       
 
       
		Repos:        repos,

     

       
199
       
 
       
		Card:         profile,

     

       
200
       
 
       
	})

     
···

       
202
       
 
       


     

       
203
       
 
       
func (s *State) starredPage(w http.ResponseWriter, r *http.Request) {

     

       
204
       
 
       
	l := s.logger.With("handler", "starredPage")

     

       
0
       
 
       

     

       
205
       
 
       


     

       
206
       
 
       
	profile, err := s.profile(r)

     

       
207
       
 
       
	if err != nil {

     

       
208
       
 
       
		l.Error("failed to build profile card", "err", err)

     

       
209
       
-
       
		s.pages.Error500(w)

     

       
210
       
 
       
		return

     

       
211
       
 
       
	}

     

       
212
       
 
       
	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       
214
       
 
       
	stars, err := db.GetRepoStars(s.db, 0, db.FilterEq("did", profile.UserDid))

     

       
215
       
 
       
	if err != nil {

     

       
216
       
 
       
		l.Error("failed to get stars", "err", err)

     

       
217
       
-
       
		s.pages.Error500(w)

     

       
218
       
 
       
		return

     

       
219
       
 
       
	}

     

       
220
       
 
       
	var repos []models.Repo

     
···

       
223
       
 
       
	}

     

       
224
       
 
       


     

       
225
       
 
       
	err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{

     

       
226
       
-
       
		LoggedInUser: s.oauth.GetUser(r),

     

       
227
       
 
       
		Repos:        repos,

     

       
228
       
 
       
		Card:         profile,

     

       
229
       
 
       
	})

     
···

       
231
       
 
       


     

       
232
       
 
       
func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) {

     

       
233
       
 
       
	l := s.logger.With("handler", "stringsPage")

     

       
0
       
 
       

     

       
234
       
 
       


     

       
235
       
 
       
	profile, err := s.profile(r)

     

       
236
       
 
       
	if err != nil {

     

       
237
       
 
       
		l.Error("failed to build profile card", "err", err)

     

       
238
       
-
       
		s.pages.Error500(w)

     

       
239
       
 
       
		return

     

       
240
       
 
       
	}

     

       
241
       
 
       
	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       
243
       
 
       
	strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid))

     

       
244
       
 
       
	if err != nil {

     

       
245
       
 
       
		l.Error("failed to get strings", "err", err)

     

       
246
       
-
       
		s.pages.Error500(w)

     

       
247
       
 
       
		return

     

       
248
       
 
       
	}

     

       
249
       
 
       


     

       
250
       
 
       
	err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{

     

       
251
       
-
       
		LoggedInUser: s.oauth.GetUser(r),

     

       
252
       
 
       
		Strings:      strings,

     

       
253
       
 
       
		Card:         profile,

     

       
254
       
 
       
	})

     
···

       
379
       
 
       
func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) {

     

       
380
       
 
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
381
       
 
       
	if !ok {

     

       
382
       
-
       
		s.pages.Error404(w)

     

       
383
       
 
       
		return

     

       
384
       
 
       
	}

     

       
385
       
 
       


     

       
386
       
 
       
	feed, err := s.getProfileFeed(r.Context(), &ident)

     

       
387
       
 
       
	if err != nil {

     

       
388
       
-
       
		s.pages.Error500(w)

     

       
389
       
 
       
		return

     

       
390
       
 
       
	}

     

       
391
       
 
       


     
···

       
395
       
 
       


     

       
396
       
 
       
	atom, err := feed.ToAtom()

     

       
397
       
 
       
	if err != nil {

     

       
398
       
-
       
		s.pages.Error500(w)

     

       
399
       
 
       
		return

     

       
400
       
 
       
	}

     

       
401
       
 
       


     

···

       
112
       
 
       


     

       
113
       
 
       
func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) {

     

       
114
       
 
       
	l := s.logger.With("handler", "profileHomePage")

     

       
115
       
+
       
	user := s.oauth.GetUser(r)

     

       
116
       
 
       


     

       
117
       
 
       
	profile, err := s.profile(r)

     

       
118
       
 
       
	if err != nil {

     

       
119
       
 
       
		l.Error("failed to build profile card", "err", err)

     

       
120
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
121
       
 
       
		return

     

       
122
       
 
       
	}

     

       
123
       
 
       
	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       
164
       
 
       
	}

     

       
165
       
 
       


     

       
166
       
 
       
	s.pages.ProfileOverview(w, pages.ProfileOverviewParams{

     

       
167
       
+
       
		LoggedInUser:       user,

     

       
168
       
 
       
		Card:               profile,

     

       
169
       
 
       
		Repos:              pinnedRepos,

     

       
170
       
 
       
		CollaboratingRepos: pinnedCollaboratingRepos,

     
···

       
174
       
 
       


     

       
175
       
 
       
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {

     

       
176
       
 
       
	l := s.logger.With("handler", "reposPage")

     

       
177
       
+
       
	user := s.oauth.GetUser(r)

     

       
178
       
 
       


     

       
179
       
 
       
	profile, err := s.profile(r)

     

       
180
       
 
       
	if err != nil {

     

       
181
       
 
       
		l.Error("failed to build profile card", "err", err)

     

       
182
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
183
       
 
       
		return

     

       
184
       
 
       
	}

     

       
185
       
 
       
	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       
191
       
 
       
	)

     

       
192
       
 
       
	if err != nil {

     

       
193
       
 
       
		l.Error("failed to get repos", "err", err)

     

       
194
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
195
       
 
       
		return

     

       
196
       
 
       
	}

     

       
197
       
 
       


     

       
198
       
 
       
	err = s.pages.ProfileRepos(w, pages.ProfileReposParams{

     

       
199
       
+
       
		LoggedInUser: user,

     

       
200
       
 
       
		Repos:        repos,

     

       
201
       
 
       
		Card:         profile,

     

       
202
       
 
       
	})

     
···

       
204
       
 
       


     

       
205
       
 
       
func (s *State) starredPage(w http.ResponseWriter, r *http.Request) {

     

       
206
       
 
       
	l := s.logger.With("handler", "starredPage")

     

       
207
       
+
       
	user := s.oauth.GetUser(r)

     

       
208
       
 
       


     

       
209
       
 
       
	profile, err := s.profile(r)

     

       
210
       
 
       
	if err != nil {

     

       
211
       
 
       
		l.Error("failed to build profile card", "err", err)

     

       
212
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
213
       
 
       
		return

     

       
214
       
 
       
	}

     

       
215
       
 
       
	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       
217
       
 
       
	stars, err := db.GetRepoStars(s.db, 0, db.FilterEq("did", profile.UserDid))

     

       
218
       
 
       
	if err != nil {

     

       
219
       
 
       
		l.Error("failed to get stars", "err", err)

     

       
220
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
221
       
 
       
		return

     

       
222
       
 
       
	}

     

       
223
       
 
       
	var repos []models.Repo

     
···

       
226
       
 
       
	}

     

       
227
       
 
       


     

       
228
       
 
       
	err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{

     

       
229
       
+
       
		LoggedInUser: user,

     

       
230
       
 
       
		Repos:        repos,

     

       
231
       
 
       
		Card:         profile,

     

       
232
       
 
       
	})

     
···

       
234
       
 
       


     

       
235
       
 
       
func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) {

     

       
236
       
 
       
	l := s.logger.With("handler", "stringsPage")

     

       
237
       
+
       
	user := s.oauth.GetUser(r)

     

       
238
       
 
       


     

       
239
       
 
       
	profile, err := s.profile(r)

     

       
240
       
 
       
	if err != nil {

     

       
241
       
 
       
		l.Error("failed to build profile card", "err", err)

     

       
242
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
243
       
 
       
		return

     

       
244
       
 
       
	}

     

       
245
       
 
       
	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       
247
       
 
       
	strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid))

     

       
248
       
 
       
	if err != nil {

     

       
249
       
 
       
		l.Error("failed to get strings", "err", err)

     

       
250
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
251
       
 
       
		return

     

       
252
       
 
       
	}

     

       
253
       
 
       


     

       
254
       
 
       
	err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{

     

       
255
       
+
       
		LoggedInUser: user,

     

       
256
       
 
       
		Strings:      strings,

     

       
257
       
 
       
		Card:         profile,

     

       
258
       
 
       
	})

     
···

       
383
       
 
       
func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) {

     

       
384
       
 
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
385
       
 
       
	if !ok {

     

       
386
       
+
       
		s.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: nil})

     

       
387
       
 
       
		return

     

       
388
       
 
       
	}

     

       
389
       
 
       


     

       
390
       
 
       
	feed, err := s.getProfileFeed(r.Context(), &ident)

     

       
391
       
 
       
	if err != nil {

     

       
392
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil})

     

       
393
       
 
       
		return

     

       
394
       
 
       
	}

     

       
395
       
 
       


     
···

       
399
       
 
       


     

       
400
       
 
       
	atom, err := feed.ToAtom()

     

       
401
       
 
       
	if err != nil {

     

       
402
       
+
       
		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil})

     

       
403
       
 
       
		return

     

       
404
       
 
       
	}

     

       
405
       
 
       


     

···

       
10
       
 
       
	"tangled.org/core/appview/labels"

     

       
11
       
 
       
	"tangled.org/core/appview/middleware"

     

       
12
       
 
       
	"tangled.org/core/appview/notifications"

     

       
0
       
 
       

     

       
13
       
 
       
	"tangled.org/core/appview/pipelines"

     

       
14
       
 
       
	"tangled.org/core/appview/pulls"

     

       
15
       
 
       
	"tangled.org/core/appview/repo"

     
···

       
108
       
 
       
	})

     

       
109
       
 
       


     

       
110
       
 
       
	r.NotFound(func(w http.ResponseWriter, r *http.Request) {

     

       
111
       
-
       
		s.pages.Error404(w)

     

       
112
       
 
       
	})

     

       
113
       
 
       


     

       
114
       
 
       
	return r

     
···

       
179
       
 
       
	r.Get("/brand", s.Brand)

     

       
180
       
 
       


     

       
181
       
 
       
	r.NotFound(func(w http.ResponseWriter, r *http.Request) {

     

       
182
       
-
       
		s.pages.Error404(w)

     

       
183
       
 
       
	})

     

       
184
       
 
       
	return r

     

       
185
       
 
       
}

     

···

       
10
       
 
       
	"tangled.org/core/appview/labels"

     

       
11
       
 
       
	"tangled.org/core/appview/middleware"

     

       
12
       
 
       
	"tangled.org/core/appview/notifications"

     

       
13
       
+
       
	"tangled.org/core/appview/pages"

     

       
14
       
 
       
	"tangled.org/core/appview/pipelines"

     

       
15
       
 
       
	"tangled.org/core/appview/pulls"

     

       
16
       
 
       
	"tangled.org/core/appview/repo"

     
···

       
109
       
 
       
	})

     

       
110
       
 
       


     

       
111
       
 
       
	r.NotFound(func(w http.ResponseWriter, r *http.Request) {

     

       
112
       
+
       
		s.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: s.oauth.GetUser(r)})

     

       
113
       
 
       
	})

     

       
114
       
 
       


     

       
115
       
 
       
	return r

     
···

       
180
       
 
       
	r.Get("/brand", s.Brand)

     

       
181
       
 
       


     

       
182
       
 
       
	r.NotFound(func(w http.ResponseWriter, r *http.Request) {

     

       
183
       
+
       
		s.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: s.oauth.GetUser(r)})

     

       
184
       
 
       
	})

     

       
185
       
 
       
	return r

     

       
186
       
 
       
}

     

···

       
88
       
 
       


     

       
89
       
 
       
func (s *Strings) contents(w http.ResponseWriter, r *http.Request) {

     

       
90
       
 
       
	l := s.Logger.With("handler", "contents")

     

       
0
       
 
       

     

       
91
       
 
       


     

       
92
       
 
       
	id, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
93
       
 
       
	if !ok {

     
···

       
118
       
 
       
	}

     

       
119
       
 
       
	if len(strings) < 1 {

     

       
120
       
 
       
		l.Error("string not found")

     

       
121
       
-
       
		s.Pages.Error404(w)

     

       
122
       
 
       
		return

     

       
123
       
 
       
	}

     

       
124
       
 
       
	if len(strings) != 1 {

     
···

       
152
       
 
       
	if err != nil {

     

       
153
       
 
       
		l.Error("failed to get star count", "err", err)

     

       
154
       
 
       
	}

     

       
155
       
-
       
	user := s.OAuth.GetUser(r)

     

       
156
       
 
       
	isStarred := false

     

       
157
       
 
       
	if user != nil {

     

       
158
       
 
       
		isStarred = db.GetStarStatus(s.Db, user.Did, string.AtUri())

     

···

       
88
       
 
       


     

       
89
       
 
       
func (s *Strings) contents(w http.ResponseWriter, r *http.Request) {

     

       
90
       
 
       
	l := s.Logger.With("handler", "contents")

     

       
91
       
+
       
	user := s.OAuth.GetUser(r)

     

       
92
       
 
       


     

       
93
       
 
       
	id, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
94
       
 
       
	if !ok {

     
···

       
119
       
 
       
	}

     

       
120
       
 
       
	if len(strings) < 1 {

     

       
121
       
 
       
		l.Error("string not found")

     

       
122
       
+
       
		s.Pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})

     

       
123
       
 
       
		return

     

       
124
       
 
       
	}

     

       
125
       
 
       
	if len(strings) != 1 {

     
···

       
153
       
 
       
	if err != nil {

     

       
154
       
 
       
		l.Error("failed to get star count", "err", err)

     

       
155
       
 
       
	}

     

       
0
       
 
       

     

       
156
       
 
       
	isStarred := false

     

       
157
       
 
       
	if user != nil {

     

       
158
       
 
       
		isStarred = db.GetStarStatus(s.Db, user.Did, string.AtUri())