back round 0 view raw

appview/pages: include LoggedInUser on error pages #845

closed
opened by octet-stream.net targeting master from octet-stream.net/core: thombles/error-logged-in

Closes https://tangled.org/tangled.org/core/issues/272

Call sites are updated to provide user, which was usually present anyway. There were a couple of exceptions where I passed nil in functions that were creating an atom feed, since it seemed unlikely to be authenticated.

options
unified split
Changed files
+107 -98
appview
issues
issues.go
middleware
middleware.go
notifications
notifications.go
pages
pages.go
pulls
pulls.go
repo
archive.go
blob.go
branches.go
compare.go
feed.go
index.go
log.go
settings.go
tags.go
tree.go
state
gfi.go
profile.go
router.go
strings
strings.go
+12 -12
appview/issues/issues.go 
···

       
83

       
83

       
 

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


     

       
84

       
84

       
 

       
	if !ok {


     

       
85

       
85

       
 

       
		l.Error("failed to get issue")


     

       
86

       

       
-

       
		rp.pages.Error404(w)


     

       

       
86

       
+

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


     

       
87

       
87

       
 

       
		return


     

       
88

       
88

       
 

       
	}


     

       
89

       
89

       
 

       



     
···

       
104

       
104

       
 

       
	)


     

       
105

       
105

       
 

       
	if err != nil {


     

       
106

       
106

       
 

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


     

       
107

       

       
-

       
		rp.pages.Error503(w)


     

       

       
107

       
+

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


     

       
108

       
108

       
 

       
		return


     

       
109

       
109

       
 

       
	}


     

       
110

       
110

       
 

       



     
···

       
137

       
137

       
 

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


     

       
138

       
138

       
 

       
	if !ok {


     

       
139

       
139

       
 

       
		l.Error("failed to get issue")


     

       
140

       

       
-

       
		rp.pages.Error404(w)


     

       

       
140

       
+

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


     

       
141

       
141

       
 

       
		return


     

       
142

       
142

       
 

       
	}


     

       
143

       
143

       
 

       



     
···

       
282

       
282

       
 

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


     

       
283

       
283

       
 

       
	if !ok {


     

       
284

       
284

       
 

       
		l.Error("failed to get issue")


     

       
285

       

       
-

       
		rp.pages.Error404(w)


     

       

       
285

       
+

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


     

       
286

       
286

       
 

       
		return


     

       
287

       
287

       
 

       
	}


     

       
288

       
288

       
 

       



     
···

       
333

       
333

       
 

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


     

       
334

       
334

       
 

       
	if !ok {


     

       
335

       
335

       
 

       
		l.Error("failed to get issue")


     

       
336

       

       
-

       
		rp.pages.Error404(w)


     

       

       
336

       
+

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


     

       
337

       
337

       
 

       
		return


     

       
338

       
338

       
 

       
	}


     

       
339

       
339

       
 

       



     
···

       
383

       
383

       
 

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


     

       
384

       
384

       
 

       
	if !ok {


     

       
385

       
385

       
 

       
		l.Error("failed to get issue")


     

       
386

       

       
-

       
		rp.pages.Error404(w)


     

       

       
386

       
+

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


     

       
387

       
387

       
 

       
		return


     

       
388

       
388

       
 

       
	}


     

       
389

       
389

       
 

       



     
···

       
481

       
481

       
 

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


     

       
482

       
482

       
 

       
	if !ok {


     

       
483

       
483

       
 

       
		l.Error("failed to get issue")


     

       
484

       

       
-

       
		rp.pages.Error404(w)


     

       

       
484

       
+

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


     

       
485

       
485

       
 

       
		return


     

       
486

       
486

       
 

       
	}


     

       
487

       
487

       
 

       



     
···

       
522

       
522

       
 

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


     

       
523

       
523

       
 

       
	if !ok {


     

       
524

       
524

       
 

       
		l.Error("failed to get issue")


     

       
525

       

       
-

       
		rp.pages.Error404(w)


     

       

       
525

       
+

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


     

       
526

       
526

       
 

       
		return


     

       
527

       
527

       
 

       
	}


     

       
528

       
528

       
 

       



     
···

       
626

       
626

       
 

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


     

       
627

       
627

       
 

       
	if !ok {


     

       
628

       
628

       
 

       
		l.Error("failed to get issue")


     

       
629

       

       
-

       
		rp.pages.Error404(w)


     

       

       
629

       
+

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


     

       
630

       
630

       
 

       
		return


     

       
631

       
631

       
 

       
	}


     

       
632

       
632

       
 

       



     
···

       
667

       
667

       
 

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


     

       
668

       
668

       
 

       
	if !ok {


     

       
669

       
669

       
 

       
		l.Error("failed to get issue")


     

       
670

       

       
-

       
		rp.pages.Error404(w)


     

       

       
670

       
+

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


     

       
671

       
671

       
 

       
		return


     

       
672

       
672

       
 

       
	}


     

       
673

       
673

       
 

       



     
···

       
708

       
708

       
 

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


     

       
709

       
709

       
 

       
	if !ok {


     

       
710

       
710

       
 

       
		l.Error("failed to get issue")


     

       
711

       

       
-

       
		rp.pages.Error404(w)


     

       

       
711

       
+

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


     

       
712

       
712

       
 

       
		return


     

       
713

       
713

       
 

       
	}


     

       
