appview/pages: include LoggedInUser on error pages

Signed-off-by: Thomas Karpiniec <[e-mail]>

appview/issues/issues.go

···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	)
 	if err != nil {
 		l.Error("failed to fetch labels", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
 		l.Error("failed to get issue")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	)
 	if err != nil {
 		l.Error("failed to fetch labels", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 

appview/middleware/middleware.go

···
 			if err != nil {
 				// invalid did or handle
 				log.Printf("failed to resolve did/handle '%s': %s\n", didOrHandle, err)
-				mw.pages.Error404(w)
+				mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(req)})
 				return
 			}
 
···
 			)
 			if err != nil {
 				log.Println("failed to resolve repo", "err", err)
-				mw.pages.ErrorKnot404(w)
+				mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(req)})
 				return
 			}
 
···
 			f, err := mw.repoResolver.Resolve(r)
 			if err != nil {
 				log.Println("failed to fully resolve repo", err)
-				mw.pages.ErrorKnot404(w)
+				mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})
 				return
 			}
 
···
 			prIdInt, err := strconv.Atoi(prId)
 			if err != nil {
 				log.Println("failed to parse pr id", err)
-				mw.pages.Error404(w)
+				mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})
 				return
 			}
 
 			pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt)
 			if err != nil {
 				log.Println("failed to get pull and comments", err)
-				mw.pages.Error404(w)
+				mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})
 				return
 			}
 
···
 		f, err := mw.repoResolver.Resolve(r)
 		if err != nil {
 			log.Println("failed to fully resolve repo", err)
-			mw.pages.ErrorKnot404(w)
+			mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})
 			return
 		}
 
···
 		issueId, err := strconv.Atoi(issueIdStr)
 		if err != nil {
 			log.Println("failed to fully resolve issue ID", err)
-			mw.pages.Error404(w)
+			mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})
 			return
 		}
 
 		issue, err := db.GetIssue(mw.db, f.RepoAt(), issueId)
 		if err != nil {
 			log.Println("failed to get issues", "err", err)
-			mw.pages.Error404(w)
+			mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})
 			return
 		}
 
···
 			f, err := mw.repoResolver.Resolve(r)
 			if err != nil {
 				log.Println("failed to fully resolve repo", err)
-				mw.pages.ErrorKnot404(w)
+				mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)})
 				return
 			}
 

appview/notifications/notifications.go

···
 	)
 	if err != nil {
 		l.Error("failed to get total notifications", "err", err)
-		n.pages.Error500(w)
+		n.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	)
 	if err != nil {
 		l.Error("failed to get notifications", "err", err)
-		n.pages.Error500(w)
+		n.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 

appview/pages/pages.go

···
 	return hex.EncodeToString(hasher.Sum(nil))[:8] // Use first 8 chars of hash
 }
 
