appview: add user in 404 error pages #9

···

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

     

       
79
       
 
       
	if !ok {

     

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

     

       
81
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
82
       
 
       
		return

     

       
83
       
 
       
	}

     

       
84
       
 
       


     
···

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

     

       
133
       
 
       
	if !ok {

     

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

     

       
135
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
136
       
 
       
		return

     

       
137
       
 
       
	}

     

       
138
       
 
       


     
···

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

     

       
276
       
 
       
	if !ok {

     

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

     

       
278
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
279
       
 
       
		return

     

       
280
       
 
       
	}

     

       
281
       
 
       


     
···

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

     

       
325
       
 
       
	if !ok {

     

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

     

       
327
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
328
       
 
       
		return

     

       
329
       
 
       
	}

     

       
330
       
 
       


     
···

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

     

       
369
       
 
       
	if !ok {

     

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

     

       
371
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
372
       
 
       
		return

     

       
373
       
 
       
	}

     

       
374
       
 
       


     
···

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

     

       
457
       
 
       
	if !ok {

     

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

     

       
459
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
460
       
 
       
		return

     

       
461
       
 
       
	}

     

       
462
       
 
       


     
···

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

     

       
498
       
 
       
	if !ok {

     

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

     

       
500
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
501
       
 
       
		return

     

       
502
       
 
       
	}

     

       
503
       
 
       


     
···

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

     

       
602
       
 
       
	if !ok {

     

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

     

       
604
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
605
       
 
       
		return

     

       
606
       
 
       
	}

     

       
607
       
 
       


     
···

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

     

       
643
       
 
       
	if !ok {

     

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

     

       
645
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
646
       
 
       
		return

     

       
647
       
 
       
	}

     

       
648
       
 
       


     
···

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

     

       
684
       
 
       
	if !ok {

     

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

     

       
686
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
687
       
 
       
		return

     

       
688
       
 
       
	}

     

       
689
       
 
       


     

···

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

     

       
79
       
 
       
	if !ok {

     

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

     

       
81
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
82
       
+
       
			LoggedInUser: user,

     

       
83
       
+
       
		})

     

       
84
       
 
       
		return

     

       
85
       
 
       
	}

     

       
86
       
 
       


     
···

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

     

       
135
       
 
       
	if !ok {

     

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

     

       
137
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
138
       
+
       
			LoggedInUser: user,

     

       
139
       
+
       
		})

     

       
140
       
 
       
		return

     

       
141
       
 
       
	}

     

       
142
       
 
       


     
···

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

     

       
280
       
 
       
	if !ok {

     

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

     

       
282
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
283
       
+
       
			LoggedInUser: user,

     

       
284
       
+
       
		})

     

       
285
       
 
       
		return

     

       
286
       
 
       
	}

     

       
287
       
 
       


     
···

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

     

       
331
       
 
       
	if !ok {

     

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

     

       
333
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
334
       
+
       
			LoggedInUser: user,

     

       
335
       
+
       
		})

     

       
336
       
 
       
		return

     

       
337
       
 
       
	}

     

       
338
       
 
       


     
···

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

     

       
377
       
 
       
	if !ok {

     

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

     

       
379
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
380
       
+
       
			LoggedInUser: user,

     

       
381
       
+
       
		})

     

       
382
       
 
       
		return

     

       
383
       
 
       
	}

     

       
384
       
 
       


     
···

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

     

       
467
       
 
       
	if !ok {

     

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

     

       
469
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
470
       
+
       
			LoggedInUser: user,

     

       
471
       
+
       
		})

     

       
472
       
 
       
		return

     

       
473
       
 
       
	}

     

       
474
       
 
       


     
···

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

     

       
510
       
 
       
	if !ok {

     

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

     

       
512
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
513
       
+
       
			LoggedInUser: user,

     

       
514
       
+
       
		})

     

       
515
       
 
       
		return

     

       
516
       
 
       
	}

     

       
517
       
 
       


     
···

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

     

       
616
       
 
       
	if !ok {

     

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

     

       
618
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
619
       
+
       
			LoggedInUser: user,

     

       
620
       
+
       
		})

     

       
621
       
 
       
		return

     

       
622
       
 
       
	}

     

       
623
       
 
       


     
···

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

     

       
659
       
 
       
	if !ok {

     

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

     

       
661
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
662
       
+
       
			LoggedInUser: user,

     

       
663
       
+
       
		})

     

       
664
       
 
       
		return

     

       
665
       
 
       
	}

     

       
666
       
 
       


     
···

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

     

       
702
       
 
       
	if !ok {

     

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

     

       
704
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
705
       
+
       
			LoggedInUser: user,

     

       
706
       
+
       
		})

     

       
707
       
 
       
		return

     

       
708
       
 
       
	}

     

       
709
       
 
       


     

···

       
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
       
 
       


     

···

       
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{})

     

       
195
       
 
       
				return

     

       
196
       
 
       
			}

     

       
197
       
 
       


     