714

       
714

       
 

       



     
···

       
864

       
864

       
 

       
	)


     

       
865

       
865

       
 

       
	if err != nil {


     

       
866

       
866

       
 

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


     

       
867

       

       
-

       
		rp.pages.Error503(w)


     

       

       
867

       
+

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


     

       
868

       
868

       
 

       
		return


     

       
869

       
869

       
 

       
	}


     

       
870

       
870
+9 -9
appview/middleware/middleware.go 
···

       
191

       
191

       
 

       
			if err != nil {


     

       
192

       
192

       
 

       
				// invalid did or handle


     

       
193

       
193

       
 

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


     

       
194

       

       
-

       
				mw.pages.Error404(w)


     

       

       
194

       
+

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


     

       
195

       
195

       
 

       
				return


     

       
196

       
196

       
 

       
			}


     

       
197

       
197

       
 

       



     
···

       
222

       
222

       
 

       
			)


     

       
223

       
223

       
 

       
			if err != nil {


     

       
224

       
224

       
 

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


     

       
225

       

       
-

       
				mw.pages.ErrorKnot404(w)


     

       

       
225

       
+

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


     

       
226

       
226

       
 

       
				return


     

       
227

       
227

       
 

       
			}


     

       
228

       
228

       
 

       



     
···

       
239

       
239

       
 

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


     

       
240

       
240

       
 

       
			if err != nil {


     

       
241

       
241

       
 

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


     

       
242

       

       
-

       
				mw.pages.ErrorKnot404(w)


     

       

       
242

       
+

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


     

       
243

       
243

       
 

       
				return


     

       
244

       
244

       
 

       
			}


     

       
245

       
245

       
 

       



     
···

       
247

       
247

       
 

       
			prIdInt, err := strconv.Atoi(prId)


     

       
248

       
248

       
 

       
			if err != nil {


     

       
249

       
249

       
 

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


     

       
250

       

       
-

       
				mw.pages.Error404(w)


     

       

       
250

       
+

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


     

       
251

       
251

       
 

       
				return


     

       
252

       
252

       
 

       
			}


     

       
253

       
253

       
 

       



     

       
254

       
254

       
 

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


     

       
255

       
255

       
 

       
			if err != nil {


     

       
256

       
256

       
 

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


     

       
257

       

       
-

       
				mw.pages.Error404(w)


     

       

       
257

       
+

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


     

       
258

       
258

       
 

       
				return


     

       
259

       
259

       
 

       
			}


     

       
260

       
260

       
 

       



     
···

       
287

       
287

       
 

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


     

       
288

       
288

       
 

       
		if err != nil {


     

       
289

       
289

       
 

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


     

       
290

       

       
-

       
			mw.pages.ErrorKnot404(w)


     

       

       
290

       
+

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


     

       
291

       
291

       
 

       
			return


     

       
292

       
292

       
 

       
		}


     

       
293

       
293

       
 

       



     
···

       
295

       
295

       
 

       
		issueId, err := strconv.Atoi(issueIdStr)


     

       
296

       
296

       
 

       
		if err != nil {


     

       
297

       
297

       
 

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


     

       
298

       

       
-

       
			mw.pages.Error404(w)


     

       

       
298

       
+

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


     

       
299

       
299

       
 

       
			return


     

       
300

       
300

       
 

       
		}


     

       
301

       
301

       
 

       



     

       
302

       
302

       
 

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


     

       
303

       
303

       
 

       
		if err != nil {


     

       
304

       
304

       
 

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


     

       
305

       

       
-

       
			mw.pages.Error404(w)


     

       

       
305

       
+

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


     

       
306

       
306

       
 

       
			return


     

       
307

       
307

       
 

       
		}


     

       
308

       
308

       
 

       



     
···

       
323

       
323

       
 

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


     

       
324

       
324

       
 

       
			if err != nil {


     

       
325

       
325

       
 

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


     

       
326

       

       
-

       
				mw.pages.ErrorKnot404(w)


     

       

       
326

       
+

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


     

       
327

       
327

       
 

       
				return


     

       
328

       
328

       
 

       
			}


     

       
329

       
329
+2 -2
appview/notifications/notifications.go 
···

       
57

       
57

       
 

       
	)


     

       
58

       
58

       
 

       
	if err != nil {


     

       
59

       
59

       
 

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


     

       
60

       

       
-

       
		n.pages.Error500(w)


     

       

       
60

       
+

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


     

       
61

       
61

       
 

       
		return


     

       
62

       
62

       
 

       
	}


     

       
63

       
63

       
 

       



     
···

       
68

       
68

       
 

       
	)


     

       
69

       
69

       
 

       
	if err != nil {


     

       
70

       
70

       
 

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


     

       
71

       

       
-

       
		n.pages.Error500(w)


     

       

       
71

       
+

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


     

       
72

       
72

       
 

       
		return


     

       
73

       
73

       
 

       
	}


     

       