-func (p *Pages) Error500(w io.Writer) error {
-	return p.execute("errors/500", w, nil)
+type ErrorPageParams struct {
+	LoggedInUser *oauth.User
 }
 
-func (p *Pages) Error404(w io.Writer) error {
-	return p.execute("errors/404", w, nil)
+func (p *Pages) Error500(w io.Writer, params ErrorPageParams) error {
+	return p.execute("errors/500", w, params)
 }
 
-func (p *Pages) ErrorKnot404(w io.Writer) error {
-	return p.execute("errors/knot404", w, nil)
+func (p *Pages) Error404(w io.Writer, params ErrorPageParams) error {
+	return p.execute("errors/404", w, params)
 }
 
-func (p *Pages) Error503(w io.Writer) error {
-	return p.execute("errors/503", w, nil)
+func (p *Pages) ErrorKnot404(w io.Writer, params ErrorPageParams) error {
+	return p.execute("errors/knot404", w, params)
+}
+
+func (p *Pages) Error503(w io.Writer, params ErrorPageParams) error {
+	return p.execute("errors/503", w, params)
 }

appview/pulls/pulls.go

···
 	)
 	if err != nil {
 		log.Println("failed to fetch labels", err)
-		s.pages.Error503(w)
+		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	)
 	if err != nil {
 		log.Println("failed to fetch labels", err)
-		s.pages.Error503(w)
+		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 		if err != nil {
 			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 				log.Println("failed to call XRPC repo.branches", xrpcerr)
-				s.pages.Error503(w)
+				s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 				return
 			}
 			log.Println("failed to fetch branches", err)
···
 		var result types.RepoBranchesResponse
 		if err := json.Unmarshal(xrpcBytes, &result); err != nil {
 			log.Println("failed to decode XRPC response", err)
-			s.pages.Error503(w)
+			s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 			return
 		}
 
···
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 			log.Println("failed to call XRPC repo.branches", xrpcerr)
-			s.pages.Error503(w)
+			s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 			return
 		}
 		log.Println("failed to fetch branches", err)
···
 	var result types.RepoBranchesResponse
 	if err := json.Unmarshal(xrpcBytes, &result); err != nil {
 		log.Println("failed to decode XRPC response", err)
-		s.pages.Error503(w)
+		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 			log.Println("failed to call XRPC repo.branches for source", xrpcerr)
-			s.pages.Error503(w)
+			s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 			return
 		}
 		log.Println("failed to fetch source branches", err)
···
 	var sourceBranches types.RepoBranchesResponse
 	if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {
 		log.Println("failed to decode source branches XRPC response", err)
-		s.pages.Error503(w)
+		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 			log.Println("failed to call XRPC repo.branches for target", xrpcerr)
-			s.pages.Error503(w)
+			s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 			return
 		}
 		log.Println("failed to fetch target branches", err)
···
 	var targetBranches types.RepoBranchesResponse
 	if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {
 		log.Println("failed to decode target branches XRPC response", err)
-		s.pages.Error503(w)
+		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 

appview/repo/archive.go

···
 	"strings"
 
 	"tangled.org/core/api/tangled"
+	"tangled.org/core/appview/pages"
 	xrpcclient "tangled.org/core/appview/xrpcclient"
 
 	indigoxrpc "github.com/bluesky-social/indigo/xrpc"
···
 	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: rp.oauth.GetUser(r)})
 		return
 	}
 	// Set headers for file download, just pass along whatever the knot specifies

appview/repo/blob.go

···
 // - rest      :      |          |
 func (rp *Repo) Blob(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "RepoBlob")
+	user := rp.oauth.GetUser(r)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 
 	// Create the blob view
 	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())
-
-	user := rp.oauth.GetUser(r)
 
 	rp.pages.RepoBlob(w, pages.RepoBlobParams{
 		LoggedInUser:    user,
···
 	resp, err := client.Do(req)
 	if err != nil {
 		l.Error("failed to reach knotserver", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: rp.oauth.GetUser(r)})
 		return
 	}
 

appview/repo/branches.go

···
 
 func (rp *Repo) Branches(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "RepoBranches")
+	user := rp.oauth.GetUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	var result types.RepoBranchesResponse
 	if err := json.Unmarshal(xrpcBytes, &result); err != nil {
 		l.Error("failed to decode XRPC response", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	sortBranches(result.Branches)
-	user := rp.oauth.GetUser(r)
 	rp.pages.RepoBranches(w, pages.RepoBranchesParams{
 		LoggedInUser:         user,
 		RepoInfo:             f.RepoInfo(user),

appview/repo/compare.go

···
 	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 
 	if base == "" || head == "" {
 		l.Error("invalid comparison")
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.compare", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 

appview/repo/feed.go

···
 
 	"tangled.org/core/appview/db"
 	"tangled.org/core/appview/models"
+	"tangled.org/core/appview/pages"
 	"tangled.org/core/appview/pagination"
 	"tangled.org/core/appview/reporesolver"
 
···
 	feed, err := rp.getRepoFeed(r.Context(), f)
 	if err != nil {
 		log.Println("failed to get repo feed:", err)
-		rp.pages.Error500(w)
+		rp.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil})
 		return
 	}
 
 	atom, err := feed.ToAtom()
 	if err != nil {
-		rp.pages.Error500(w)
+		rp.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil})
 		return
 	}
 

appview/repo/index.go

···
 			return
 		}
 
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		l.Error("failed to build index response", "err", err)
 		return
 	}

