back round 0 view raw

appview: add user in knot404 error pages #10

closed

opened by

serendipty01.dev 1 month ago targeting master from push-prquzlvztlul

Signed-off-by: Shalabh Agarwal me@serendipty01.dev

options

unified split

Changed files

+21 -7

appview

middleware

middleware.go

pages

pages.go

+19 -5

appview/middleware/middleware.go

···

       206
        
       	return func(next http.Handler) http.Handler {

     

       207
        
       		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {

     

       208
        
       			repoName := chi.URLParam(req, "repo")

     

       0
        
       
     

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

     

       210
        
       			if !ok {

     

       211
        
       				log.Println("malformed middleware")

     
···

       220
        
       			)

     

       221
        
       			if err != nil {

     

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

     

       223
       -
       				mw.pages.ErrorKnot404(w)

     

       0
        
       
     

       0
        
       
     

       224
        
       				return

     

       225
        
       			}

     

       226
        
       

     
···

       235
        
       	return func(next http.Handler) http.Handler {

     

       236
        
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

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

     

       0
        
       
     

       238
        
       			if err != nil {

     

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

     

       240
       -
       				mw.pages.ErrorKnot404(w)

     

       0
        
       
     

       0
        
       
     

       241
        
       				return

     

       242
        
       			}

     

       243
        
       

     
···

       282
        
       func (mw Middleware) ResolveIssue(next http.Handler) http.Handler {

     

       283
        
       	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

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

     

       0
        
       
     

       285
        
       		if err != nil {

     

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

     

       287
       -
       			mw.pages.ErrorKnot404(w)

     

       0
        
       
     

       0
        
       
     

       288
        
       			return

     

       289
        
       		}

     

       290
        
       

     
···

       292
        
       		issueId, err := strconv.Atoi(issueIdStr)

     

       293
        
       		if err != nil {

     

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

     

       295
       -
       			mw.pages.ErrorKnot404(w)

     

       0
        
       
     

       0
        
       
     

       296
        
       			return

     

       297
        
       		}

     

       298
        
       

     
···

       326
        
       	return func(next http.Handler) http.Handler {

     

       327
        
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

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

     

       0
        
       
     

       329
        
       			if err != nil {

     

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

     

       331
       -
       				mw.pages.ErrorKnot404(w)

     

       0
        
       
     

       0
        
       
     

       332
        
       				return

     

       333
        
       			}

     

       334

···

       206
        
       	return func(next http.Handler) http.Handler {

     

       207
        
       		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {

     

       208
        
       			repoName := chi.URLParam(req, "repo")

     

       209
       +
       			user := mw.oauth.GetUser(req)

     

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

     

       211
        
       			if !ok {

     

       212
        
       				log.Println("malformed middleware")

     
···

       221
        
       			)

     

       222
        
       			if err != nil {

     

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

     

       224
       +
       				mw.pages.ErrorKnot404(w, pages.ErrorPageParams{

     

       225
       +
       					LoggedInUser: user,

     

       226
       +
       				})

     

       227
        
       				return

     

       228
        
       			}

     

       229
        
       

     
···

       238
        
       	return func(next http.Handler) http.Handler {

     

       239
        
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

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

     

       241
       +
       			user := mw.oauth.GetUser(r)

     

       242
        
       			if err != nil {

     

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

     

       244
       +
       				mw.pages.ErrorKnot404(w, pages.ErrorPageParams{

     

       245
       +
       					LoggedInUser: user,

     

       246
       +
       				})

     

       247
        
       				return

     

       248
        
       			}

     

       249
        
       

     
···

       288
        
       func (mw Middleware) ResolveIssue(next http.Handler) http.Handler {

     

       289
        
       	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

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

     

       291
       +
       		user := mw.oauth.GetUser(r)

     

       292
        
       		if err != nil {

     

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

     

       294
       +
       			mw.pages.ErrorKnot404(w, pages.ErrorPageParams{

     

       295
       +
       				LoggedInUser: user,

     

       296
       +
       			})

     

       297
        
       			return

     

       298
        
       		}

     

       299
        
       

     
···

       301
        
       		issueId, err := strconv.Atoi(issueIdStr)

     

       302
        
       		if err != nil {

     

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

     

       304
       +
       			mw.pages.ErrorKnot404(w, pages.ErrorPageParams{

     

       305
       +
       				LoggedInUser: user,

     

       306
       +
       			})

     

       307
        
       			return

     

       308
        
       		}

     

       309
        
       

     
···

       337
        
       	return func(next http.Handler) http.Handler {

     

       338
        
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

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

     

       340
       +
       			user := mw.oauth.GetUser(r)

     

       341
        
       			if err != nil {

     

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

     

       343
       +
       				mw.pages.ErrorKnot404(w, pages.ErrorPageParams{

     

       344
       +
       					LoggedInUser: user,

     

       345
       +
       				})

     

       346
        
       				return

     

       347
        
       			}

     

       348

+2 -2

appview/pages/pages.go

···

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

     

       1531
        
       }

     

       1532
        
       

     

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

     

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

     

       1535
        
       }

     

       1536
        
       

     

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

···

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

     

       1531
        
       }

     

       1532
        
       

     

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

     

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

     

       1535
        
       }

     

       1536
        
       

     

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