74

       
74
+12 -8
appview/pages/pages.go 
···

       
1437

       
1437

       
 

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


     

       
1438

       
1438

       
 

       
}


     

       
1439

       
1439

       
 

       



     

       
1440

       

       
-

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


     

       
1441

       

       
-

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


     

       

       
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)


     

       
1442

       
1446

       
 

       
}


     

       
1443

       
1447

       
 

       



     

       
1444

       

       
-

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


     

       
1445

       

       
-

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


     

       

       
1448

       
+

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


     

       

       
1449

       
+

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


     

       
1446

       
1450

       
 

       
}


     

       
1447

       
1451

       
 

       



     

       
1448

       

       
-

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


     

       
1449

       

       
-

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


     

       

       
1452

       
+

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


     

       

       
1453

       
+

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


     

       
1450

       
1454

       
 

       
}


     

       
1451

       
1455

       
 

       



     

       
1452

       

       
-

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


     

       
1453

       

       
-

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


     

       

       
1456

       
+

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


     

       

       
1457

       
+

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


     

       
1454

       
1458

       
 

       
}
+10 -10
appview/pulls/pulls.go 
···

       
211

       
211

       
 

       
	)


     

       
212

       
212

       
 

       
	if err != nil {


     

       
213

       
213

       
 

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


     

       
214

       

       
-

       
		s.pages.Error503(w)


     

       

       
214

       
+

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


     

       
215

       
215

       
 

       
		return


     

       
216

       
216

       
 

       
	}


     

       
217

       
217

       
 

       



     
···

       
671

       
671

       
 

       
	)


     

       
672

       
672

       
 

       
	if err != nil {


     

       
673

       
673

       
 

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


     

       
674

       

       
-

       
		s.pages.Error503(w)


     

       

       
674

       
+

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


     

       
675

       
675

       
 

       
		return


     

       
676

       
676

       
 

       
	}


     

       
677

       
677

       
 

       



     
···

       
831

       
831

       
 

       
		if err != nil {


     

       
832

       
832

       
 

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


     

       
833

       
833

       
 

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


     

       
834

       

       
-

       
				s.pages.Error503(w)


     

       

       
834

       
+

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


     

       
835

       
835

       
 

       
				return


     

       
836

       
836

       
 

       
			}


     

       
837

       
837

       
 

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


     
···

       
841

       
841

       
 

       
		var result types.RepoBranchesResponse


     

       
842

       
842

       
 

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


     

       
843

       
843

       
 

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


     

       
844

       

       
-

       
			s.pages.Error503(w)


     

       

       
844

       
+

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


     

       
845

       
845

       
 

       
			return


     

       
846

       
846

       
 

       
		}


     

       
847

       
847

       
 

       



     
···

       
1438

       
1438

       
 

       
	if err != nil {


     

       
1439

       
1439

       
 

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


     

       
1440

       
1440

       
 

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


     

       
1441

       

       
-

       
			s.pages.Error503(w)


     

       

       
1441

       
+

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


     

       
1442

       
1442

       
 

       
			return


     

       
1443

       
1443

       
 

       
		}


     

       
1444

       
1444

       
 

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


     
···

       
1448

       
1448

       
 

       
	var result types.RepoBranchesResponse


     

       
1449

       
1449

       
 

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


     

       
1450

       
1450

       
 

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


     

       
1451

       

       
-

       
		s.pages.Error503(w)


     

       

       
1451

       
+

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


     

       
1452

       
1452

       
 

       
		return


     

       
1453

       
1453

       
 

       
	}


     

       
1454

       
1454

       
 

       



     
···

       
1530

       
1530

       
 

       
	if err != nil {


     

       
1531

       
1531

       
 

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


     

       
1532

       
1532

       
 

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


     

       
1533

       

       
-

       
			s.pages.Error503(w)


     

       

       
1533

       
+

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


     

       
1534

       
1534

       
 

       
			return


     

       
1535

       
1535

       
 

       
		}


     

       
1536

       
1536

       
 

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


     
···

       
1541

       
1541

       
 

       
	var sourceBranches types.RepoBranchesResponse


     

       
1542

       
1542

       
 

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


     

       
1543

       
1543

       
 

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


     

       
1544

       

       
-

       
		s.pages.Error503(w)


     

       

       
1544

       
+

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


     

       
1545

       
1545

       
 

       
		return


     

       
1546

       
1546

       
 

       
	}


     

       
1547

       
1547

       
 

       



     
···

       
1559

       
1559

       
 

       
	if err != nil {


     

       
1560

       
1560

       
 

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


     

       
1561

       
1561

       
 

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


     

       
1562

       

       
-

       
			s.pages.Error503(w)


     

       

       
1562

       
+

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


     

       
1563

       
1563

       
 

       
			return


     

       
1564

       
1564

       
 

       
		}


     

       
1565

       
1565

       
 

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


     
···

       
1570

       
1570

       
 

       
	var targetBranches types.RepoBranchesResponse


     

       
1571

       
1571

       
 

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


     

       
1572

       
1572

       
 

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


     

       
1573

       

       
-

       
		s.pages.Error503(w)


     

       

       
1573

       
+

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


     

       
1574

       
1574

       
 

       
		return


     

       
1575

       
1575

       
 

       
	}


     

       
1576

       
1576
+2 -1
appview/repo/archive.go 
···

       
7

       
7

       
 

       
	"strings"


     

       
8

       
8

       
 

       



     

       
9

       
9

       
 

       
	"tangled.org/core/api/tangled"


     

       

       
10

       
+

       
	"tangled.org/core/appview/pages"


     

       
