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 issue, ok := r.Context().Value("issue").(*models.Issue) 84 if !ok { 85 l.Error("failed to get issue") 86 - rp.pages.Error404(w) 87 return 88 } 89 ··· 104 ) 105 if err != nil { 106 l.Error("failed to fetch labels", "err", err) 107 - rp.pages.Error503(w) 108 return 109 } 110 ··· 137 issue, ok := r.Context().Value("issue").(*models.Issue) 138 if !ok { 139 l.Error("failed to get issue") 140 - rp.pages.Error404(w) 141 return 142 } 143 ··· 282 issue, ok := r.Context().Value("issue").(*models.Issue) 283 if !ok { 284 l.Error("failed to get issue") 285 - rp.pages.Error404(w) 286 return 287 } 288 ··· 333 issue, ok := r.Context().Value("issue").(*models.Issue) 334 if !ok { 335 l.Error("failed to get issue") 336 - rp.pages.Error404(w) 337 return 338 } 339 ··· 383 issue, ok := r.Context().Value("issue").(*models.Issue) 384 if !ok { 385 l.Error("failed to get issue") 386 - rp.pages.Error404(w) 387 return 388 } 389 ··· 481 issue, ok := r.Context().Value("issue").(*models.Issue) 482 if !ok { 483 l.Error("failed to get issue") 484 - rp.pages.Error404(w) 485 return 486 } 487 ··· 522 issue, ok := r.Context().Value("issue").(*models.Issue) 523 if !ok { 524 l.Error("failed to get issue") 525 - rp.pages.Error404(w) 526 return 527 } 528 ··· 626 issue, ok := r.Context().Value("issue").(*models.Issue) 627 if !ok { 628 l.Error("failed to get issue") 629 - rp.pages.Error404(w) 630 return 631 } 632 ··· 667 issue, ok := r.Context().Value("issue").(*models.Issue) 668 if !ok { 669 l.Error("failed to get issue") 670 - rp.pages.Error404(w) 671 return 672 } 673 ··· 708 issue, ok := r.Context().Value("issue").(*models.Issue) 709 if !ok { 710 l.Error("failed to get issue") 711 - rp.pages.Error404(w) 712 return 713 } 714 ··· 864 ) 865 if err != nil { 866 l.Error("failed to fetch labels", "err", err) 867 - rp.pages.Error503(w) 868 return 869 } 870
··· 83 issue, ok := r.Context().Value("issue").(*models.Issue) 84 if !ok { 85 l.Error("failed to get issue") 86 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 87 return 88 } 89 ··· 104 ) 105 if err != nil { 106 l.Error("failed to fetch labels", "err", err) 107 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 108 return 109 } 110 ··· 137 issue, ok := r.Context().Value("issue").(*models.Issue) 138 if !ok { 139 l.Error("failed to get issue") 140 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 141 return 142 } 143 ··· 282 issue, ok := r.Context().Value("issue").(*models.Issue) 283 if !ok { 284 l.Error("failed to get issue") 285 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 286 return 287 } 288 ··· 333 issue, ok := r.Context().Value("issue").(*models.Issue) 334 if !ok { 335 l.Error("failed to get issue") 336 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 337 return 338 } 339 ··· 383 issue, ok := r.Context().Value("issue").(*models.Issue) 384 if !ok { 385 l.Error("failed to get issue") 386 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 387 return 388 } 389 ··· 481 issue, ok := r.Context().Value("issue").(*models.Issue) 482 if !ok { 483 l.Error("failed to get issue") 484 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 485 return 486 } 487 ··· 522 issue, ok := r.Context().Value("issue").(*models.Issue) 523 if !ok { 524 l.Error("failed to get issue") 525 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 526 return 527 } 528 ··· 626 issue, ok := r.Context().Value("issue").(*models.Issue) 627 if !ok { 628 l.Error("failed to get issue") 629 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 630 return 631 } 632 ··· 667 issue, ok := r.Context().Value("issue").(*models.Issue) 668 if !ok { 669 l.Error("failed to get issue") 670 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 671 return 672 } 673 ··· 708 issue, ok := r.Context().Value("issue").(*models.Issue) 709 if !ok { 710 l.Error("failed to get issue") 711 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 712 return 713 } 714 ··· 864 ) 865 if err != nil { 866 l.Error("failed to fetch labels", "err", err) 867 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 868 return 869 } 870
+9 -9
appview/middleware/middleware.go
··· 191 if err != nil { 192 // invalid did or handle 193 log.Printf("failed to resolve did/handle '%s': %s\n", didOrHandle, err) 194 - mw.pages.Error404(w) 195 return 196 } 197 ··· 222 ) 223 if err != nil { 224 log.Println("failed to resolve repo", "err", err) 225 - mw.pages.ErrorKnot404(w) 226 return 227 } 228 ··· 239 f, err := mw.repoResolver.Resolve(r) 240 if err != nil { 241 log.Println("failed to fully resolve repo", err) 242 - mw.pages.ErrorKnot404(w) 243 return 244 } 245 ··· 247 prIdInt, err := strconv.Atoi(prId) 248 if err != nil { 249 log.Println("failed to parse pr id", err) 250 - mw.pages.Error404(w) 251 return 252 } 253 254 pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt) 255 if err != nil { 256 log.Println("failed to get pull and comments", err) 257 - mw.pages.Error404(w) 258 return 259 } 260 ··· 287 f, err := mw.repoResolver.Resolve(r) 288 if err != nil { 289 log.Println("failed to fully resolve repo", err) 290 - mw.pages.ErrorKnot404(w) 291 return 292 } 293 ··· 295 issueId, err := strconv.Atoi(issueIdStr) 296 if err != nil { 297 log.Println("failed to fully resolve issue ID", err) 298 - mw.pages.Error404(w) 299 return 300 } 301 302 issue, err := db.GetIssue(mw.db, f.RepoAt(), issueId) 303 if err != nil { 304 log.Println("failed to get issues", "err", err) 305 - mw.pages.Error404(w) 306 return 307 } 308 ··· 323 f, err := mw.repoResolver.Resolve(r) 324 if err != nil { 325 log.Println("failed to fully resolve repo", err) 326 - mw.pages.ErrorKnot404(w) 327 return 328 } 329
··· 191 if err != nil { 192 // invalid did or handle 193 log.Printf("failed to resolve did/handle '%s': %s\n", didOrHandle, err) 194 + mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(req)}) 195 return 196 } 197 ··· 222 ) 223 if err != nil { 224 log.Println("failed to resolve repo", "err", err) 225 + mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(req)}) 226 return 227 } 228 ··· 239 f, err := mw.repoResolver.Resolve(r) 240 if err != nil { 241 log.Println("failed to fully resolve repo", err) 242 + mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)}) 243 return 244 } 245 ··· 247 prIdInt, err := strconv.Atoi(prId) 248 if err != nil { 249 log.Println("failed to parse pr id", err) 250 + mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)}) 251 return 252 } 253 254 pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt) 255 if err != nil { 256 log.Println("failed to get pull and comments", err) 257 + mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)}) 258 return 259 } 260 ··· 287 f, err := mw.repoResolver.Resolve(r) 288 if err != nil { 289 log.Println("failed to fully resolve repo", err) 290 + mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)}) 291 return 292 } 293 ··· 295 issueId, err := strconv.Atoi(issueIdStr) 296 if err != nil { 297 log.Println("failed to fully resolve issue ID", err) 298 + mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)}) 299 return 300 } 301 302 issue, err := db.GetIssue(mw.db, f.RepoAt(), issueId) 303 if err != nil { 304 log.Println("failed to get issues", "err", err) 305 + mw.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)}) 306 return 307 } 308 ··· 323 f, err := mw.repoResolver.Resolve(r) 324 if err != nil { 325 log.Println("failed to fully resolve repo", err) 326 + mw.pages.ErrorKnot404(w, pages.ErrorPageParams{LoggedInUser: mw.oauth.GetUser(r)}) 327 return 328 } 329
+2 -2
appview/notifications/notifications.go
··· 57 ) 58 if err != nil { 59 l.Error("failed to get total notifications", "err", err) 60 - n.pages.Error500(w) 61 return 62 } 63 ··· 68 ) 69 if err != nil { 70 l.Error("failed to get notifications", "err", err) 71 - n.pages.Error500(w) 72 return 73 } 74
··· 57 ) 58 if err != nil { 59 l.Error("failed to get total notifications", "err", err) 60 + n.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 61 return 62 } 63 ··· 68 ) 69 if err != nil { 70 l.Error("failed to get notifications", "err", err) 71 + n.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 72 return 73 } 74
+12 -8
appview/pages/pages.go
··· 1437 return hex.EncodeToString(hasher.Sum(nil))[:8] // Use first 8 chars of hash 1438 } 1439 1440 - func (p *Pages) Error500(w io.Writer) error { 1441 - return p.execute("errors/500", w, nil) 1442 } 1443 1444 - func (p *Pages) Error404(w io.Writer) error { 1445 - return p.execute("errors/404", w, nil) 1446 } 1447 1448 - func (p *Pages) ErrorKnot404(w io.Writer) error { 1449 - return p.execute("errors/knot404", w, nil) 1450 } 1451 1452 - func (p *Pages) Error503(w io.Writer) error { 1453 - return p.execute("errors/503", w, nil) 1454 }
··· 1437 return hex.EncodeToString(hasher.Sum(nil))[:8] // Use first 8 chars of hash 1438 } 1439 1440 + type ErrorPageParams struct { 1441 + LoggedInUser *oauth.User 1442 + } 1443 + 1444 + func (p *Pages) Error500(w io.Writer, params ErrorPageParams) error { 1445 + return p.execute("errors/500", w, params) 1446 } 1447 1448 + func (p *Pages) Error404(w io.Writer, params ErrorPageParams) error { 1449 + return p.execute("errors/404", w, params) 1450 } 1451 1452 + func (p *Pages) ErrorKnot404(w io.Writer, params ErrorPageParams) error { 1453 + return p.execute("errors/knot404", w, params) 1454 } 1455 1456 + func (p *Pages) Error503(w io.Writer, params ErrorPageParams) error { 1457 + return p.execute("errors/503", w, params) 1458 }
+10 -10
appview/pulls/pulls.go
··· 211 ) 212 if err != nil { 213 log.Println("failed to fetch labels", err) 214 - s.pages.Error503(w) 215 return 216 } 217 ··· 671 ) 672 if err != nil { 673 log.Println("failed to fetch labels", err) 674 - s.pages.Error503(w) 675 return 676 } 677 ··· 831 if err != nil { 832 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 833 log.Println("failed to call XRPC repo.branches", xrpcerr) 834 - s.pages.Error503(w) 835 return 836 } 837 log.Println("failed to fetch branches", err) ··· 841 var result types.RepoBranchesResponse 842 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 843 log.Println("failed to decode XRPC response", err) 844 - s.pages.Error503(w) 845 return 846 } 847 ··· 1438 if err != nil { 1439 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1440 log.Println("failed to call XRPC repo.branches", xrpcerr) 1441 - s.pages.Error503(w) 1442 return 1443 } 1444 log.Println("failed to fetch branches", err) ··· 1448 var result types.RepoBranchesResponse 1449 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 1450 log.Println("failed to decode XRPC response", err) 1451 - s.pages.Error503(w) 1452 return 1453 } 1454 ··· 1530 if err != nil { 1531 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1532 log.Println("failed to call XRPC repo.branches for source", xrpcerr) 1533 - s.pages.Error503(w) 1534 return 1535 } 1536 log.Println("failed to fetch source branches", err) ··· 1541 var sourceBranches types.RepoBranchesResponse 1542 if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil { 1543 log.Println("failed to decode source branches XRPC response", err) 1544 - s.pages.Error503(w) 1545 return 1546 } 1547 ··· 1559 if err != nil { 1560 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1561 log.Println("failed to call XRPC repo.branches for target", xrpcerr) 1562 - s.pages.Error503(w) 1563 return 1564 } 1565 log.Println("failed to fetch target branches", err) ··· 1570 var targetBranches types.RepoBranchesResponse 1571 if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil { 1572 log.Println("failed to decode target branches XRPC response", err) 1573 - s.pages.Error503(w) 1574 return 1575 } 1576
··· 211 ) 212 if err != nil { 213 log.Println("failed to fetch labels", err) 214 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 215 return 216 } 217 ··· 671 ) 672 if err != nil { 673 log.Println("failed to fetch labels", err) 674 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 675 return 676 } 677 ··· 831 if err != nil { 832 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 833 log.Println("failed to call XRPC repo.branches", xrpcerr) 834 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 835 return 836 } 837 log.Println("failed to fetch branches", err) ··· 841 var result types.RepoBranchesResponse 842 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 843 log.Println("failed to decode XRPC response", err) 844 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 845 return 846 } 847 ··· 1438 if err != nil { 1439 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1440 log.Println("failed to call XRPC repo.branches", xrpcerr) 1441 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 1442 return 1443 } 1444 log.Println("failed to fetch branches", err) ··· 1448 var result types.RepoBranchesResponse 1449 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 1450 log.Println("failed to decode XRPC response", err) 1451 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 1452 return 1453 } 1454 ··· 1530 if err != nil { 1531 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1532 log.Println("failed to call XRPC repo.branches for source", xrpcerr) 1533 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 1534 return 1535 } 1536 log.Println("failed to fetch source branches", err) ··· 1541 var sourceBranches types.RepoBranchesResponse 1542 if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil { 1543 log.Println("failed to decode source branches XRPC response", err) 1544 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 1545 return 1546 } 1547 ··· 1559 if err != nil { 1560 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1561 log.Println("failed to call XRPC repo.branches for target", xrpcerr) 1562 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 1563 return 1564 } 1565 log.Println("failed to fetch target branches", err) ··· 1570 var targetBranches types.RepoBranchesResponse 1571 if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil { 1572 log.Println("failed to decode target branches XRPC response", err) 1573 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 1574 return 1575 } 1576
+2 -1
appview/repo/archive.go
··· 7 "strings" 8 9 "tangled.org/core/api/tangled" 10 xrpcclient "tangled.org/core/appview/xrpcclient" 11 12 indigoxrpc "github.com/bluesky-social/indigo/xrpc" ··· 35 archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo) 36 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 37 l.Error("failed to call XRPC repo.archive", "err", xrpcerr) 38 - rp.pages.Error503(w) 39 return 40 } 41 // Set headers for file download, just pass along whatever the knot specifies
··· 7 "strings" 8 9 "tangled.org/core/api/tangled" 10 + "tangled.org/core/appview/pages" 11 xrpcclient "tangled.org/core/appview/xrpcclient" 12 13 indigoxrpc "github.com/bluesky-social/indigo/xrpc" ··· 36 archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo) 37 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 38 l.Error("failed to call XRPC repo.archive", "err", xrpcerr) 39 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: rp.oauth.GetUser(r)}) 40 return 41 } 42 // Set headers for file download, just pass along whatever the knot specifies
+3 -4
appview/repo/blob.go
··· 33 // - rest : | | 34 func (rp *Repo) Blob(w http.ResponseWriter, r *http.Request) { 35 l := rp.logger.With("handler", "RepoBlob") 36 37 f, err := rp.repoResolver.Resolve(r) 38 if err != nil { ··· 58 resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo) 59 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 60 l.Error("failed to call XRPC repo.blob", "err", xrpcerr) 61 - rp.pages.Error503(w) 62 return 63 } 64 ··· 74 // Create the blob view 75 blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query()) 76 77 - user := rp.oauth.GetUser(r) 78 - 79 rp.pages.RepoBlob(w, pages.RepoBlobParams{ 80 LoggedInUser: user, 81 RepoInfo: f.RepoInfo(user), ··· 133 resp, err := client.Do(req) 134 if err != nil { 135 l.Error("failed to reach knotserver", "err", err) 136 - rp.pages.Error503(w) 137 return 138 } 139
··· 33 // - rest : | | 34 func (rp *Repo) Blob(w http.ResponseWriter, r *http.Request) { 35 l := rp.logger.With("handler", "RepoBlob") 36 + user := rp.oauth.GetUser(r) 37 38 f, err := rp.repoResolver.Resolve(r) 39 if err != nil { ··· 59 resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo) 60 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 61 l.Error("failed to call XRPC repo.blob", "err", xrpcerr) 62 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 63 return 64 } 65 ··· 75 // Create the blob view 76 blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query()) 77 78 rp.pages.RepoBlob(w, pages.RepoBlobParams{ 79 LoggedInUser: user, 80 RepoInfo: f.RepoInfo(user), ··· 132 resp, err := client.Do(req) 133 if err != nil { 134 l.Error("failed to reach knotserver", "err", err) 135 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: rp.oauth.GetUser(r)}) 136 return 137 } 138
+3 -3
appview/repo/branches.go
··· 16 17 func (rp *Repo) Branches(w http.ResponseWriter, r *http.Request) { 18 l := rp.logger.With("handler", "RepoBranches") 19 f, err := rp.repoResolver.Resolve(r) 20 if err != nil { 21 l.Error("failed to get repo and knot", "err", err) ··· 33 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 34 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 35 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 36 - rp.pages.Error503(w) 37 return 38 } 39 var result types.RepoBranchesResponse 40 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 41 l.Error("failed to decode XRPC response", "err", err) 42 - rp.pages.Error503(w) 43 return 44 } 45 sortBranches(result.Branches) 46 - user := rp.oauth.GetUser(r) 47 rp.pages.RepoBranches(w, pages.RepoBranchesParams{ 48 LoggedInUser: user, 49 RepoInfo: f.RepoInfo(user),
··· 16 17 func (rp *Repo) Branches(w http.ResponseWriter, r *http.Request) { 18 l := rp.logger.With("handler", "RepoBranches") 19 + user := rp.oauth.GetUser(r) 20 f, err := rp.repoResolver.Resolve(r) 21 if err != nil { 22 l.Error("failed to get repo and knot", "err", err) ··· 34 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 35 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 36 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 37 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 38 return 39 } 40 var result types.RepoBranchesResponse 41 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 42 l.Error("failed to decode XRPC response", "err", err) 43 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 44 return 45 } 46 sortBranches(result.Branches) 47 rp.pages.RepoBranches(w, pages.RepoBranchesParams{ 48 LoggedInUser: user, 49 RepoInfo: f.RepoInfo(user),
+6 -6
appview/repo/compare.go
··· 40 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 41 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 42 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 43 - rp.pages.Error503(w) 44 return 45 } 46 ··· 77 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 78 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 79 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 80 - rp.pages.Error503(w) 81 return 82 } 83 ··· 138 139 if base == "" || head == "" { 140 l.Error("invalid comparison") 141 - rp.pages.Error404(w) 142 return 143 } 144 ··· 156 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 157 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 158 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 159 - rp.pages.Error503(w) 160 return 161 } 162 ··· 170 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 171 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 172 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 173 - rp.pages.Error503(w) 174 return 175 } 176 ··· 184 compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head) 185 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 186 l.Error("failed to call XRPC repo.compare", "err", xrpcerr) 187 - rp.pages.Error503(w) 188 return 189 } 190
··· 40 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 41 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 42 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 43 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 44 return 45 } 46 ··· 77 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 78 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 79 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 80 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 81 return 82 } 83 ··· 138 139 if base == "" || head == "" { 140 l.Error("invalid comparison") 141 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 142 return 143 } 144 ··· 156 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 157 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 158 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 159 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 160 return 161 } 162 ··· 170 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 171 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 172 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 173 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 174 return 175 } 176 ··· 184 compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head) 185 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 186 l.Error("failed to call XRPC repo.compare", "err", xrpcerr) 187 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 188 return 189 } 190
+3 -2
appview/repo/feed.go
··· 10 11 "tangled.org/core/appview/db" 12 "tangled.org/core/appview/models" 13 "tangled.org/core/appview/pagination" 14 "tangled.org/core/appview/reporesolver" 15 ··· 156 feed, err := rp.getRepoFeed(r.Context(), f) 157 if err != nil { 158 log.Println("failed to get repo feed:", err) 159 - rp.pages.Error500(w) 160 return 161 } 162 163 atom, err := feed.ToAtom() 164 if err != nil { 165 - rp.pages.Error500(w) 166 return 167 } 168
··· 10 11 "tangled.org/core/appview/db" 12 "tangled.org/core/appview/models" 13 + "tangled.org/core/appview/pages" 14 "tangled.org/core/appview/pagination" 15 "tangled.org/core/appview/reporesolver" 16 ··· 157 feed, err := rp.getRepoFeed(r.Context(), f) 158 if err != nil { 159 log.Println("failed to get repo feed:", err) 160 + rp.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil}) 161 return 162 } 163 164 atom, err := feed.ToAtom() 165 if err != nil { 166 + rp.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil}) 167 return 168 } 169
+1 -1
appview/repo/index.go
··· 67 return 68 } 69 70 - rp.pages.Error503(w) 71 l.Error("failed to build index response", "err", err) 72 return 73 }
··· 67 return 68 } 69 70 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 71 l.Error("failed to build index response", "err", err) 72 return 73 }
+9 -10
appview/repo/log.go
··· 22 23 func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) { 24 l := rp.logger.With("handler", "RepoLog") 25 26 f, err := rp.repoResolver.Resolve(r) 27 if err != nil { ··· 61 xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo) 62 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 63 l.Error("failed to call XRPC repo.log", "err", xrpcerr) 64 - rp.pages.Error503(w) 65 return 66 } 67 68 var xrpcResp types.RepoLogResponse 69 if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil { 70 l.Error("failed to decode XRPC response", "err", err) 71 - rp.pages.Error503(w) 72 return 73 } 74 75 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 76 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 77 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 78 - rp.pages.Error503(w) 79 return 80 } 81 ··· 96 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 97 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 98 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 99 - rp.pages.Error503(w) 100 return 101 } 102 ··· 109 } 110 } 111 112 - user := rp.oauth.GetUser(r) 113 - 114 emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true) 115 if err != nil { 116 l.Error("failed to fetch email to did mapping", "err", err) ··· 146 147 func (rp *Repo) Commit(w http.ResponseWriter, r *http.Request) { 148 l := rp.logger.With("handler", "RepoCommit") 149 150 f, err := rp.repoResolver.Resolve(r) 151 if err != nil { ··· 161 } 162 163 if !plumbing.IsHash(ref) { 164 - rp.pages.Error404(w) 165 return 166 } 167 ··· 178 xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo) 179 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 180 l.Error("failed to call XRPC repo.diff", "err", xrpcerr) 181 - rp.pages.Error503(w) 182 return 183 } 184 185 var result types.RepoCommitResponse 186 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 187 l.Error("failed to decode XRPC response", "err", err) 188 - rp.pages.Error503(w) 189 return 190 } 191 ··· 199 l.Error("failed to GetVerifiedCommits", "err", err) 200 } 201 202 - user := rp.oauth.GetUser(r) 203 repoInfo := f.RepoInfo(user) 204 pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This}) 205 if err != nil {
··· 22 23 func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) { 24 l := rp.logger.With("handler", "RepoLog") 25 + user := rp.oauth.GetUser(r) 26 27 f, err := rp.repoResolver.Resolve(r) 28 if err != nil { ··· 62 xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo) 63 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 64 l.Error("failed to call XRPC repo.log", "err", xrpcerr) 65 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 66 return 67 } 68 69 var xrpcResp types.RepoLogResponse 70 if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil { 71 l.Error("failed to decode XRPC response", "err", err) 72 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 73 return 74 } 75 76 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 77 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 78 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 79 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 80 return 81 } 82 ··· 97 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 98 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 99 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 100 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 101 return 102 } 103 ··· 110 } 111 } 112 113 emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true) 114 if err != nil { 115 l.Error("failed to fetch email to did mapping", "err", err) ··· 145 146 func (rp *Repo) Commit(w http.ResponseWriter, r *http.Request) { 147 l := rp.logger.With("handler", "RepoCommit") 148 + user := rp.oauth.GetUser(r) 149 150 f, err := rp.repoResolver.Resolve(r) 151 if err != nil { ··· 161 } 162 163 if !plumbing.IsHash(ref) { 164 + rp.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 165 return 166 } 167 ··· 178 xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo) 179 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 180 l.Error("failed to call XRPC repo.diff", "err", xrpcerr) 181 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 182 return 183 } 184 185 var result types.RepoCommitResponse 186 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 187 l.Error("failed to decode XRPC response", "err", err) 188 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 189 return 190 } 191 ··· 199 l.Error("failed to GetVerifiedCommits", "err", err) 200 } 201 202 repoInfo := f.RepoInfo(user) 203 pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This}) 204 if err != nil {
+4 -4
appview/repo/settings.go
··· 198 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 199 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 200 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 201 - rp.pages.Error503(w) 202 return 203 } 204 205 var result types.RepoBranchesResponse 206 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 207 l.Error("failed to decode XRPC response", "err", err) 208 - rp.pages.Error503(w) 209 return 210 } 211 212 defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs)) 213 if err != nil { 214 l.Error("failed to fetch labels", "err", err) 215 - rp.pages.Error503(w) 216 return 217 } 218 219 labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels)) 220 if err != nil { 221 l.Error("failed to fetch labels", "err", err) 222 - rp.pages.Error503(w) 223 return 224 } 225 // remove default labels from the labels list, if present
··· 198 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 199 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 200 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 201 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 202 return 203 } 204 205 var result types.RepoBranchesResponse 206 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 207 l.Error("failed to decode XRPC response", "err", err) 208 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 209 return 210 } 211 212 defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs)) 213 if err != nil { 214 l.Error("failed to fetch labels", "err", err) 215 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 216 return 217 } 218 219 labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels)) 220 if err != nil { 221 l.Error("failed to fetch labels", "err", err) 222 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 223 return 224 } 225 // remove default labels from the labels list, if present
+3 -3
appview/repo/tags.go
··· 18 19 func (rp *Repo) Tags(w http.ResponseWriter, r *http.Request) { 20 l := rp.logger.With("handler", "RepoTags") 21 f, err := rp.repoResolver.Resolve(r) 22 if err != nil { 23 l.Error("failed to get repo and knot", "err", err) ··· 35 xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 36 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 37 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 38 - rp.pages.Error503(w) 39 return 40 } 41 var result types.RepoTagsResponse 42 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 43 l.Error("failed to decode XRPC response", "err", err) 44 - rp.pages.Error503(w) 45 return 46 } 47 artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt())) ··· 68 danglingArtifacts = append(danglingArtifacts, a) 69 } 70 } 71 - user := rp.oauth.GetUser(r) 72 rp.pages.RepoTags(w, pages.RepoTagsParams{ 73 LoggedInUser: user, 74 RepoInfo: f.RepoInfo(user),
··· 18 19 func (rp *Repo) Tags(w http.ResponseWriter, r *http.Request) { 20 l := rp.logger.With("handler", "RepoTags") 21 + user := rp.oauth.GetUser(r) 22 f, err := rp.repoResolver.Resolve(r) 23 if err != nil { 24 l.Error("failed to get repo and knot", "err", err) ··· 36 xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 37 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 38 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 39 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 40 return 41 } 42 var result types.RepoTagsResponse 43 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 44 l.Error("failed to decode XRPC response", "err", err) 45 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 46 return 47 } 48 artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt())) ··· 69 danglingArtifacts = append(danglingArtifacts, a) 70 } 71 } 72 rp.pages.RepoTags(w, pages.RepoTagsParams{ 73 LoggedInUser: user, 74 RepoInfo: f.RepoInfo(user),
+2 -2
appview/repo/tree.go
··· 19 20 func (rp *Repo) Tree(w http.ResponseWriter, r *http.Request) { 21 l := rp.logger.With("handler", "RepoTree") 22 f, err := rp.repoResolver.Resolve(r) 23 if err != nil { 24 l.Error("failed to fully resolve repo", "err", err) ··· 43 xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo) 44 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 45 l.Error("failed to call XRPC repo.tree", "err", xrpcerr) 46 - rp.pages.Error503(w) 47 return 48 } 49 // Convert XRPC response to internal types.RepoTreeResponse ··· 86 http.Redirect(w, r, redirectTo, http.StatusFound) 87 return 88 } 89 - user := rp.oauth.GetUser(r) 90 var breadcrumbs [][]string 91 breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))}) 92 if treePath != "" {
··· 19 20 func (rp *Repo) Tree(w http.ResponseWriter, r *http.Request) { 21 l := rp.logger.With("handler", "RepoTree") 22 + user := rp.oauth.GetUser(r) 23 f, err := rp.repoResolver.Resolve(r) 24 if err != nil { 25 l.Error("failed to fully resolve repo", "err", err) ··· 44 xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo) 45 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 46 l.Error("failed to call XRPC repo.tree", "err", xrpcerr) 47 + rp.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 48 return 49 } 50 // Convert XRPC response to internal types.RepoTreeResponse ··· 87 http.Redirect(w, r, redirectTo, http.StatusFound) 88 return 89 } 90 var breadcrumbs [][]string 91 breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))}) 92 if treePath != "" {
+3 -3
appview/state/gfi.go
··· 23 gfiLabelDef, err := db.GetLabelDefinition(s.db, db.FilterEq("at_uri", goodFirstIssueLabel)) 24 if err != nil { 25 log.Println("failed to get gfi label def", err) 26 - s.pages.Error500(w) 27 return 28 } 29 30 repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel)) 31 if err != nil { 32 log.Println("failed to get repo labels", err) 33 - s.pages.Error503(w) 34 return 35 } 36 ··· 60 ) 61 if err != nil { 62 log.Println("failed to get issues", err) 63 - s.pages.Error503(w) 64 return 65 } 66
··· 23 gfiLabelDef, err := db.GetLabelDefinition(s.db, db.FilterEq("at_uri", goodFirstIssueLabel)) 24 if err != nil { 25 log.Println("failed to get gfi label def", err) 26 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 27 return 28 } 29 30 repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel)) 31 if err != nil { 32 log.Println("failed to get repo labels", err) 33 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 34 return 35 } 36 ··· 60 ) 61 if err != nil { 62 log.Println("failed to get issues", err) 63 + s.pages.Error503(w, pages.ErrorPageParams{LoggedInUser: user}) 64 return 65 } 66
+18 -14
appview/state/profile.go
··· 112 113 func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) { 114 l := s.logger.With("handler", "profileHomePage") 115 116 profile, err := s.profile(r) 117 if err != nil { 118 l.Error("failed to build profile card", "err", err) 119 - s.pages.Error500(w) 120 return 121 } 122 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 163 } 164 165 s.pages.ProfileOverview(w, pages.ProfileOverviewParams{ 166 - LoggedInUser: s.oauth.GetUser(r), 167 Card: profile, 168 Repos: pinnedRepos, 169 CollaboratingRepos: pinnedCollaboratingRepos, ··· 173 174 func (s *State) reposPage(w http.ResponseWriter, r *http.Request) { 175 l := s.logger.With("handler", "reposPage") 176 177 profile, err := s.profile(r) 178 if err != nil { 179 l.Error("failed to build profile card", "err", err) 180 - s.pages.Error500(w) 181 return 182 } 183 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 189 ) 190 if err != nil { 191 l.Error("failed to get repos", "err", err) 192 - s.pages.Error500(w) 193 return 194 } 195 196 err = s.pages.ProfileRepos(w, pages.ProfileReposParams{ 197 - LoggedInUser: s.oauth.GetUser(r), 198 Repos: repos, 199 Card: profile, 200 }) ··· 202 203 func (s *State) starredPage(w http.ResponseWriter, r *http.Request) { 204 l := s.logger.With("handler", "starredPage") 205 206 profile, err := s.profile(r) 207 if err != nil { 208 l.Error("failed to build profile card", "err", err) 209 - s.pages.Error500(w) 210 return 211 } 212 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 214 stars, err := db.GetRepoStars(s.db, 0, db.FilterEq("did", profile.UserDid)) 215 if err != nil { 216 l.Error("failed to get stars", "err", err) 217 - s.pages.Error500(w) 218 return 219 } 220 var repos []models.Repo ··· 223 } 224 225 err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{ 226 - LoggedInUser: s.oauth.GetUser(r), 227 Repos: repos, 228 Card: profile, 229 }) ··· 231 232 func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) { 233 l := s.logger.With("handler", "stringsPage") 234 235 profile, err := s.profile(r) 236 if err != nil { 237 l.Error("failed to build profile card", "err", err) 238 - s.pages.Error500(w) 239 return 240 } 241 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 243 strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid)) 244 if err != nil { 245 l.Error("failed to get strings", "err", err) 246 - s.pages.Error500(w) 247 return 248 } 249 250 err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{ 251 - LoggedInUser: s.oauth.GetUser(r), 252 Strings: strings, 253 Card: profile, 254 }) ··· 379 func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) { 380 ident, ok := r.Context().Value("resolvedId").(identity.Identity) 381 if !ok { 382 - s.pages.Error404(w) 383 return 384 } 385 386 feed, err := s.getProfileFeed(r.Context(), &ident) 387 if err != nil { 388 - s.pages.Error500(w) 389 return 390 } 391 ··· 395 396 atom, err := feed.ToAtom() 397 if err != nil { 398 - s.pages.Error500(w) 399 return 400 } 401
··· 112 113 func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) { 114 l := s.logger.With("handler", "profileHomePage") 115 + user := s.oauth.GetUser(r) 116 117 profile, err := s.profile(r) 118 if err != nil { 119 l.Error("failed to build profile card", "err", err) 120 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 121 return 122 } 123 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 164 } 165 166 s.pages.ProfileOverview(w, pages.ProfileOverviewParams{ 167 + LoggedInUser: user, 168 Card: profile, 169 Repos: pinnedRepos, 170 CollaboratingRepos: pinnedCollaboratingRepos, ··· 174 175 func (s *State) reposPage(w http.ResponseWriter, r *http.Request) { 176 l := s.logger.With("handler", "reposPage") 177 + user := s.oauth.GetUser(r) 178 179 profile, err := s.profile(r) 180 if err != nil { 181 l.Error("failed to build profile card", "err", err) 182 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 183 return 184 } 185 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 191 ) 192 if err != nil { 193 l.Error("failed to get repos", "err", err) 194 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 195 return 196 } 197 198 err = s.pages.ProfileRepos(w, pages.ProfileReposParams{ 199 + LoggedInUser: user, 200 Repos: repos, 201 Card: profile, 202 }) ··· 204 205 func (s *State) starredPage(w http.ResponseWriter, r *http.Request) { 206 l := s.logger.With("handler", "starredPage") 207 + user := s.oauth.GetUser(r) 208 209 profile, err := s.profile(r) 210 if err != nil { 211 l.Error("failed to build profile card", "err", err) 212 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 213 return 214 } 215 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 217 stars, err := db.GetRepoStars(s.db, 0, db.FilterEq("did", profile.UserDid)) 218 if err != nil { 219 l.Error("failed to get stars", "err", err) 220 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 221 return 222 } 223 var repos []models.Repo ··· 226 } 227 228 err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{ 229 + LoggedInUser: user, 230 Repos: repos, 231 Card: profile, 232 }) ··· 234 235 func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) { 236 l := s.logger.With("handler", "stringsPage") 237 + user := s.oauth.GetUser(r) 238 239 profile, err := s.profile(r) 240 if err != nil { 241 l.Error("failed to build profile card", "err", err) 242 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 243 return 244 } 245 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 247 strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid)) 248 if err != nil { 249 l.Error("failed to get strings", "err", err) 250 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: user}) 251 return 252 } 253 254 err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{ 255 + LoggedInUser: user, 256 Strings: strings, 257 Card: profile, 258 }) ··· 383 func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) { 384 ident, ok := r.Context().Value("resolvedId").(identity.Identity) 385 if !ok { 386 + s.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: nil}) 387 return 388 } 389 390 feed, err := s.getProfileFeed(r.Context(), &ident) 391 if err != nil { 392 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil}) 393 return 394 } 395 ··· 399 400 atom, err := feed.ToAtom() 401 if err != nil { 402 + s.pages.Error500(w, pages.ErrorPageParams{LoggedInUser: nil}) 403 return 404 } 405
+3 -2
appview/state/router.go
··· 10 "tangled.org/core/appview/labels" 11 "tangled.org/core/appview/middleware" 12 "tangled.org/core/appview/notifications" 13 "tangled.org/core/appview/pipelines" 14 "tangled.org/core/appview/pulls" 15 "tangled.org/core/appview/repo" ··· 108 }) 109 110 r.NotFound(func(w http.ResponseWriter, r *http.Request) { 111 - s.pages.Error404(w) 112 }) 113 114 return r ··· 179 r.Get("/brand", s.Brand) 180 181 r.NotFound(func(w http.ResponseWriter, r *http.Request) { 182 - s.pages.Error404(w) 183 }) 184 return r 185 }
··· 10 "tangled.org/core/appview/labels" 11 "tangled.org/core/appview/middleware" 12 "tangled.org/core/appview/notifications" 13 + "tangled.org/core/appview/pages" 14 "tangled.org/core/appview/pipelines" 15 "tangled.org/core/appview/pulls" 16 "tangled.org/core/appview/repo" ··· 109 }) 110 111 r.NotFound(func(w http.ResponseWriter, r *http.Request) { 112 + s.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: s.oauth.GetUser(r)}) 113 }) 114 115 return r ··· 180 r.Get("/brand", s.Brand) 181 182 r.NotFound(func(w http.ResponseWriter, r *http.Request) { 183 + s.pages.Error404(w, pages.ErrorPageParams{LoggedInUser: s.oauth.GetUser(r)}) 184 }) 185 return r 186 }
+2 -2
appview/strings/strings.go
··· 88 89 func (s *Strings) contents(w http.ResponseWriter, r *http.Request) { 90 l := s.Logger.With("handler", "contents") 91 92 id, ok := r.Context().Value("resolvedId").(identity.Identity) 93 if !ok { ··· 118 } 119 if len(strings) < 1 { 120 l.Error("string not found") 121 - s.Pages.Error404(w) 122 return 123 } 124 if len(strings) != 1 { ··· 152 if err != nil { 153 l.Error("failed to get star count", "err", err) 154 } 155 - user := s.OAuth.GetUser(r) 156 isStarred := false 157 if user != nil { 158 isStarred = db.GetStarStatus(s.Db, user.Did, string.AtUri())
··· 88 89 func (s *Strings) contents(w http.ResponseWriter, r *http.Request) { 90 l := s.Logger.With("handler", "contents") 91 + user := s.OAuth.GetUser(r) 92 93 id, ok := r.Context().Value("resolvedId").(identity.Identity) 94 if !ok { ··· 119 } 120 if len(strings) < 1 { 121 l.Error("string not found") 122 + s.Pages.Error404(w, pages.ErrorPageParams{LoggedInUser: user}) 123 return 124 } 125 if len(strings) != 1 { ··· 153 if err != nil { 154 l.Error("failed to get star count", "err", err) 155 } 156 isStarred := false 157 if user != nil { 158 isStarred = db.GetStarStatus(s.Db, user.Did, string.AtUri())