back round 0 view raw

appview: add logged in user in 500 error pages #689

closed

opened by

serendipty01.dev 1 month ago targeting master from serendipty01.dev/tangled-core: push-prquzlvztlul

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

options

unified split

Changed files

+52 -15

appview

notifications

notifications.go

pages

pages.go

repo

feed.go

state

profile.go

+6 -2

appview/notifications/notifications.go

···

       61
       61
        
       	)

     

       62
       62
        
       	if err != nil {

     

       63
       63
        
       		l.Error("failed to get total notifications", "err", err)

     

       64
       64
       -
       		n.pages.Error500(w)

     

       64
       64
       +
       		n.pages.Error500(w, pages.ErrorPageParams{

     

       65
       65
       +
       			LoggedInUser: user,

     

       66
       66
       +
       		})

     

       65
       67
        
       		return

     

       66
       68
        
       	}

     

       67
       69
        
       

     
···

       72
       74
        
       	)

     

       73
       75
        
       	if err != nil {

     

       74
       76
        
       		l.Error("failed to get notifications", "err", err)

     

       75
       75
       -
       		n.pages.Error500(w)

     

       77
       77
       +
       		n.pages.Error500(w, pages.ErrorPageParams{

     

       78
       78
       +
       			LoggedInUser: user,

     

       79
       79
       +
       		})

     

       76
       80
        
       		return

     

       77
       81
        
       	}

     

       78
       82

+6 -2

appview/pages/pages.go

···

       1381
       1381
        
       	Active       string

     

       1382
       1382
        
       }

     

       1383
       1383
        
       

     

       1384
       1384
       +
       type ErrorPageParams struct {

     

       1385
       1385
       +
       	LoggedInUser *oauth.User

     

       1386
       1386
       +
       }

     

       1387
       1387
       +
       

     

       1384
       1388
        
       func (p *Pages) Workflow(w io.Writer, params WorkflowParams) error {

     

       1385
       1389
        
       	params.Active = "pipelines"

     

       1386
       1390
        
       	return p.executeRepo("repo/pipelines/workflow", w, params)

     
···

       1518
       1522
        
       	return hex.EncodeToString(hasher.Sum(nil))[:8] // Use first 8 chars of hash

     

       1519
       1523
        
       }

     

       1520
       1524
        
       

     

       1521
       1521
       -
       func (p *Pages) Error500(w io.Writer) error {

     

       1522
       1522
       -
       	return p.execute("errors/500", w, nil)

     

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

     

       1526
       1526
       +
       	return p.execute("errors/500", w, params)

     

       1523
       1527
        
       }

     

       1524
       1528
        
       

     

       1525
       1529
        
       func (p *Pages) Error404(w io.Writer) error {

+8 -2

appview/repo/feed.go

···

       10
       10
        
       

     

       11
       11
        
       	"tangled.org/core/appview/db"

     

       12
       12
        
       	"tangled.org/core/appview/models"

     

       13
       13
       +
       	"tangled.org/core/appview/pages"

     

       13
       14
        
       	"tangled.org/core/appview/pagination"

     

       14
       15
        
       	"tangled.org/core/appview/reporesolver"

     

       15
       16
        
       

     
···

       152
       153
        
       		log.Println("failed to fully resolve repo:", err)

     

       153
       154
        
       		return

     

       154
       155
        
       	}

     

       156
       156
       +
       	user := rp.oauth.GetUser(r)

     

       155
       157
        
       

     

       156
       158
        
       	feed, err := rp.getRepoFeed(r.Context(), f)

     

       157
       159
        
       	if err != nil {

     

       158
       160
        
       		log.Println("failed to get repo feed:", err)

     

       159
       159
       -
       		rp.pages.Error500(w)

     

       161
       161
       +
       		rp.pages.Error500(w, pages.ErrorPageParams{

     

       162
       162
       +
       			LoggedInUser: user,

     

       163
       163
       +
       		})

     

       160
       164
        
       		return

     

       161
       165
        
       	}

     

       162
       166
        
       

     

       163
       167
        
       	atom, err := feed.ToAtom()

     

       164
       168
        
       	if err != nil {

     

       165
       165
       -
       		rp.pages.Error500(w)

     

       169
       169
       +
       		rp.pages.Error500(w, pages.ErrorPageParams{

     

       170
       170
       +
       			LoggedInUser: user,

     

       171
       171
       +
       		})

     

       166
       172
        
       		return

     

       167
       173
        
       	}

     

       168
       174

+32 -9

appview/state/profile.go