10

       
11

       
 

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


     

       
11

       
12

       
 

       



     

       
12

       
13

       
 

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


     
···

       
35

       
36

       
 

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


     

       
36

       
37

       
 

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


     

       
37

       
38

       
 

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


     

       
38

       

       
-

       
		rp.pages.Error503(w)


     

       

       
39

       
+

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


     

       
39

       
40

       
 

       
		return


     

       
40

       
41

       
 

       
	}


     

       
41

       
42

       
 

       
	// Set headers for file download, just pass along whatever the knot specifies
+3 -4
appview/repo/blob.go 
···

       
33

       
33

       
 

       
// - rest      :      |          |


     

       
34

       
34

       
 

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


     

       
35

       
35

       
 

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


     

       

       
36

       
+

       
	user := rp.oauth.GetUser(r)


     

       
36

       
37

       
 

       



     

       
37

       
38

       
 

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


     

       
38

       
39

       
 

       
	if err != nil {


     
···

       
58

       
59

       
 

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


     

       
59

       
60

       
 

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


     

       
60

       
61

       
 

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


     

       
61

       

       
-

       
		rp.pages.Error503(w)


     

       

       
62

       
+

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


     

       
62

       
63

       
 

       
		return


     

       
63

       
64

       
 

       
	}


     

       
64

       
65

       
 

       



     
···

       
74

       
75

       
 

       
	// Create the blob view


     

       
75

       
76

       
 

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


     

       
76

       
77

       
 

       



     

       
77

       

       
-

       
	user := rp.oauth.GetUser(r)


     

       
78

       

       
-

       



     

       
79

       
78

       
 

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


     

       
80

       
79

       
 

       
		LoggedInUser:    user,


     

       
81

       
80

       
 

       
		RepoInfo:        f.RepoInfo(user),


     
···

       
133

       
132

       
 

       
	resp, err := client.Do(req)


     

       
134

       
133

       
 

       
	if err != nil {


     

       
135

       
134

       
 

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


     

       
136

       

       
-

       
		rp.pages.Error503(w)


     

       

       
135

       
+

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


     

       
137

       
136

       
 

       
		return


     

       
138

       
137

       
 

       
	}


     

       
139

       
138
+3 -3
appview/repo/branches.go 
···

       
16

       
16

       
 

       



     

       
17

       
17

       
 

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


     

       
18

       
18

       
 

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


     

       

       
19

       
+

       
	user := rp.oauth.GetUser(r)


     

       
19

       
20

       
 

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


     

       
20

       
21

       
 

       
	if err != nil {


     

       
21

       
22

       
 

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


     
···

       
33

       
34

       
 

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


     

       
34

       
35

       
 

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


     

       
35

       
36

       
 

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


     

       
36

       

       
-

       
		rp.pages.Error503(w)


     

       

       
37

       
+

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


     

       
37

       
38

       
 

       
		return


     

       
38

       
39

       
 

       
	}


     

       
39

       
40

       
 

       
	var result types.RepoBranchesResponse


     

       
40

       
41

       
 

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


     

       
41

       
42

       
 

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


     

       
42

       

       
-

       
		rp.pages.Error503(w)


     

       

       
43

       
+

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


     

       
43

       
44

       
 

       
		return


     

       
44

       
45

       
 

       
	}


     

       
45

       
46

       
 

       
	sortBranches(result.Branches)


     

       
46

       

       
-

       
	user := rp.oauth.GetUser(r)


     

       
47

       
47

       
 

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


     

       
48

       
48

       
 

       
		LoggedInUser:         user,


     

       
49

       
49

       
 

       
		RepoInfo:             f.RepoInfo(user),
+6 -6
appview/repo/compare.go 
···

       
40

       
40

       
 

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


     

       
41

       
41

       
 

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


     

       
42

       
42

       
 

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


     

       
43

       

       
-

       
		rp.pages.Error503(w)


     

       

       
43

       
+

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


     

       
44

       
44

       
 

       
		return


     

       
45

       
45

       
 

       
	}


     

       
46

       
46

       
 

       



     
···

       
77

       
77

       
 

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


     

       
78

       
78

       
 

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


     

       
79

       
79

       
 

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


     

       
80

       

       
-

       
		rp.pages.Error503(w)


     

       

       
80

       
+

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


     

       
81

       
81

       
 

       
		return


     

       
82

       
82

       
 

       
	}


     

       
83

       
83

       
 

       



     
···

       
138

       
138

       
 

       



     

       
139

       
139

       
 

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


     

       
140

       
140

       
 

       
		l.Error("invalid comparison")


     

       
141

       

       
-

       
		rp.pages.Error404(w)


     

       

       
141

       
+

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


     

       
142

       
142

       
 

       
		return


     

       
143

       
143

       
 

       
	}


     

       
144

       
144

       
 

       



     
···

       
156

       
156

       
 

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


     

       
157

       
157

       
 

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


     

       
158

       
158

       
 

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


     

       
159

       

       
-

       
		rp.pages.Error503(w)


     

       

       
159

       
+

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


     

       
160

       
160

       
 

       
		return


     

       
161

       
161

       
 

       
	}


     

       
162

       
162

       
 

       



     
···

       
170

       
170

       
 

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


     

       
171

       
171

       
 

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


     

       
172

       
172

       
 

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


     

       
173

       

       
-

       
		rp.pages.Error503(w)


     

       

       
173

       
+

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


     

       
174

       
174

       
 

       
		return


     

       
