appview/pages: include LoggedInUser on error pages #845

+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 86 - rp.pages.Error404(w) 86 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 107 - rp.pages.Error503(w) 107 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 140 - rp.pages.Error404(w) 140 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 285 - rp.pages.Error404(w) 285 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 336 - rp.pages.Error404(w) 336 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 386 - rp.pages.Error404(w) 386 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 484 - rp.pages.Error404(w) 484 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 525 - rp.pages.Error404(w) 525 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 629 - rp.pages.Error404(w) 629 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 670 - rp.pages.Error404(w) 670 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 711 - rp.pages.Error404(w) 711 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 867 - rp.pages.Error503(w) 867 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 194 - mw.pages.Error404(w) 194 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 225 - mw.pages.ErrorKnot404(w) 225 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 242 - mw.pages.ErrorKnot404(w) 242 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 250 - mw.pages.Error404(w) 250 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 257 - mw.pages.Error404(w) 257 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 290 - mw.pages.ErrorKnot404(w) 290 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 298 - mw.pages.Error404(w) 298 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 305 - mw.pages.Error404(w) 305 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 326 - mw.pages.ErrorKnot404(w) 326 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 60 - n.pages.Error500(w) 60 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 71 - n.pages.Error500(w) 71 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 1440 - func (p *Pages) Error500(w io.Writer) error { 1441 1441 - return p.execute("errors/500", w, nil) 1440 1440 + type ErrorPageParams struct { 1441 1441 + LoggedInUser *oauth.User 1442 1442 + } 1443 1443 + 1444 1444 + func (p *Pages) Error500(w io.Writer, params ErrorPageParams) error { 1445 1445 + return p.execute("errors/500", w, params) 1442 1446 } 1443 1447 1444 1444 - func (p *Pages) Error404(w io.Writer) error { 1445 1445 - return p.execute("errors/404", w, nil) 1448 1448 + func (p *Pages) Error404(w io.Writer, params ErrorPageParams) error { 1449 1449 + return p.execute("errors/404", w, params) 1446 1450 } 1447 1451 1448 1448 - func (p *Pages) ErrorKnot404(w io.Writer) error { 1449 1449 - return p.execute("errors/knot404", w, nil) 1452 1452 + func (p *Pages) ErrorKnot404(w io.Writer, params ErrorPageParams) error { 1453 1453 + return p.execute("errors/knot404", w, params) 1450 1454 } 1451 1455 1452 1452 - func (p *Pages) Error503(w io.Writer) error { 1453 1453 - return p.execute("errors/503", w, nil) 1456 1456 + func (p *Pages) Error503(w io.Writer, params ErrorPageParams) error { 1457 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 214 - s.pages.Error503(w) 214 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 674 - s.pages.Error503(w) 674 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 834 - s.pages.Error503(w) 834 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 844 - s.pages.Error503(w) 844 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 1441 - s.pages.Error503(w) 1441 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 1451 - s.pages.Error503(w) 1451 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 1533 - s.pages.Error503(w) 1533 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 1544 - s.pages.Error503(w) 1544 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 1562 - s.pages.Error503(w) 1562 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 1573 - s.pages.Error503(w) 1573 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 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 38 - rp.pages.Error503(w) 39 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 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 61 - rp.pages.Error503(w) 62 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 77 - user := rp.oauth.GetUser(r) 78 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 136 - rp.pages.Error503(w) 135 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 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 36 - rp.pages.Error503(w) 37 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 42 - rp.pages.Error503(w) 43 43 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 43 44 return 44 45 } 45 46 sortBranches(result.Branches) 46 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 43 - rp.pages.Error503(w) 43 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 80 - rp.pages.Error503(w) 80 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 141 - rp.pages.Error404(w) 141 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 159 - rp.pages.Error503(w) 159 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 173 - rp.pages.Error503(w) 173 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 187 - rp.pages.Error503(w) 187 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 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 159 - rp.pages.Error500(w) 160 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 165 - rp.pages.Error500(w) 166 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 70 - rp.pages.Error503(w) 70 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 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 64 - rp.pages.Error503(w) 65 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 71 - rp.pages.Error503(w) 72 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 78 - rp.pages.Error503(w) 79 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 99 - rp.pages.Error503(w) 100 100 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 100 101 return 101 102 } 102 103 ··· 109 110 } 110 111 } 111 112 112 112 - user := rp.oauth.GetUser(r) 113 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 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 164 - rp.pages.Error404(w) 164 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 181 - rp.pages.Error503(w) 181 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 188 - rp.pages.Error503(w) 188 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 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 201 - rp.pages.Error503(w) 201 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 208 - rp.pages.Error503(w) 208 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 215 - rp.pages.Error503(w) 215 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 222 - rp.pages.Error503(w) 222 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 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 38 - rp.pages.Error503(w) 39 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 44 - rp.pages.Error503(w) 45 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 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 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 46 - rp.pages.Error503(w) 47 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 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 26 - s.pages.Error500(w) 26 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 33 - s.pages.Error503(w) 33 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 63 - s.pages.Error503(w) 63 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 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 119 - s.pages.Error500(w) 120 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 166 - LoggedInUser: s.oauth.GetUser(r), 167 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 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 180 - s.pages.Error500(w) 182 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 192 - s.pages.Error500(w) 194 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 197 - LoggedInUser: s.oauth.GetUser(r), 199 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 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 209 - s.pages.Error500(w) 212 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 217 - s.pages.Error500(w) 220 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 226 - LoggedInUser: s.oauth.GetUser(r), 229 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 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 238 - s.pages.Error500(w) 242 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 246 - s.pages.Error500(w) 250 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 251 - LoggedInUser: s.oauth.GetUser(r), 255 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 382 - s.pages.Error404(w) 386 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 388 - s.pages.Error500(w) 392 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 398 - s.pages.Error500(w) 402 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 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 111 - s.pages.Error404(w) 112 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 182 - s.pages.Error404(w) 183 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 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 121 - s.Pages.Error404(w) 122 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 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())