···

       112
       112
        
       

     

       113
       113
        
       func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) {

     

       114
       114
        
       	l := s.logger.With("handler", "profileHomePage")

     

       115
       115
       +
       	user := s.oauth.GetUser(r)

     

       115
       116
        
       

     

       116
       117
        
       	profile, err := s.profile(r)

     

       117
       118
        
       	if err != nil {

     

       118
       119
        
       		l.Error("failed to build profile card", "err", err)

     

       119
       119
       -
       		s.pages.Error500(w)

     

       120
       120
       +
       		s.pages.Error500(w, pages.ErrorPageParams{

     

       121
       121
       +
       			LoggedInUser: user,

     

       122
       122
       +
       		})

     

       120
       123
        
       		return

     

       121
       124
        
       	}

     

       122
       125
        
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       173
       176
        
       

     

       174
       177
        
       func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {

     

       175
       178
        
       	l := s.logger.With("handler", "reposPage")

     

       179
       179
       +
       	user := s.oauth.GetUser(r)

     

       176
       180
        
       

     

       177
       181
        
       	profile, err := s.profile(r)

     

       178
       182
        
       	if err != nil {

     

       179
       183
        
       		l.Error("failed to build profile card", "err", err)

     

       180
       180
       -
       		s.pages.Error500(w)

     

       184
       184
       +
       		s.pages.Error500(w, pages.ErrorPageParams{

     

       185
       185
       +
       			LoggedInUser: user,

     

       186
       186
       +
       		})

     

       181
       187
        
       		return

     

       182
       188
        
       	}

     

       183
       189
        
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       189
       195
        
       	)

     

       190
       196
        
       	if err != nil {

     

       191
       197
        
       		l.Error("failed to get repos", "err", err)

     

       192
       192
       -
       		s.pages.Error500(w)

     

       198
       198
       +
       		s.pages.Error500(w, pages.ErrorPageParams{

     

       199
       199
       +
       			LoggedInUser: user,

     

       200
       200
       +
       		})

     

       193
       201
        
       		return

     

       194
       202
        
       	}

     

       195
       203
        
       

     
···

       202
       210
        
       

     

       203
       211
        
       func (s *State) starredPage(w http.ResponseWriter, r *http.Request) {

     

       204
       212
        
       	l := s.logger.With("handler", "starredPage")

     

       213
       213
       +
       	user := s.oauth.GetUser(r)

     

       205
       214
        
       

     

       206
       215
        
       	profile, err := s.profile(r)

     

       207
       216
        
       	if err != nil {

     

       208
       217
        
       		l.Error("failed to build profile card", "err", err)

     

       209
       209
       -
       		s.pages.Error500(w)

     

       218
       218
       +
       		s.pages.Error500(w, pages.ErrorPageParams{

     

       219
       219
       +
       			LoggedInUser: user,

     

       220
       220
       +
       		})

     

       210
       221
        
       		return

     

       211
       222
        
       	}

     

       212
       223
        
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       214
       225
        
       	stars, err := db.GetStars(s.db, 0, db.FilterEq("starred_by_did", profile.UserDid))

     

       215
       226
        
       	if err != nil {

     

       216
       227
        
       		l.Error("failed to get stars", "err", err)

     

       217
       217
       -
       		s.pages.Error500(w)

     

       228
       228
       +
       		s.pages.Error500(w, pages.ErrorPageParams{

     

       229
       229
       +
       			LoggedInUser: user,

     

       230
       230
       +
       		})

     

       218
       231
        
       		return

     

       219
       232
        
       	}

     

       220
       233
        
       	var repos []models.Repo

     
···

       233
       246
        
       

     

       234
       247
        
       func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) {

     

       235
       248
        
       	l := s.logger.With("handler", "stringsPage")

     

       249
       249
       +
       	user := s.oauth.GetUser(r)

     

       236
       250
        
       

     

       237
       251
        
       	profile, err := s.profile(r)

     

       238
       252
        
       	if err != nil {

     

       239
       253
        
       		l.Error("failed to build profile card", "err", err)

     

       240
       240
       -
       		s.pages.Error500(w)

     

       254
       254
       +
       		s.pages.Error500(w, pages.ErrorPageParams{

     

       255
       255
       +
       			LoggedInUser: user,

     

       256
       256
       +
       		})

     

       241
       257
        
       		return

     

       242
       258
        
       	}

     

       243
       259
        
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     
···

       245
       261
        
       	strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid))

     

       246
       262
        
       	if err != nil {

     

       247
       263
        
       		l.Error("failed to get strings", "err", err)

     

       248
       248
       -
       		s.pages.Error500(w)

     

       264
       264
       +
       		s.pages.Error500(w, pages.ErrorPageParams{

     

       265
       265
       +
       			LoggedInUser: user,

     

       266
       266
       +
       		})

     

       249
       267
        
       		return

     

       250
       268
        
       	}

     

       251
       269
        
       

     
···

       384
       402
        
       		s.pages.Error404(w)

     

       385
       403
        
       		return

     

       386
       404
        
       	}

     

       405
       405
       +
       	user := s.oauth.GetUser(r)

     

       387
       406
        
       

     

       388
       407
        
       	feed, err := s.getProfileFeed(r.Context(), &ident)

     

       389
       408
        
       	if err != nil {

     

       390
       390
       -
       		s.pages.Error500(w)

     

       409
       409
       +
       		s.pages.Error500(w, pages.ErrorPageParams{

     

       410
       410
       +
       			LoggedInUser: user,

     

       411
       411
       +
       		})

     

       391
       412
        
       		return

     

       392
       413
        
       	}

     

       393
       414
        
       

     
···

       397
       418
        
       

     

       398
       419
        
       	atom, err := feed.ToAtom()

     

       399
       420
        
       	if err != nil {

     

       400
       400
       -
       		s.pages.Error500(w)

     

       421
       421
       +
       		s.pages.Error500(w, pages.ErrorPageParams{

     

       422
       422
       +
       			LoggedInUser: user,

     

       423
       423
       +
       		})

     

       401
       424
        
       		return

     

       402
       425
        
       	}

     

       403
       426