175

       
175

       
 

       
	}


     

       
176

       
176

       
 

       



     
···

       
184

       
184

       
 

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


     

       
185

       
185

       
 

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


     

       
186

       
186

       
 

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


     

       
187

       

       
-

       
		rp.pages.Error503(w)


     

       

       
187

       
+

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


     

       
188

       
188

       
 

       
		return


     

       
189

       
189

       
 

       
	}


     

       
190

       
190
+3 -2
appview/repo/feed.go 
···

       
10

       
10

       
 

       



     

       
11

       
11

       
 

       
	"tangled.org/core/appview/db"


     

       
12

       
12

       
 

       
	"tangled.org/core/appview/models"


     

       

       
13

       
+

       
	"tangled.org/core/appview/pages"


     

       
13

       
14

       
 

       
	"tangled.org/core/appview/pagination"


     

       
14

       
15

       
 

       
	"tangled.org/core/appview/reporesolver"


     

       
15

       
16

       
 

       



     
···

       
156

       
157

       
 

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


     

       
157

       
158

       
 

       
	if err != nil {


     

       
158

       
159

       
 

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


     

       
159

       

       
-

       
		rp.pages.Error500(w)


     

       

       
160

       
+

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


     

       
160

       
161

       
 

       
		return


     

       
161

       
162

       
 

       
	}


     

       
162

       
163

       
 

       



     

       
163

       
164

       
 

       
	atom, err := feed.ToAtom()


     

       
164

       
165

       
 

       
	if err != nil {


     

       
165

       

       
-

       
		rp.pages.Error500(w)


     

       

       
166

       
+

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


     

       
166

       
167

       
 

       
		return


     

       
167

       
168

       
 

       
	}


     

       
168

       
169
+1 -1
appview/repo/index.go 
···

       
67

       
67

       
 

       
			return


     

       
68

       
68

       
 

       
		}


     

       
69

       
69

       
 

       



     

       
70

       

       
-

       
		rp.pages.Error503(w)


     

       

       
70

       
+

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


     

       
71

       
71

       
 

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


     

       
72

       
72

       
 

       
		return


     

       
73

       
73

       
 

       
	}
+9 -10
appview/repo/log.go 
···

       
22

       
22

       
 

       



     

       
23

       
23

       
 

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


     

       
24

       
24

       
 

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


     

       

       
25

       
+

       
	user := rp.oauth.GetUser(r)


     

       
25

       
26

       
 

       



     

       
26

       
27

       
 

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


     

       
27

       
28

       
 

       
	if err != nil {


     
···

       
61

       
62

       
 

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


     

       
62

       
63

       
 

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


     

       
63

       
64

       
 

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


     

       
64

       

       
-

       
		rp.pages.Error503(w)


     

       

       
65

       
+

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


     

       
65

       
66

       
 

       
		return


     

       
66

       
67

       
 

       
	}


     

       
67

       
68

       
 

       



     

       
68

       
69

       
 

       
	var xrpcResp types.RepoLogResponse


     

       
69

       
70

       
 

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


     

       
70

       
71

       
 

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


     

       
71

       

       
-

       
		rp.pages.Error503(w)


     

       

       
72

       
+

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


     

       
72

       
73

       
 

       
		return


     

       
73

       
74

       
 

       
	}


     

       
74

       
75

       
 

       



     

       
75

       
76

       
 

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


     

       
76

       
77

       
 

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


     

       
77

       
78

       
 

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


     

       
78

       

       
-

       
		rp.pages.Error503(w)


     

       

       
79

       
+

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


     

       
79

       
80

       
 

       
		return


     

       
80

       
81

       
 

       
	}


     

       
81

       
82

       
 

       



     
···

       
96

       
97

       
 

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


     

       
97

       
98

       
 

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


     

       
98

       
99

       
 

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


     

       
99

       

       
-

       
		rp.pages.Error503(w)


     

       

       
100

       
+

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


     

       
100

       
101

       
 

       
		return


     

       
101

       
102

       
 

       
	}


     

       
102

       
103

       
 

       



     
···

       
109

       
110

       
 

       
		}


     

       
110

       
111

       
 

       
	}


     

       
111

       
112

       
 

       



     

       
112

       

       
-

       
	user := rp.oauth.GetUser(r)


     

       
113

       

       
-

       



     

       
114

       
113

       
 

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


     

       
115

       
114

       
 

       
	if err != nil {


     

       
116

       
115

       
 

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


     
···

       
146

       
145

       
 

       



     

       
147

       
146

       
 

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


     

       
148

       
147

       
 

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


     

       

       
148

       
+

       
	user := rp.oauth.GetUser(r)


     

       
149

       
149

       
 

       



     

       
150

       
150

       
 

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


     

       
151

       
151

       
 

       
	if err != nil {


     
···

       
161

       
161

       
 

       
	}


     

       
162

       
162

       
 

       



     

       
163

       
163

       
 

       
	if !plumbing.IsHash(ref) {


     

       
164

       

       
-

       
		rp.pages.Error404(w)


     

       

       
164

       
+

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


     

       
165

       
165

       
 

       
		return


     

       
166

       
166

       
 

       
	}


     

       
167

       
167

       
 

       



     
···

       
178

       
178

       
 

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


     

       
179

       
179

       
 

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


     

       
180

       
180

       
 

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


     

       
181

       

       
-

       
		rp.pages.Error503(w)


     

       

       
181

       
+

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


     

       
182

       
182

       
 

       
		return


     

       
183

       
183

       
 

       
	}


     

       