···

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

     

       
1527
       
 
       
}

     

       
1528
       
 
       


     

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

     

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

     

       
1531
       
 
       
}

     

       
1532
       
 
       


     

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

     

···

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

     

       
1527
       
 
       
}

     

       
1528
       
 
       


     

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

     

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

     

       
1531
       
 
       
}

     

       
1532
       
 
       


     

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

     

···

       
353
       
 
       


     

       
354
       
 
       
func (rp *Repo) RepoCommit(w http.ResponseWriter, r *http.Request) {

     

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

     

       
0
       
 
       

     

       
356
       
 
       


     

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

     

       
358
       
 
       
	if err != nil {

     
···

       
368
       
 
       
	}

     

       
369
       
 
       


     

       
370
       
 
       
	if !plumbing.IsHash(ref) {

     

       
371
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
372
       
 
       
		return

     

       
373
       
 
       
	}

     

       
374
       
 
       


     
···

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

     

       
407
       
 
       
	}

     

       
408
       
 
       


     

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

     

       
410
       
 
       
	repoInfo := f.RepoInfo(user)

     

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

     

       
412
       
 
       
	if err != nil {

     
···

       
2512
       
 
       


     

       
2513
       
 
       
	if base == "" || head == "" {

     

       
2514
       
 
       
		l.Error("invalid comparison")

     

       
2515
       
-
       
		rp.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2516
       
 
       
		return

     

       
2517
       
 
       
	}

     

       
2518
       
 
       


     

···

       
353
       
 
       


     

       
354
       
 
       
func (rp *Repo) RepoCommit(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       
357
       
 
       


     

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

     

       
359
       
 
       
	if err != nil {

     
···

       
369
       
 
       
	}

     

       
370
       
 
       


     

       
371
       
 
       
	if !plumbing.IsHash(ref) {

     

       
372
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
373
       
+
       
			LoggedInUser: user,

     

       
374
       
+
       
		})

     

       
375
       
 
       
		return

     

       
376
       
 
       
	}

     

       
377
       
 
       


     
···

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

     

       
410
       
 
       
	}

     

       
411
       
 
       


     

       
0
       
 
       

     

       
412
       
 
       
	repoInfo := f.RepoInfo(user)

     

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

     

       
414
       
 
       
	if err != nil {

     
···

       
2514
       
 
       


     

       
2515
       
 
       
	if base == "" || head == "" {

     

       
2516
       
 
       
		l.Error("invalid comparison")

     

       
2517
       
+
       
		rp.pages.Error404(w, pages.ErrorPageParams{

     

       
2518
       
+
       
			LoggedInUser: user,

     

       
2519
       
+
       
		})

     

       
2520
       
 
       
		return

     

       
2521
       
 
       
	}

     

       
2522
       
 
       


     

···

       
398
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
401
       
 
       
	if !ok {

     

       
402
       
-
       
		s.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
403
       
 
       
		return

     

       
404
       
 
       
	}

     

       
405
       
-
       
	user := s.oauth.GetUser(r)

     

       
406
       
 
       


     

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

     

       
408
       
 
       
	if err != nil {

     

···

       
398
       
 
       


     

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

     

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

     

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

     

       
402
       
+
       


     

       
403
       
 
       
	if !ok {

     

       
404
       
+
       
		s.pages.Error404(w, pages.ErrorPageParams{

     

       
405
       
+
       
			LoggedInUser: user,

     

       
406
       
+
       
		})

     

       
407
       
 
       
		return

     

       
408
       
 
       
	}

     

       
0
       
 
       

     

       
409
       
 
       


     

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

     

       
411
       
 
       
	if err != nil {

     

···

       
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"

     
···

       
103
       
 
       
	})

     

       
104
       
 
       


     

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

     

       
106
       
-
       
		s.pages.Error404(w)

     

       
107
       
 
       
	})

     

       
108
       
 
       


     

       
109
       
 
       
	return r

     
···

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

     

       
175
       
 
       


     

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

     

       
177
       
-
       
		s.pages.Error404(w)

     

       
178
       
 
       
	})

     

       
179
       
 
       
	return r

     

       
180
       
 
       
}

     

···

       
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"

     
···

       
104
       
 
       
	})

     

       
105
       
 
       


     

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

     

       
107
       
+
       
		s.pages.Error404(w, pages.ErrorPageParams{})

     

       
108
       
 
       
	})

     

       
109
       
 
       


     

       
110
       
 
       
	return r

     
···

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

     

       
176
       
 
       


     

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

     

       
178
       
+
       
		s.pages.Error404(w, pages.ErrorPageParams{})

     

       
179
       
 
       
	})

     

       
180
       
 
       
	return r

     

       
181
       
 
       
}

     

···

       
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)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
122
       
 
       
		return

     

       
123
       
 
       
	}

     

       
124
       
 
       
	if len(strings) != 1 {

     

···

       
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{

     

       
123
       
+
       
			LoggedInUser: user,

     

       
124
       
+
       
		})

     

       
125
       
 
       
		return

     

       
126
       
 
       
	}

     

       
127
       
 
       
	if len(strings) != 1 {