appview/repo/log.go

···
 
 func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "RepoLog")
+	user := rp.oauth.GetUser(r)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.log", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
 	var xrpcResp types.RepoLogResponse
 	if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {
 		l.Error("failed to decode XRPC response", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
 	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 		}
 	}
 
-	user := rp.oauth.GetUser(r)
-
 	emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)
 	if err != nil {
 		l.Error("failed to fetch email to did mapping", "err", err)
···
 
 func (rp *Repo) Commit(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "RepoCommit")
+	user := rp.oauth.GetUser(r)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 	}
 
 	if !plumbing.IsHash(ref) {
-		rp.pages.Error404(w)
+		rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
 	var result types.RepoCommitResponse
 	if err := json.Unmarshal(xrpcBytes, &result); err != nil {
 		l.Error("failed to decode XRPC response", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 		l.Error("failed to GetVerifiedCommits", "err", err)
 	}
 
-	user := rp.oauth.GetUser(r)
 	repoInfo := f.RepoInfo(user)
 	pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})
 	if err != nil {

appview/repo/settings.go

···
 	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
 	var result types.RepoBranchesResponse
 	if err := json.Unmarshal(xrpcBytes, &result); err != nil {
 		l.Error("failed to decode XRPC response", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
 	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs))
 	if err != nil {
 		l.Error("failed to fetch labels", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
 	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))
 	if err != nil {
 		l.Error("failed to fetch labels", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	// remove default labels from the labels list, if present

appview/repo/tags.go

···
 
 func (rp *Repo) Tags(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "RepoTags")
+	user := rp.oauth.GetUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	var result types.RepoTagsResponse
 	if err := json.Unmarshal(xrpcBytes, &result); err != nil {
 		l.Error("failed to decode XRPC response", "err", err)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))
···
 			danglingArtifacts = append(danglingArtifacts, a)
 		}
 	}
-	user := rp.oauth.GetUser(r)
 	rp.pages.RepoTags(w, pages.RepoTagsParams{
 		LoggedInUser:      user,
 		RepoInfo:          f.RepoInfo(user),

appview/repo/tree.go

···
 
 func (rp *Repo) Tree(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "RepoTree")
+	user := rp.oauth.GetUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to fully resolve repo", "err", err)
···
 	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)
-		rp.pages.Error503(w)
+		rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	// Convert XRPC response to internal types.RepoTreeResponse
···
 		http.Redirect(w, r, redirectTo, http.StatusFound)
 		return
 	}