184

       
184

       
 

       



     

       
185

       
185

       
 

       
	var result types.RepoCommitResponse


     

       
186

       
186

       
 

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


     

       
187

       
187

       
 

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


     

       
188

       

       
-

       
		rp.pages.Error503(w)


     

       

       
188

       
+

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


     

       
189

       
189

       
 

       
		return


     

       
190

       
190

       
 

       
	}


     

       
191

       
191

       
 

       



     
···

       
199

       
199

       
 

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


     

       
200

       
200

       
 

       
	}


     

       
201

       
201

       
 

       



     

       
202

       

       
-

       
	user := rp.oauth.GetUser(r)


     

       
203

       
202

       
 

       
	repoInfo := f.RepoInfo(user)


     

       
204

       
203

       
 

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


     

       
205

       
204

       
 

       
	if err != nil {
+4 -4
appview/repo/settings.go 
···

       
198

       
198

       
 

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


     

       
199

       
199

       
 

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


     

       
200

       
200

       
 

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


     

       
201

       

       
-

       
		rp.pages.Error503(w)


     

       

       
201

       
+

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


     

       
202

       
202

       
 

       
		return


     

       
203

       
203

       
 

       
	}


     

       
204

       
204

       
 

       



     

       
205

       
205

       
 

       
	var result types.RepoBranchesResponse


     

       
206

       
206

       
 

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


     

       
207

       
207

       
 

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


     

       
208

       

       
-

       
		rp.pages.Error503(w)


     

       

       
208

       
+

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


     

       
209

       
209

       
 

       
		return


     

       
210

       
210

       
 

       
	}


     

       
211

       
211

       
 

       



     

       
212

       
212

       
 

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


     

       
213

       
213

       
 

       
	if err != nil {


     

       
214

       
214

       
 

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


     

       
215

       

       
-

       
		rp.pages.Error503(w)


     

       

       
215

       
+

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


     

       
216

       
216

       
 

       
		return


     

       
217

       
217

       
 

       
	}


     

       
218

       
218

       
 

       



     

       
219

       
219

       
 

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


     

       
220

       
220

       
 

       
	if err != nil {


     

       
221

       
221

       
 

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


     

       
222

       

       
-

       
		rp.pages.Error503(w)


     

       

       
222

       
+

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


     

       
223

       
223

       
 

       
		return


     

       
224

       
224

       
 

       
	}


     

       
225

       
225

       
 

       
	// remove default labels from the labels list, if present
+3 -3
appview/repo/tags.go 
···

       
18

       
18

       
 

       



     

       
19

       
19

       
 

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


     

       
20

       
20

       
 

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


     

       

       
21

       
+

       
	user := rp.oauth.GetUser(r)


     

       
21

       
22

       
 

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


     

       
22

       
23

       
 

       
	if err != nil {


     

       
23

       
24

       
 

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


     
···

       
35

       
36

       
 

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


     

       
36

       
37

       
 

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


     

       
37

       
38

       
 

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


     

       
38

       

       
-

       
		rp.pages.Error503(w)


     

       

       
39

       
+

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


     

       
39

       
40

       
 

       
		return


     

       
40

       
41

       
 

       
	}


     

       
41

       
42

       
 

       
	var result types.RepoTagsResponse


     

       
42

       
43

       
 

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


     

       
43

       
44

       
 

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


     

       
44

       

       
-

       
		rp.pages.Error503(w)


     

       

       
45

       
+

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


     

       
45

       
46

       
 

       
		return


     

       
46

       
47

       
 

       
	}


     

       
47

       
48

       
 

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


     
···

       
68

       
69

       
 

       
			danglingArtifacts = append(danglingArtifacts, a)


     

       
69

       
70

       
 

       
		}


     

       
70

       
71

       
 

       
	}


     

       
71

       

       
-

       
	user := rp.oauth.GetUser(r)


     

       
72

       
72

       
 

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


     

       
73

       
73

       
 

       
		LoggedInUser:      user,


     

       
74

       
74

       
 

       
		RepoInfo:          f.RepoInfo(user),
+2 -2
appview/repo/tree.go 
···

       
19

       
19

       
 

       



     

       
20

       
20

       
 

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


     

       
21

       
21

       
 

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


     

       

       
22

       
+

       
	user := rp.oauth.GetUser(r)


     

       
22

       
23

       
 

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


     

       
23

       
24

       
 

       
	if err != nil {


     

       
24

       
25

       
 

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


     
···

       
43

       
44

       
 

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


     

       
44

       
45

       
 

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


     

       
45

       
46

       
 

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


     

       
46

       

       
-

       
		rp.pages.Error503(w)


     

       

       
47

       
+

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


     

       
47

       
48

       
 

       
		return


     

       
48

       
49

       
 

       
	}


     

       
49

       
50

       
 

       
	// Convert XRPC response to internal types.RepoTreeResponse


     
···

       
86

       
87

       
 

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


     

       
87

       
88

       
 

       
		return


     

       
88

       
89

       
 

       
	}


     

       
89

       

       
-

       
	user := rp.oauth.GetUser(r)


     

       
90

       
90

       
 

       
	var breadcrumbs [][]string


     

       
