+8 -5

appview/db/issues.go

··· 101 101 pLower := FilterGte("row_num", page.Offset+1) 102 102 pUpper := FilterLte("row_num", page.Offset+page.Limit) 103 103 104 104 - args = append(args, pLower.Arg()...) 105 105 - args = append(args, pUpper.Arg()...) 106 106 - pagination := " where " + pLower.Condition() + " and " + pUpper.Condition() 104 104 + pageClause := "" 105 105 + if page.Limit > 0 { 106 106 + args = append(args, pLower.Arg()...) 107 107 + args = append(args, pUpper.Arg()...) 108 108 + pageClause = " where " + pLower.Condition() + " and " + pUpper.Condition() 109 109 + } 107 110 108 111 query := fmt.Sprintf( 109 112 ` ··· 128 131 %s 129 132 `, 130 133 whereClause, 131 131 - pagination, 134 134 + pageClause, 132 135 ) 133 136 134 137 rows, err := e.Query(query, args...) ··· 244 247 } 245 248 246 249 func GetIssues(e Execer, filters ...filter) ([]models.Issue, error) { 247 247 - return GetIssuesPaginated(e, pagination.FirstPage(), filters...) 250 250 + return GetIssuesPaginated(e, pagination.Page{}, filters...) 248 251 } 249 252 250 253 func AddIssueComment(e Execer, c models.IssueComment) (int64, error) {

+7 -4

appview/db/notifications.go

··· 60 60 whereClause += " AND " + condition 61 61 } 62 62 } 63 63 + pageClause := "" 64 64 + if page.Limit > 0 { 65 65 + pageClause = " limit ? offset ? " 66 66 + args = append(args, page.Limit, page.Offset) 67 67 + } 63 68 64 69 query := fmt.Sprintf(` 65 70 select id, recipient_did, actor_did, type, entity_type, entity_id, read, created, repo_id, issue_id, pull_id 66 71 from notifications 67 72 %s 68 73 order by created desc 69 69 - limit ? offset ? 70 70 - `, whereClause) 71 71 - 72 72 - args = append(args, page.Limit, page.Offset) 74 74 + %s 75 75 + `, whereClause, pageClause) 73 76 74 77 rows, err := e.QueryContext(context.Background(), query, args...) 75 78 if err != nil {

+13 -41

appview/issues/issues.go

··· 78 78 issue, ok := r.Context().Value("issue").(*models.Issue) 79 79 if !ok { 80 80 l.Error("failed to get issue") 81 81 - rp.pages.Error404(w, pages.ErrorPageParams{ 82 82 - LoggedInUser: user, 83 83 - }) 81 81 + rp.pages.Error404(w) 84 82 return 85 83 } 86 84 ··· 101 99 ) 102 100 if err != nil { 103 101 l.Error("failed to fetch labels", "err", err) 104 104 - rp.pages.Error503(w, pages.ErrorPageParams{ 105 105 - LoggedInUser: user, 106 106 - }) 102 102 + rp.pages.Error503(w) 107 103 return 108 104 } 109 105 ··· 136 132 issue, ok := r.Context().Value("issue").(*models.Issue) 137 133 if !ok { 138 134 l.Error("failed to get issue") 139 139 - rp.pages.Error404(w, pages.ErrorPageParams{ 140 140 - LoggedInUser: user, 141 141 - }) 135 135 + rp.pages.Error404(w) 142 136 return 143 137 } 144 138 ··· 281 275 issue, ok := r.Context().Value("issue").(*models.Issue) 282 276 if !ok { 283 277 l.Error("failed to get issue") 284 284 - rp.pages.Error404(w, pages.ErrorPageParams{ 285 285 - LoggedInUser: user, 286 286 - }) 278 278 + rp.pages.Error404(w) 287 279 return 288 280 } 289 281 ··· 332 324 issue, ok := r.Context().Value("issue").(*models.Issue) 333 325 if !ok { 334 326 l.Error("failed to get issue") 335 335 - rp.pages.Error404(w, pages.ErrorPageParams{ 336 336 - LoggedInUser: user, 337 337 - }) 327 327 + rp.pages.Error404(w) 338 328 return 339 329 } 340 330 ··· 378 368 issue, ok := r.Context().Value("issue").(*models.Issue) 379 369 if !ok { 380 370 l.Error("failed to get issue") 381 381 - rp.pages.Error404(w, pages.ErrorPageParams{ 382 382 - LoggedInUser: user, 383 383 - }) 371 371 + rp.pages.Error404(w) 384 372 return 385 373 } 386 374 ··· 468 456 issue, ok := r.Context().Value("issue").(*models.Issue) 469 457 if !ok { 470 458 l.Error("failed to get issue") 471 471 - rp.pages.Error404(w, pages.ErrorPageParams{ 472 472 - LoggedInUser: user, 473 473 - }) 459 459 + rp.pages.Error404(w) 474 460 return 475 461 } 476 462 ··· 511 497 issue, ok := r.Context().Value("issue").(*models.Issue) 512 498 if !ok { 513 499 l.Error("failed to get issue") 514 514 - rp.pages.Error404(w, pages.ErrorPageParams{ 515 515 - LoggedInUser: user, 516 516 - }) 500 500 + rp.pages.Error404(w) 517 501 return 518 502 } 519 503 ··· 617 601 issue, ok := r.Context().Value("issue").(*models.Issue) 618 602 if !ok { 619 603 l.Error("failed to get issue") 620 620 - rp.pages.Error404(w, pages.ErrorPageParams{ 621 621 - LoggedInUser: user, 622 622 - }) 604 604 + rp.pages.Error404(w) 623 605 return 624 606 } 625 607 ··· 660 642 issue, ok := r.Context().Value("issue").(*models.Issue) 661 643 if !ok { 662 644 l.Error("failed to get issue") 663 663 - rp.pages.Error404(w, pages.ErrorPageParams{ 664 664 - LoggedInUser: user, 665 665 - }) 645 645 + rp.pages.Error404(w) 666 646 return 667 647 } 668 648 ··· 703 683 issue, ok := r.Context().Value("issue").(*models.Issue) 704 684 if !ok { 705 685 l.Error("failed to get issue") 706 706 - rp.pages.Error404(w, pages.ErrorPageParams{ 707 707 - LoggedInUser: user, 708 708 - }) 686 686 + rp.pages.Error404(w) 709 687 return 710 688 } 711 689 ··· 792 770 isOpen = true 793 771 } 794 772 795 795 - page, ok := r.Context().Value("page").(pagination.Page) 796 796 - if !ok { 797 797 - l.Error("failed to get page") 798 798 - page = pagination.FirstPage() 799 799 - } 773 773 + page := pagination.FromContext(r.Context()) 800 774 801 775 user := rp.oauth.GetUser(r) 802 776 f, err := rp.repoResolver.Resolve(r) ··· 828 802 ) 829 803 if err != nil { 830 804 l.Error("failed to fetch labels", "err", err) 831 831 - rp.pages.Error503(w, pages.ErrorPageParams{ 832 832 - LoggedInUser: user, 833 833 - }) 805 805 + rp.pages.Error503(w) 834 806 return 835 807 } 836 808

+7 -21

appview/middleware/middleware.go

··· 105 105 } 106 106 } 107 107 108 108 - ctx := context.WithValue(r.Context(), "page", page) 108 108 + ctx := pagination.IntoContext(r.Context(), page) 109 109 next.ServeHTTP(w, r.WithContext(ctx)) 110 110 }) 111 111 } ··· 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, pages.ErrorPageParams{}) 194 194 + mw.pages.Error404(w) 195 195 return 196 196 } 197 197 ··· 206 206 return func(next http.Handler) http.Handler { 207 207 return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { 208 208 repoName := chi.URLParam(req, "repo") 209 209 - user := mw.oauth.GetUser(req) 210 209 id, ok := req.Context().Value("resolvedId").(identity.Identity) 211 210 if !ok { 212 211 log.Println("malformed middleware") ··· 221 220 ) 222 221 if err != nil { 223 222 log.Println("failed to resolve repo", "err", err) 224 224 - mw.pages.ErrorKnot404(w, pages.ErrorPageParams{ 225 225 - LoggedInUser: user, 226 226 - }) 223 223 + mw.pages.ErrorKnot404(w) 227 224 return 228 225 } 229 226 ··· 238 235 return func(next http.Handler) http.Handler { 239 236 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 240 237 f, err := mw.repoResolver.Resolve(r) 241 241 - user := mw.oauth.GetUser(r) 242 238 if err != nil { 243 239 log.Println("failed to fully resolve repo", err) 244 244 - mw.pages.ErrorKnot404(w, pages.ErrorPageParams{ 245 245 - LoggedInUser: user, 246 246 - }) 240 240 + mw.pages.ErrorKnot404(w) 247 241 return 248 242 } 249 243 ··· 288 282 func (mw Middleware) ResolveIssue(next http.Handler) http.Handler { 289 283 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 290 284 f, err := mw.repoResolver.Resolve(r) 291 291 - user := mw.oauth.GetUser(r) 292 285 if err != nil { 293 286 log.Println("failed to fully resolve repo", err) 294 294 - mw.pages.ErrorKnot404(w, pages.ErrorPageParams{ 295 295 - LoggedInUser: user, 296 296 - }) 287 287 + mw.pages.ErrorKnot404(w) 297 288 return 298 289 } 299 290 ··· 301 292 issueId, err := strconv.Atoi(issueIdStr) 302 293 if err != nil { 303 294 log.Println("failed to fully resolve issue ID", err) 304 304 - mw.pages.ErrorKnot404(w, pages.ErrorPageParams{ 305 305 - LoggedInUser: user, 306 306 - }) 295 295 + mw.pages.ErrorKnot404(w) 307 296 return 308 297 } 309 298 ··· 337 326 return func(next http.Handler) http.Handler { 338 327 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 339 328 f, err := mw.repoResolver.Resolve(r) 340 340 - user := mw.oauth.GetUser(r) 341 329 if err != nil { 342 330 log.Println("failed to fully resolve repo", err) 343 343 - mw.pages.ErrorKnot404(w, pages.ErrorPageParams{ 344 344 - LoggedInUser: user, 345 345 - }) 331 331 + mw.pages.ErrorKnot404(w) 346 332 return 347 333 } 348 334

+3 -11

appview/notifications/notifications.go

··· 49 49 l := n.logger.With("handler", "notificationsPage") 50 50 user := n.oauth.GetUser(r) 51 51 52 52 - page, ok := r.Context().Value("page").(pagination.Page) 53 53 - if !ok { 54 54 - l.Error("failed to get page") 55 55 - page = pagination.FirstPage() 56 56 - } 52 52 + page := pagination.FromContext(r.Context()) 57 53 58 54 total, err := db.CountNotifications( 59 55 n.db, ··· 61 57 ) 62 58 if err != nil { 63 59 l.Error("failed to get total notifications", "err", err) 64 64 - n.pages.Error500(w, pages.ErrorPageParams{ 65 65 - LoggedInUser: user, 66 66 - }) 60 60 + n.pages.Error500(w) 67 61 return 68 62 } 69 63 ··· 74 68 ) 75 69 if err != nil { 76 70 l.Error("failed to get notifications", "err", err) 77 77 - n.pages.Error500(w, pages.ErrorPageParams{ 78 78 - LoggedInUser: user, 79 79 - }) 71 71 + n.pages.Error500(w) 80 72 return 81 73 } 82 74

+13 -2

appview/oauth/handler.go

··· 4 4 "bytes" 5 5 "context" 6 6 "encoding/json" 7 7 + "errors" 7 8 "fmt" 8 9 "net/http" 9 10 "slices" 10 11 "time" 11 12 13 13 + "github.com/bluesky-social/indigo/atproto/auth/oauth" 12 14 "github.com/go-chi/chi/v5" 13 15 "github.com/lestrrat-go/jwx/v2/jwk" 14 16 "github.com/posthog/posthog-go" ··· 58 60 59 61 func (o *OAuth) callback(w http.ResponseWriter, r *http.Request) { 60 62 ctx := r.Context() 63 63 + l := o.Logger.With("query", r.URL.Query()) 61 64 62 65 sessData, err := o.ClientApp.ProcessCallback(ctx, r.URL.Query()) 63 66 if err != nil { 64 64 - http.Error(w, err.Error(), http.StatusInternalServerError) 67 67 + var callbackErr *oauth.AuthRequestCallbackError 68 68 + if errors.As(err, &callbackErr) { 69 69 + l.Debug("callback error", "err", callbackErr) 70 70 + http.Redirect(w, r, fmt.Sprintf("/login?error=%s", callbackErr.ErrorCode), http.StatusFound) 71 71 + return 72 72 + } 73 73 + l.Error("failed to process callback", "err", err) 74 74 + http.Redirect(w, r, "/login?error=oauth", http.StatusFound) 65 75 return 66 76 } 67 77 68 78 if err := o.SaveSession(w, r, sessData); err != nil { 69 69 - http.Error(w, err.Error(), http.StatusInternalServerError) 79 79 + l.Error("failed to save session", "data", sessData, "err", err) 80 80 + http.Redirect(w, r, "/login?error=session", http.StatusFound) 70 81 return 71 82 } 72 83

+4 -1

appview/oauth/oauth.go

··· 58 58 59 59 sessStore := sessions.NewCookieStore([]byte(config.Core.CookieSecret)) 60 60 61 61 + clientApp := oauth.NewClientApp(&oauthConfig, authStore) 62 62 + clientApp.Dir = res.Directory() 63 63 + 61 64 return &OAuth{ 62 62 - ClientApp: oauth.NewClientApp(&oauthConfig, authStore), 65 65 + ClientApp: clientApp, 63 66 Config: config, 64 67 SessStore: sessStore, 65 68 JwksUri: jwksUri,

+3 -2

appview/pages/funcmap.go

··· 297 297 }, 298 298 299 299 "normalizeForHtmlId": func(s string) string { 300 300 - // TODO: extend this to handle other cases? 301 301 - return strings.ReplaceAll(s, ":", "_") 300 300 + normalized := strings.ReplaceAll(s, ":", "_") 301 301 + normalized = strings.ReplaceAll(normalized, ".", "_") 302 302 + return normalized 302 303 }, 303 304 "sshFingerprint": func(pubKey string) string { 304 305 fp, err := crypto.SSHFingerprint(pubKey)

+9 -12

appview/pages/pages.go

··· 221 221 222 222 type LoginParams struct { 223 223 ReturnUrl string 224 224 + ErrorCode string 224 225 } 225 226 226 227 func (p *Pages) Login(w io.Writer, params LoginParams) error { ··· 1381 1382 Active string 1382 1383 } 1383 1384 1384 1384 - type ErrorPageParams struct { 1385 1385 - LoggedInUser *oauth.User 1386 1386 - } 1387 1387 - 1388 1385 func (p *Pages) Workflow(w io.Writer, params WorkflowParams) error { 1389 1386 params.Active = "pipelines" 1390 1387 return p.executeRepo("repo/pipelines/workflow", w, params) ··· 1522 1519 return hex.EncodeToString(hasher.Sum(nil))[:8] // Use first 8 chars of hash 1523 1520 } 1524 1521 1525 1525 - func (p *Pages) Error500(w io.Writer, params ErrorPageParams) error { 1526 1526 - return p.execute("errors/500", w, params) 1522 1522 + func (p *Pages) Error500(w io.Writer) error { 1523 1523 + return p.execute("errors/500", w, nil) 1527 1524 } 1528 1525 1529 1529 - func (p *Pages) Error404(w io.Writer, params ErrorPageParams) error { 1530 1530 - return p.execute("errors/404", w, params) 1526 1526 + func (p *Pages) Error404(w io.Writer) error { 1527 1527 + return p.execute("errors/404", w, nil) 1531 1528 } 1532 1529 1533 1533 - func (p *Pages) ErrorKnot404(w io.Writer, params ErrorPageParams) error { 1534 1534 - return p.execute("errors/knot404", w, params) 1530 1530 + func (p *Pages) ErrorKnot404(w io.Writer) error { 1531 1531 + return p.execute("errors/knot404", w, nil) 1535 1532 } 1536 1533 1537 1537 - func (p *Pages) Error503(w io.Writer, params ErrorPageParams) error { 1538 1538 - return p.execute("errors/503", w, params) 1534 1534 + func (p *Pages) Error503(w io.Writer) error { 1535 1535 + return p.execute("errors/503", w, nil) 1539 1536 }

+1 -1

appview/pages/templates/strings/string.html

··· 47 47 </span> 48 48 </section> 49 49 <section class="bg-white dark:bg-gray-800 px-6 py-4 rounded relative w-full dark:text-white"> 50 50 - <div class="flex justify-between items-center text-gray-500 dark:text-gray-400 text-sm md:text-base pb-2 mb-3 text-base border-b border-gray-200 dark:border-gray-700"> 50 50 + <div class="flex flex-col md:flex-row md:justify-between md:items-center text-gray-500 dark:text-gray-400 text-sm md:text-base pb-2 mb-3 text-base border-b border-gray-200 dark:border-gray-700"> 51 51 <span> 52 52 {{ .String.Filename }} 53 53 <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

+1 -1

appview/pages/templates/user/fragments/followCard.html

··· 3 3 <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 rounded-sm"> 4 4 <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800 flex items-center gap-4"> 5 5 <div class="flex-shrink-0 max-h-full w-24 h-24"> 6 6 - <img class="object-cover rounded-full p-2" src="{{ fullAvatar $userIdent }}" /> 6 6 + <img class="object-cover rounded-full p-2" src="{{ fullAvatar $userIdent }}" alt="{{ $userIdent }}" /> 7 7 </div> 8 8 9 9 <div class="flex flex-col md:flex-row md:items-center md:justify-between gap-2 w-full">

+20 -2

appview/pages/templates/user/login.html

··· 13 13 <title>login &middot; tangled</title> 14 14 </head> 15 15 <body class="flex items-center justify-center min-h-screen"> 16 16 - <main class="max-w-md px-6 -mt-4"> 16 16 + <main class="max-w-md px-7 mt-4"> 17 17 <h1 class="flex place-content-center text-3xl font-semibold italic dark:text-white" > 18 18 {{ template "fragments/logotype" }} 19 19 </h1> ··· 21 21 tightly-knit social coding. 22 22 </h2> 23 23 <form 24 24 - class="mt-4 max-w-sm mx-auto" 24 24 + class="mt-4" 25 25 hx-post="/login" 26 26 hx-swap="none" 27 27 hx-disabled-elt="#login-button" ··· 56 56 <span>login</span> 57 57 </button> 58 58 </form> 59 59 + {{ if .ErrorCode }} 60 60 + <div class="flex gap-2 my-2 bg-red-50 dark:bg-red-900 border border-red-500 rounded drop-shadow-sm px-3 py-2 text-red-500 dark:text-red-300"> 61 61 + <span class="py-1">{{ i "circle-alert" "w-4 h-4" }}</span> 62 62 + <div> 63 63 + <h5 class="font-medium">Login error</h5> 64 64 + <p class="text-sm"> 65 65 + {{ if eq .ErrorCode "access_denied" }} 66 66 + You have not authorized the app. 67 67 + {{ else if eq .ErrorCode "session" }} 68 68 + Server failed to create user session. 69 69 + {{ else }} 70 70 + Internal Server error. 71 71 + {{ end }} 72 72 + Please try again. 73 73 + </p> 74 74 + </div> 75 75 + </div> 76 76 + {{ end }} 59 77 <p class="text-sm text-gray-500"> 60 78 Don't have an account? <a href="/signup" class="underline">Create an account</a> on Tangled now! 61 79 </p>

+23

appview/pagination/page.go

··· 1 1 package pagination 2 2 3 3 + import "context" 4 4 + 3 5 type Page struct { 4 6 Offset int // where to start from 5 7 Limit int // number of items in a page ··· 10 12 Offset: 0, 11 13 Limit: 30, 12 14 } 15 15 + } 16 16 + 17 17 + type ctxKey struct{} 18 18 + 19 19 + func IntoContext(ctx context.Context, page Page) context.Context { 20 20 + return context.WithValue(ctx, ctxKey{}, page) 21 21 + } 22 22 + 23 23 + func FromContext(ctx context.Context) Page { 24 24 + if ctx == nil { 25 25 + return FirstPage() 26 26 + } 27 27 + v := ctx.Value(ctxKey{}) 28 28 + if v == nil { 29 29 + return FirstPage() 30 30 + } 31 31 + page, ok := v.(Page) 32 32 + if !ok { 33 33 + return FirstPage() 34 34 + } 35 35 + return page 13 36 } 14 37 15 38 func (p Page) Previous() Page {

+10 -30

appview/pulls/pulls.go

··· 205 205 ) 206 206 if err != nil { 207 207 log.Println("failed to fetch labels", err) 208 208 - s.pages.Error503(w, pages.ErrorPageParams{ 209 209 - LoggedInUser: user, 210 210 - }) 208 208 + s.pages.Error503(w) 211 209 return 212 210 } 213 211 ··· 638 636 ) 639 637 if err != nil { 640 638 log.Println("failed to fetch labels", err) 641 641 - s.pages.Error503(w, pages.ErrorPageParams{ 642 642 - LoggedInUser: user, 643 643 - }) 639 639 + s.pages.Error503(w) 644 640 return 645 641 } 646 642 ··· 789 785 if err != nil { 790 786 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 791 787 log.Println("failed to call XRPC repo.branches", xrpcerr) 792 792 - s.pages.Error503(w, pages.ErrorPageParams{ 793 793 - LoggedInUser: user, 794 794 - }) 788 788 + s.pages.Error503(w) 795 789 return 796 790 } 797 791 log.Println("failed to fetch branches", err) ··· 801 795 var result types.RepoBranchesResponse 802 796 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 803 797 log.Println("failed to decode XRPC response", err) 804 804 - s.pages.Error503(w, pages.ErrorPageParams{ 805 805 - LoggedInUser: user, 806 806 - }) 798 798 + s.pages.Error503(w) 807 799 return 808 800 } 809 801 ··· 1400 1392 if err != nil { 1401 1393 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1402 1394 log.Println("failed to call XRPC repo.branches", xrpcerr) 1403 1403 - s.pages.Error503(w, pages.ErrorPageParams{ 1404 1404 - LoggedInUser: user, 1405 1405 - }) 1395 1395 + s.pages.Error503(w) 1406 1396 return 1407 1397 } 1408 1398 log.Println("failed to fetch branches", err) ··· 1412 1402 var result types.RepoBranchesResponse 1413 1403 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 1414 1404 log.Println("failed to decode XRPC response", err) 1415 1415 - s.pages.Error503(w, pages.ErrorPageParams{ 1416 1416 - LoggedInUser: user, 1417 1417 - }) 1405 1405 + s.pages.Error503(w) 1418 1406 return 1419 1407 } 1420 1408 ··· 1496 1484 if err != nil { 1497 1485 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1498 1486 log.Println("failed to call XRPC repo.branches for source", xrpcerr) 1499 1499 - s.pages.Error503(w, pages.ErrorPageParams{ 1500 1500 - LoggedInUser: user, 1501 1501 - }) 1487 1487 + s.pages.Error503(w) 1502 1488 return 1503 1489 } 1504 1490 log.Println("failed to fetch source branches", err) ··· 1509 1495 var sourceBranches types.RepoBranchesResponse 1510 1496 if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil { 1511 1497 log.Println("failed to decode source branches XRPC response", err) 1512 1512 - s.pages.Error503(w, pages.ErrorPageParams{ 1513 1513 - LoggedInUser: user, 1514 1514 - }) 1498 1498 + s.pages.Error503(w) 1515 1499 return 1516 1500 } 1517 1501 ··· 1529 1513 if err != nil { 1530 1514 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1531 1515 log.Println("failed to call XRPC repo.branches for target", xrpcerr) 1532 1532 - s.pages.Error503(w, pages.ErrorPageParams{ 1533 1533 - LoggedInUser: user, 1534 1534 - }) 1516 1516 + s.pages.Error503(w) 1535 1517 return 1536 1518 } 1537 1519 log.Println("failed to fetch target branches", err) ··· 1542 1524 var targetBranches types.RepoBranchesResponse 1543 1525 if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil { 1544 1526 log.Println("failed to decode target branches XRPC response", err) 1545 1545 - s.pages.Error503(w, pages.ErrorPageParams{ 1546 1546 - LoggedInUser: user, 1547 1547 - }) 1527 1527 + s.pages.Error503(w) 1548 1528 return 1549 1529 } 1550 1530

+2 -8

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" 14 13 "tangled.org/core/appview/pagination" 15 14 "tangled.org/core/appview/reporesolver" 16 15 ··· 153 152 log.Println("failed to fully resolve repo:", err) 154 153 return 155 154 } 156 156 - user := rp.oauth.GetUser(r) 157 155 158 156 feed, err := rp.getRepoFeed(r.Context(), f) 159 157 if err != nil { 160 158 log.Println("failed to get repo feed:", err) 161 161 - rp.pages.Error500(w, pages.ErrorPageParams{ 162 162 - LoggedInUser: user, 163 163 - }) 159 159 + rp.pages.Error500(w) 164 160 return 165 161 } 166 162 167 163 atom, err := feed.ToAtom() 168 164 if err != nil { 169 169 - rp.pages.Error500(w, pages.ErrorPageParams{ 170 170 - LoggedInUser: user, 171 171 - }) 165 165 + rp.pages.Error500(w) 172 166 return 173 167 } 174 168

+1 -3

appview/repo/index.go

··· 67 67 return 68 68 } 69 69 70 70 - rp.pages.Error503(w, pages.ErrorPageParams{ 71 71 - LoggedInUser: user, 72 72 - }) 70 70 + rp.pages.Error503(w) 73 71 l.Error("failed to build index response", "err", err) 74 72 return 75 73 }

+34 -83

appview/repo/repo.go

··· 90 90 91 91 func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) { 92 92 l := rp.logger.With("handler", "DownloadArchive") 93 93 - user := rp.oauth.GetUser(r) 94 93 95 94 ref := chi.URLParam(r, "ref") 96 95 ref, _ = url.PathUnescape(ref) ··· 114 113 archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo) 115 114 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 116 115 l.Error("failed to call XRPC repo.archive", "err", xrpcerr) 117 117 - rp.pages.Error503(w, pages.ErrorPageParams{ 118 118 - LoggedInUser: user, 119 119 - }) 116 116 + rp.pages.Error503(w) 120 117 return 121 118 } 122 119 ··· 133 130 134 131 func (rp *Repo) RepoLog(w http.ResponseWriter, r *http.Request) { 135 132 l := rp.logger.With("handler", "RepoLog") 136 136 - user := rp.oauth.GetUser(r) 137 133 138 134 f, err := rp.repoResolver.Resolve(r) 139 135 if err != nil { ··· 173 169 xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo) 174 170 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 175 171 l.Error("failed to call XRPC repo.log", "err", xrpcerr) 176 176 - rp.pages.Error503(w, pages.ErrorPageParams{ 177 177 - LoggedInUser: user, 178 178 - }) 172 172 + rp.pages.Error503(w) 179 173 return 180 174 } 181 175 182 176 var xrpcResp types.RepoLogResponse 183 177 if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil { 184 178 l.Error("failed to decode XRPC response", "err", err) 185 185 - rp.pages.Error503(w, pages.ErrorPageParams{ 186 186 - LoggedInUser: user, 187 187 - }) 179 179 + rp.pages.Error503(w) 188 180 return 189 181 } 190 182 191 183 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 192 184 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 193 185 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 194 194 - rp.pages.Error503(w, pages.ErrorPageParams{ 195 195 - LoggedInUser: user, 196 196 - }) 186 186 + rp.pages.Error503(w) 197 187 return 198 188 } 199 189 ··· 214 204 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 215 205 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 216 206 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 217 217 - rp.pages.Error503(w, pages.ErrorPageParams{ 218 218 - LoggedInUser: user, 219 219 - }) 207 207 + rp.pages.Error503(w) 220 208 return 221 209 } 222 210 ··· 228 216 } 229 217 } 230 218 } 219 219 + 220 220 + user := rp.oauth.GetUser(r) 231 221 232 222 emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true) 233 223 if err != nil { ··· 363 353 364 354 func (rp *Repo) RepoCommit(w http.ResponseWriter, r *http.Request) { 365 355 l := rp.logger.With("handler", "RepoCommit") 366 366 - user := rp.oauth.GetUser(r) 367 356 368 357 f, err := rp.repoResolver.Resolve(r) 369 358 if err != nil { ··· 379 368 } 380 369 381 370 if !plumbing.IsHash(ref) { 382 382 - rp.pages.Error404(w, pages.ErrorPageParams{ 383 383 - LoggedInUser: user, 384 384 - }) 371 371 + rp.pages.Error404(w) 385 372 return 386 373 } 387 374 ··· 398 385 xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo) 399 386 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 400 387 l.Error("failed to call XRPC repo.diff", "err", xrpcerr) 401 401 - rp.pages.Error503(w, pages.ErrorPageParams{ 402 402 - LoggedInUser: user, 403 403 - }) 388 388 + rp.pages.Error503(w) 404 389 return 405 390 } 406 391 407 392 var result types.RepoCommitResponse 408 393 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 409 394 l.Error("failed to decode XRPC response", "err", err) 410 410 - rp.pages.Error503(w, pages.ErrorPageParams{ 411 411 - LoggedInUser: user, 412 412 - }) 395 395 + rp.pages.Error503(w) 413 396 return 414 397 } 415 398 ··· 423 406 l.Error("failed to GetVerifiedCommits", "err", err) 424 407 } 425 408 409 409 + user := rp.oauth.GetUser(r) 426 410 repoInfo := f.RepoInfo(user) 427 411 pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This}) 428 412 if err != nil { ··· 447 431 448 432 func (rp *Repo) RepoTree(w http.ResponseWriter, r *http.Request) { 449 433 l := rp.logger.With("handler", "RepoTree") 450 450 - user := rp.oauth.GetUser(r) 451 434 452 435 f, err := rp.repoResolver.Resolve(r) 453 436 if err != nil { ··· 477 460 xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo) 478 461 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 479 462 l.Error("failed to call XRPC repo.tree", "err", xrpcerr) 480 480 - rp.pages.Error503(w, pages.ErrorPageParams{ 481 481 - LoggedInUser: user, 482 482 - }) 463 463 + rp.pages.Error503(w) 483 464 return 484 465 } 485 466 ··· 530 511 http.Redirect(w, r, redirectTo, http.StatusFound) 531 512 return 532 513 } 514 514 + 515 515 + user := rp.oauth.GetUser(r) 533 516 534 517 var breadcrumbs [][]string 535 518 breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))}) ··· 552 535 553 536 func (rp *Repo) RepoTags(w http.ResponseWriter, r *http.Request) { 554 537 l := rp.logger.With("handler", "RepoTags") 555 555 - user := rp.oauth.GetUser(r) 556 538 557 539 f, err := rp.repoResolver.Resolve(r) 558 540 if err != nil { ··· 573 555 xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 574 556 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 575 557 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 576 576 - rp.pages.Error503(w, pages.ErrorPageParams{ 577 577 - LoggedInUser: user, 578 578 - }) 558 558 + rp.pages.Error503(w) 579 559 return 580 560 } 581 561 582 562 var result types.RepoTagsResponse 583 563 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 584 564 l.Error("failed to decode XRPC response", "err", err) 585 585 - rp.pages.Error503(w, pages.ErrorPageParams{ 586 586 - LoggedInUser: user, 587 587 - }) 565 565 + rp.pages.Error503(w) 588 566 return 589 567 } 590 568 ··· 616 594 } 617 595 } 618 596 597 597 + user := rp.oauth.GetUser(r) 619 598 rp.pages.RepoTags(w, pages.RepoTagsParams{ 620 599 LoggedInUser: user, 621 600 RepoInfo: f.RepoInfo(user), ··· 627 606 628 607 func (rp *Repo) RepoBranches(w http.ResponseWriter, r *http.Request) { 629 608 l := rp.logger.With("handler", "RepoBranches") 630 630 - user := rp.oauth.GetUser(r) 631 609 632 610 f, err := rp.repoResolver.Resolve(r) 633 611 if err != nil { ··· 648 626 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 649 627 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 650 628 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 651 651 - rp.pages.Error503(w, pages.ErrorPageParams{ 652 652 - LoggedInUser: user, 653 653 - }) 629 629 + rp.pages.Error503(w) 654 630 return 655 631 } 656 632 657 633 var result types.RepoBranchesResponse 658 634 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 659 635 l.Error("failed to decode XRPC response", "err", err) 660 660 - rp.pages.Error503(w, pages.ErrorPageParams{ 661 661 - LoggedInUser: user, 662 662 - }) 636 636 + rp.pages.Error503(w) 663 637 return 664 638 } 665 639 666 640 sortBranches(result.Branches) 667 641 642 642 + user := rp.oauth.GetUser(r) 668 643 rp.pages.RepoBranches(w, pages.RepoBranchesParams{ 669 644 LoggedInUser: user, 670 645 RepoInfo: f.RepoInfo(user), ··· 723 698 724 699 func (rp *Repo) RepoBlob(w http.ResponseWriter, r *http.Request) { 725 700 l := rp.logger.With("handler", "RepoBlob") 726 726 - user := rp.oauth.GetUser(r) 727 701 728 702 f, err := rp.repoResolver.Resolve(r) 729 703 if err != nil { ··· 750 724 resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo) 751 725 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 752 726 l.Error("failed to call XRPC repo.blob", "err", xrpcerr) 753 753 - rp.pages.Error503(w, pages.ErrorPageParams{ 754 754 - LoggedInUser: user, 755 755 - }) 727 727 + rp.pages.Error503(w) 756 728 return 757 729 } 758 730 ··· 824 796 sizeHint = uint64(len(resp.Content)) 825 797 } 826 798 799 799 + user := rp.oauth.GetUser(r) 800 800 + 827 801 // Determine if content is binary (dereference pointer) 828 802 isBinary := false 829 803 if resp.IsBinary != nil { ··· 850 824 851 825 func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) { 852 826 l := rp.logger.With("handler", "RepoBlobRaw") 853 853 - user := rp.oauth.GetUser(r) 854 827 855 828 f, err := rp.repoResolver.Resolve(r) 856 829 if err != nil { ··· 899 872 resp, err := client.Do(req) 900 873 if err != nil { 901 874 l.Error("failed to reach knotserver", "err", err) 902 902 - rp.pages.Error503(w, pages.ErrorPageParams{ 903 903 - LoggedInUser: user, 904 904 - }) 875 875 + rp.pages.Error503(w) 905 876 return 906 877 } 907 878 defer resp.Body.Close() ··· 1992 1963 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 1993 1964 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1994 1965 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 1995 1995 - rp.pages.Error503(w, pages.ErrorPageParams{ 1996 1996 - LoggedInUser: user, 1997 1997 - }) 1966 1966 + rp.pages.Error503(w) 1998 1967 return 1999 1968 } 2000 1969 2001 1970 var result types.RepoBranchesResponse 2002 1971 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 2003 1972 l.Error("failed to decode XRPC response", "err", err) 2004 2004 - rp.pages.Error503(w, pages.ErrorPageParams{ 2005 2005 - LoggedInUser: user, 2006 2006 - }) 1973 1973 + rp.pages.Error503(w) 2007 1974 return 2008 1975 } 2009 1976 2010 1977 defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", models.DefaultLabelDefs())) 2011 1978 if err != nil { 2012 1979 l.Error("failed to fetch labels", "err", err) 2013 2013 - rp.pages.Error503(w, pages.ErrorPageParams{ 2014 2014 - LoggedInUser: user, 2015 2015 - }) 1980 1980 + rp.pages.Error503(w) 2016 1981 return 2017 1982 } 2018 1983 2019 1984 labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels)) 2020 1985 if err != nil { 2021 1986 l.Error("failed to fetch labels", "err", err) 2022 2022 - rp.pages.Error503(w, pages.ErrorPageParams{ 2023 2023 - LoggedInUser: user, 2024 2024 - }) 1987 1987 + rp.pages.Error503(w) 2025 1988 return 2026 1989 } 2027 1990 // remove default labels from the labels list, if present ··· 2455 2418 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 2456 2419 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2457 2420 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 2458 2458 - rp.pages.Error503(w, pages.ErrorPageParams{ 2459 2459 - LoggedInUser: user, 2460 2460 - }) 2421 2421 + rp.pages.Error503(w) 2461 2422 return 2462 2423 } 2463 2424 ··· 2494 2455 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 2495 2456 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2496 2457 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 2497 2497 - rp.pages.Error503(w, pages.ErrorPageParams{ 2498 2498 - LoggedInUser: user, 2499 2499 - }) 2458 2458 + rp.pages.Error503(w) 2500 2459 return 2501 2460 } 2502 2461 ··· 2553 2512 2554 2513 if base == "" || head == "" { 2555 2514 l.Error("invalid comparison") 2556 2556 - rp.pages.Error404(w, pages.ErrorPageParams{ 2557 2557 - LoggedInUser: user, 2558 2558 - }) 2515 2515 + rp.pages.Error404(w) 2559 2516 return 2560 2517 } 2561 2518 ··· 2573 2530 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 2574 2531 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2575 2532 l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 2576 2576 - rp.pages.Error503(w, pages.ErrorPageParams{ 2577 2577 - LoggedInUser: user, 2578 2578 - }) 2533 2533 + rp.pages.Error503(w) 2579 2534 return 2580 2535 } 2581 2536 ··· 2589 2544 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 2590 2545 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2591 2546 l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 2592 2592 - rp.pages.Error503(w, pages.ErrorPageParams{ 2593 2593 - LoggedInUser: user, 2594 2594 - }) 2547 2547 + rp.pages.Error503(w) 2595 2548 return 2596 2549 } 2597 2550 ··· 2605 2558 compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head) 2606 2559 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2607 2560 l.Error("failed to call XRPC repo.compare", "err", xrpcerr) 2608 2608 - rp.pages.Error503(w, pages.ErrorPageParams{ 2609 2609 - LoggedInUser: user, 2610 2610 - }) 2561 2561 + rp.pages.Error503(w) 2611 2562 return 2612 2563 } 2613 2564

+1

appview/state/follow.go

··· 26 26 subjectIdent, err := s.idResolver.ResolveIdent(r.Context(), subject) 27 27 if err != nil { 28 28 log.Println("failed to follow, invalid did") 29 29 + return 29 30 } 30 31 31 32 if currentUser.Did == subjectIdent.DID.String() {

+3 -10

appview/state/gfi.go

··· 18 18 func (s *State) GoodFirstIssues(w http.ResponseWriter, r *http.Request) { 19 19 user := s.oauth.GetUser(r) 20 20 21 21 - page, ok := r.Context().Value("page").(pagination.Page) 22 22 - if !ok { 23 23 - page = pagination.FirstPage() 24 24 - } 21 21 + page := pagination.FromContext(r.Context()) 25 22 26 23 goodFirstIssueLabel := fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, "good-first-issue") 27 24 28 25 repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel)) 29 26 if err != nil { 30 27 log.Println("failed to get repo labels", err) 31 31 - s.pages.Error503(w, pages.ErrorPageParams{ 32 32 - LoggedInUser: user, 33 33 - }) 28 28 + s.pages.Error503(w) 34 29 return 35 30 } 36 31 ··· 59 54 ) 60 55 if err != nil { 61 56 log.Println("failed to get issues", err) 62 62 - s.pages.Error503(w, pages.ErrorPageParams{ 63 63 - LoggedInUser: user, 64 64 - }) 57 57 + s.pages.Error503(w) 65 58 return 66 59 } 67 60

+2

appview/state/login.go

··· 14 14 switch r.Method { 15 15 case http.MethodGet: 16 16 returnURL := r.URL.Query().Get("return_url") 17 17 + errorCode := r.URL.Query().Get("error") 17 18 s.pages.Login(w, pages.LoginParams{ 18 19 ReturnUrl: returnURL, 20 20 + ErrorCode: errorCode, 19 21 }) 20 22 case http.MethodPost: 21 23 handle := r.FormValue("handle")

+10 -36

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) 116 115 117 116 profile, err := s.profile(r) 118 117 if err != nil { 119 118 l.Error("failed to build profile card", "err", err) 120 120 - s.pages.Error500(w, pages.ErrorPageParams{ 121 121 - LoggedInUser: user, 122 122 - }) 119 119 + s.pages.Error500(w) 123 120 return 124 121 } 125 122 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 176 173 177 174 func (s *State) reposPage(w http.ResponseWriter, r *http.Request) { 178 175 l := s.logger.With("handler", "reposPage") 179 179 - user := s.oauth.GetUser(r) 180 176 181 177 profile, err := s.profile(r) 182 178 if err != nil { 183 179 l.Error("failed to build profile card", "err", err) 184 184 - s.pages.Error500(w, pages.ErrorPageParams{ 185 185 - LoggedInUser: user, 186 186 - }) 180 180 + s.pages.Error500(w) 187 181 return 188 182 } 189 183 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 195 189 ) 196 190 if err != nil { 197 191 l.Error("failed to get repos", "err", err) 198 198 - s.pages.Error500(w, pages.ErrorPageParams{ 199 199 - LoggedInUser: user, 200 200 - }) 192 192 + s.pages.Error500(w) 201 193 return 202 194 } 203 195 ··· 210 202 211 203 func (s *State) starredPage(w http.ResponseWriter, r *http.Request) { 212 204 l := s.logger.With("handler", "starredPage") 213 213 - user := s.oauth.GetUser(r) 214 205 215 206 profile, err := s.profile(r) 216 207 if err != nil { 217 208 l.Error("failed to build profile card", "err", err) 218 218 - s.pages.Error500(w, pages.ErrorPageParams{ 219 219 - LoggedInUser: user, 220 220 - }) 209 209 + s.pages.Error500(w) 221 210 return 222 211 } 223 212 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 225 214 stars, err := db.GetStars(s.db, 0, db.FilterEq("starred_by_did", profile.UserDid)) 226 215 if err != nil { 227 216 l.Error("failed to get stars", "err", err) 228 228 - s.pages.Error500(w, pages.ErrorPageParams{ 229 229 - LoggedInUser: user, 230 230 - }) 217 217 + s.pages.Error500(w) 231 218 return 232 219 } 233 220 var repos []models.Repo ··· 246 233 247 234 func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) { 248 235 l := s.logger.With("handler", "stringsPage") 249 249 - user := s.oauth.GetUser(r) 250 236 251 237 profile, err := s.profile(r) 252 238 if err != nil { 253 239 l.Error("failed to build profile card", "err", err) 254 254 - s.pages.Error500(w, pages.ErrorPageParams{ 255 255 - LoggedInUser: user, 256 256 - }) 240 240 + s.pages.Error500(w) 257 241 return 258 242 } 259 243 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle) ··· 261 245 strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid)) 262 246 if err != nil { 263 247 l.Error("failed to get strings", "err", err) 264 264 - s.pages.Error500(w, pages.ErrorPageParams{ 265 265 - LoggedInUser: user, 266 266 - }) 248 248 + s.pages.Error500(w) 267 249 return 268 250 } 269 251 ··· 398 380 399 381 func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) { 400 382 ident, ok := r.Context().Value("resolvedId").(identity.Identity) 401 401 - user := s.oauth.GetUser(r) 402 402 - 403 383 if !ok { 404 404 - s.pages.Error404(w, pages.ErrorPageParams{ 405 405 - LoggedInUser: user, 406 406 - }) 384 384 + s.pages.Error404(w) 407 385 return 408 386 } 409 387 410 388 feed, err := s.getProfileFeed(r.Context(), &ident) 411 389 if err != nil { 412 412 - s.pages.Error500(w, pages.ErrorPageParams{ 413 413 - LoggedInUser: user, 414 414 - }) 390 390 + s.pages.Error500(w) 415 391 return 416 392 } 417 393 ··· 421 397 422 398 atom, err := feed.ToAtom() 423 399 if err != nil { 424 424 - s.pages.Error500(w, pages.ErrorPageParams{ 425 425 - LoggedInUser: user, 426 426 - }) 400 400 + s.pages.Error500(w) 427 401 return 428 402 } 429 403

+2 -3

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" 14 13 "tangled.org/core/appview/pipelines" 15 14 "tangled.org/core/appview/pulls" 16 15 "tangled.org/core/appview/repo" ··· 104 103 }) 105 104 106 105 r.NotFound(func(w http.ResponseWriter, r *http.Request) { 107 107 - s.pages.Error404(w, pages.ErrorPageParams{}) 106 106 + s.pages.Error404(w) 108 107 }) 109 108 110 109 return r ··· 175 174 r.Get("/brand", s.Brand) 176 175 177 176 r.NotFound(func(w http.ResponseWriter, r *http.Request) { 178 178 - s.pages.Error404(w, pages.ErrorPageParams{}) 177 177 + s.pages.Error404(w) 179 178 }) 180 179 return r 181 180 }

+1 -4

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) 92 91 93 92 id, ok := r.Context().Value("resolvedId").(identity.Identity) 94 93 if !ok { ··· 119 118 } 120 119 if len(strings) < 1 { 121 120 l.Error("string not found") 122 122 - s.Pages.Error404(w, pages.ErrorPageParams{ 123 123 - LoggedInUser: user, 124 124 - }) 121 121 + s.Pages.Error404(w) 125 122 return 126 123 } 127 124 if len(strings) != 1 {

+1 -1

spindle/engines/nixery/engine.go

··· 222 222 }, 223 223 ReadonlyRootfs: false, 224 224 CapDrop: []string{"ALL"}, 225 225 - CapAdd: []string{"CAP_DAC_OVERRIDE"}, 225 225 + CapAdd: []string{"CAP_DAC_OVERRIDE", "CAP_CHOWN", "CAP_FOWNER", "CAP_SETUID", "CAP_SETGID"}, 226 226 SecurityOpt: []string{"no-new-privileges"}, 227 227 ExtraHosts: []string{"host.docker.internal:host-gateway"}, 228 228 }, nil, nil, "")