-	user := rp.oauth.GetUser(r)
 	var breadcrumbs [][]string
 	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})
 	if treePath != "" {

appview/state/gfi.go

···
 	gfiLabelDef, err := db.GetLabelDefinition(s.db, db.FilterEq("at_uri", goodFirstIssueLabel))
 	if err != nil {
 		log.Println("failed to get gfi label def", err)
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
 	repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel))
 	if err != nil {
 		log.Println("failed to get repo labels", err)
-		s.pages.Error503(w)
+		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
···
 	)
 	if err != nil {
 		log.Println("failed to get issues", err)
-		s.pages.Error503(w)
+		s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 

appview/state/profile.go

···
 
 func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) {
 	l := s.logger.With("handler", "profileHomePage")
+	user := s.oauth.GetUser(r)
 
 	profile, err := s.profile(r)
 	if err != nil {
 		l.Error("failed to build profile card", "err", err)
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
···
 	}
 
 	s.pages.ProfileOverview(w, pages.ProfileOverviewParams{
-		LoggedInUser:       s.oauth.GetUser(r),
+		LoggedInUser:       user,
 		Card:               profile,
 		Repos:              pinnedRepos,
 		CollaboratingRepos: pinnedCollaboratingRepos,
···
 
 func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
 	l := s.logger.With("handler", "reposPage")
+	user := s.oauth.GetUser(r)
 
 	profile, err := s.profile(r)
 	if err != nil {
 		l.Error("failed to build profile card", "err", err)
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
···
 	)
 	if err != nil {
 		l.Error("failed to get repos", "err", err)
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
 	err = s.pages.ProfileRepos(w, pages.ProfileReposParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: user,
 		Repos:        repos,
 		Card:         profile,
 	})
···
 
 func (s *State) starredPage(w http.ResponseWriter, r *http.Request) {
 	l := s.logger.With("handler", "starredPage")
+	user := s.oauth.GetUser(r)
 
 	profile, err := s.profile(r)
 	if err != nil {
 		l.Error("failed to build profile card", "err", err)
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
···
 	stars, err := db.GetRepoStars(s.db, 0, db.FilterEq("did", profile.UserDid))
 	if err != nil {
 		l.Error("failed to get stars", "err", err)
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	var repos []models.Repo
···
 	}
 
 	err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: user,
 		Repos:        repos,
 		Card:         profile,
 	})
···
 
 func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) {
 	l := s.logger.With("handler", "stringsPage")
+	user := s.oauth.GetUser(r)
 
 	profile, err := s.profile(r)
 	if err != nil {
 		l.Error("failed to build profile card", "err", err)
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
···
 	strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid))
 	if err != nil {
 		l.Error("failed to get strings", "err", err)
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 
 	err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: user,
 		Strings:      strings,
 		Card:         profile,
 	})
···
 func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) {
 	ident, ok := r.Context().Value("resolvedId").(identity.Identity)
 	if !ok {
-		s.pages.Error404(w)
+		s.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: nil})
 		return
 	}
 
 	feed, err := s.getProfileFeed(r.Context(), &ident)
 	if err != nil {
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil})
 		return
 	}
 
···
 
 	atom, err := feed.ToAtom()
 	if err != nil {
-		s.pages.Error500(w)
+		s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil})
 		return
 	}
 

appview/state/router.go

···
 	"tangled.org/core/appview/labels"
 	"tangled.org/core/appview/middleware"
 	"tangled.org/core/appview/notifications"
+	"tangled.org/core/appview/pages"
 	"tangled.org/core/appview/pipelines"
 	"tangled.org/core/appview/pulls"
 	"tangled.org/core/appview/repo"
···
 	})
 
 	r.NotFound(func(w http.ResponseWriter, r *http.Request) {
-		s.pages.Error404(w)
+		s.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: s.oauth.GetUser(r)})
 	})
 
 	return r
···
 	r.Get("/brand", s.Brand)
 
 	r.NotFound(func(w http.ResponseWriter, r *http.Request) {
-		s.pages.Error404(w)
+		s.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: s.oauth.GetUser(r)})
 	})
 	return r
 }

appview/strings/strings.go

···
 
 func (s *Strings) contents(w http.ResponseWriter, r *http.Request) {
 	l := s.Logger.With("handler", "contents")
+	user := s.OAuth.GetUser(r)
 
 	id, ok := r.Context().Value("resolvedId").(identity.Identity)
 	if !ok {
···
 	}
 	if len(strings) < 1 {
 		l.Error("string not found")
-		s.Pages.Error404(w)
+		s.Pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user})
 		return
 	}
 	if len(strings) != 1 {
···
 	if err != nil {
 		l.Error("failed to get star count", "err", err)
 	}
-	user := s.OAuth.GetUser(r)
 	isStarred := false
 	if user != nil {
 		isStarred = db.GetStarStatus(s.Db, user.Did, string.AtUri())