91

       
91

       
 

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


     

       
92

       
92

       
 

       
	if treePath != "" {
+3 -3
appview/state/gfi.go 
···

       
23

       
23

       
 

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


     

       
24

       
24

       
 

       
	if err != nil {


     

       
25

       
25

       
 

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


     

       
26

       

       
-

       
		s.pages.Error500(w)


     

       

       
26

       
+

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


     

       
27

       
27

       
 

       
		return


     

       
28

       
28

       
 

       
	}


     

       
29

       
29

       
 

       



     

       
30

       
30

       
 

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


     

       
31

       
31

       
 

       
	if err != nil {


     

       
32

       
32

       
 

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


     

       
33

       

       
-

       
		s.pages.Error503(w)


     

       

       
33

       
+

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


     

       
34

       
34

       
 

       
		return


     

       
35

       
35

       
 

       
	}


     

       
36

       
36

       
 

       



     
···

       
60

       
60

       
 

       
	)


     

       
61

       
61

       
 

       
	if err != nil {


     

       
62

       
62

       
 

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


     

       
63

       

       
-

       
		s.pages.Error503(w)


     

       

       
63

       
+

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


     

       
64

       
64

       
 

       
		return


     

       
65

       
65

       
 

       
	}


     

       
66

       
66
+18 -14
appview/state/profile.go 
···

       
112

       
112

       
 

       



     

       
113

       
113

       
 

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


     

       
114

       
114

       
 

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


     

       

       
115

       
+

       
	user := s.oauth.GetUser(r)


     

       
115

       
116

       
 

       



     

       
116

       
117

       
 

       
	profile, err := s.profile(r)


     

       
117

       
118

       
 

       
	if err != nil {


     

       
118

       
119

       
 

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


     

       
119

       

       
-

       
		s.pages.Error500(w)


     

       

       
120

       
+

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


     

       
120

       
121

       
 

       
		return


     

       
121

       
122

       
 

       
	}


     

       
122

       
123

       
 

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


     
···

       
163

       
164

       
 

       
	}


     

       
164

       
165

       
 

       



     

       
165

       
166

       
 

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


     

       
166

       

       
-

       
		LoggedInUser:       s.oauth.GetUser(r),


     

       

       
167

       
+

       
		LoggedInUser:       user,


     

       
167

       
168

       
 

       
		Card:               profile,


     

       
168

       
169

       
 

       
		Repos:              pinnedRepos,


     

       
169

       
170

       
 

       
		CollaboratingRepos: pinnedCollaboratingRepos,


     
···

       
173

       
174

       
 

       



     

       
174

       
175

       
 

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


     

       
175

       
176

       
 

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


     

       

       
177

       
+

       
	user := s.oauth.GetUser(r)


     

       
176

       
178

       
 

       



     

       
177

       
179

       
 

       
	profile, err := s.profile(r)


     

       
178

       
180

       
 

       
	if err != nil {


     

       
179

       
181

       
 

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


     

       
180

       

       
-

       
		s.pages.Error500(w)


     

       

       
182

       
+

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


     

       
181

       
183

       
 

       
		return


     

       
182

       
184

       
 

       
	}


     

       
183

       
185

       
 

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


     
···

       
189

       
191

       
 

       
	)


     

       
190

       
192

       
 

       
	if err != nil {


     

       
191

       
193

       
 

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


     

       
192

       

       
-

       
		s.pages.Error500(w)


     

       

       
194

       
+

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


     

       
193

       
195

       
 

       
		return


     

       
194

       
196

       
 

       
	}


     

       
195

       
197

       
 

       



     

       
196

       
198

       
 

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


     

       
197

       

       
-

       
		LoggedInUser: s.oauth.GetUser(r),


     

       

       
199

       
+

       
		LoggedInUser: user,


     

       
198

       
200

       
 

       
		Repos:        repos,


     

       
199

       
201

       
 

       
		Card:         profile,


     

       
200

       
202

       
 

       
	})


     
···

       
202

       
204

       
 

       



     

       
203

       
205

       
 

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


     

       
204

       
206

       
 

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


     

       

       
207

       
+

       
	user := s.oauth.GetUser(r)


     

       
205

       
208

       
 

       



     

       
206

       
209

       
 

       
	profile, err := s.profile(r)


     

       
207

       
210

       
 

       
	if err != nil {


     

       
208

       
211

       
 

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


     

       
209

       

       
-

       
		s.pages.Error500(w)


     

       

       
212

       
+

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


     

       
210

       
213

       
 

       
		return


     

       
211

       
214

       
 

       
	}


     

       
212

       
215

       
 

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


     
···

       
214

       
217

       
 

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


     

       
215

       
218

       
 

       
	if err != nil {


     

       
216

       
219

       
 

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


     

       
217

       

       
-

       
		s.pages.Error500(w)


     

       

       
220

       
+

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


     

       
218

       
221

       
 

       
		return


     

       
219

       
222

       
 

       
	}


     

       
220

       
223

       
 

       
	var repos []models.Repo


     
···

       
223

       
226

       
 

       
	}


     

       
224

       
227

       
 

       



     

       
225

       
228

       
 

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


     

       
226

       

       
-

       
		LoggedInUser: s.oauth.GetUser(r),


     

       

       
229

       
+

       
		LoggedInUser: user,


     

       
227

       
230

       
 

       
		Repos:        repos,


     

       
228

       
231

       
 

       
		Card:         profile,


     

       
229

       
232

       
 

       
	})


     
···

       
231

       
234

       
 

       



     

       
232

       
235

       
 

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


     

       
233

       
236

       
 

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


     

       

       
237

       
+

       
	user := s.oauth.GetUser(r)


     

       
234

       
238

       
 

       



     

       
235

       
239

       
 

       
	profile, err := s.profile(r)


     

       
236

       
240

       
 

       
	if err != nil {


     

       
237

       
241

       
 

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


     

       
238

       

       
-

       
		s.pages.Error500(w)


     

       

       
242

       
+

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


     

       
239

       
243

       
 

       
		return


     

       
240

       
244

       
 

       
	}


     

       
241

       
245

       
 

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


     
···

       
243

       
247

       
 

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


     

       
244

       
248

       
 

       
	if err != nil {


     

       
245

       
249

       
 

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


     

       
246

       

       
-

       
		s.pages.Error500(w)


     

       

       
250

       
+

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


     

       
247

       
251

       
 

       
		return


     

       
248

       
252

       
 

       
	}


     

       
249

       
253

       
 

       



     

       
250

       
254

       
 

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


     

       
251

       

       
-

       
		LoggedInUser: s.oauth.GetUser(r),


     

       

       
255

       
+

       
		LoggedInUser: user,


     

       
252

       
256

       
 

       
		Strings:      strings,


     

       
253

       
257

       
 

       
		Card:         profile,


     

       
254

       
258

       
 

       
	})


     
···

       
379

       
383

       
 

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


     

       
380

       
384

       
 

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


     

       
381

       
385

       
 

       
	if !ok {


     

       
382

       

       
-

       
		s.pages.Error404(w)


     

       

       
386

       
+

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


     

       
383

       
387

       
 

       
		return


     

       
384

       
388

       
 

       
	}


     

       
385

       
389

       
 

       



     

       
386

       
390

       
 

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


     

       
387

       
391

       
 

       
	if err != nil {


     

       
388

       

       
-

       
		s.pages.Error500(w)


     

       

       
392

       
+

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


     

       
389

       
393

       
 

       
		return


     

       
390

       
394

       
 

       
	}


     

       
391

       
395

       
 

       



     
···

       
395

       
399

       
 

       



     

       
396

       
400

       
 

       
	atom, err := feed.ToAtom()


     

       
397

       
401

       
 

       
	if err != nil {


     

       
398

       

       
-

       
		s.pages.Error500(w)


     

       

       
402

       
+

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


     

       
399

       
403

       
 

       
		return


     

       
400

       
404

       
 

       
	}


     

       
401

       
405
+3 -2
appview/state/router.go 
···

       
10

       
10

       
 

       
	"tangled.org/core/appview/labels"


     

       
11

       
11

       
 

       
	"tangled.org/core/appview/middleware"


     

       
12

       
12

       
 

       
	"tangled.org/core/appview/notifications"


     

       

       
13

       
+

       
	"tangled.org/core/appview/pages"


     

       
13

       
14

       
 

       
	"tangled.org/core/appview/pipelines"


     

       
14

       
15

       
 

       
	"tangled.org/core/appview/pulls"


     

       
15

       
16

       
 

       
	"tangled.org/core/appview/repo"


     
···

       
108

       
109

       
 

       
	})


     

       
109

       
110

       
 

       



     

       
110

       
111

       
 

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


     

       
111

       

       
-

       
		s.pages.Error404(w)


     

       

       
112

       
+

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


     

       
112

       
113

       
 

       
	})


     

       
113

       
114

       
 

       



     

       
114

       
115

       
 

       
	return r


     
···

       
179

       
180

       
 

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


     

       
180

       
181

       
 

       



     

       
181

       
182

       
 

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


     

       
182

       

       
-

       
		s.pages.Error404(w)


     

       

       
183

       
+

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


     

       
183

       
184

       
 

       
	})


     

       
184

       
185

       
 

       
	return r


     

       
185

       
186

       
 

       
}
+2 -2
appview/strings/strings.go 
···

       
88

       
88

       
 

       



     

       
89

       
89

       
 

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


     

       
90

       
90

       
 

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


     

       

       
91

       
+

       
	user := s.OAuth.GetUser(r)


     

       
91

       
92

       
 

       



     

       
92

       
93

       
 

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


     

       
93

       
94

       
 

       
	if !ok {


     
···

       
118

       
119

       
 

       
	}


     

       
119

       
120

       
 

       
	if len(strings) < 1 {


     

       
120

       
121

       
 

       
		l.Error("string not found")


     

       
121

       

       
-

       
		s.Pages.Error404(w)


     

       

       
122

       
+

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


     

       
122

       
123

       
 

       
		return


     

       
123

       
124

       
 

       
	}


     

       
124

       
125

       
 

       
	if len(strings) != 1 {


     
···

       
152

       
153

       
 

       
	if err != nil {


     

       
153

       
154

       
 

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


     

       
154

       
155

       
 

       
	}


     

       
155

       

       
-

       
	user := s.OAuth.GetUser(r)


     

       
156

       
156

       
 

       
	isStarred := false


     

       
157

       
157

       
 

       
	if user != nil {


     

       
158

       
158

       
 

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