appview: add user in 500 error pages #8

···

       
61
       
 
       
	)

     

       
62
       
 
       
	if err != nil {

     

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

     

       
64
       
-
       
		n.pages.Error500(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
65
       
 
       
		return

     

       
66
       
 
       
	}

     

       
67
       
 
       


     
···

       
72
       
 
       
	)

     

       
73
       
 
       
	if err != nil {

     

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

     

       
75
       
-
       
		n.pages.Error500(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
76
       
 
       
		return

     

       
77
       
 
       
	}

     

       
78
       
 
       


     

···

       
61
       
 
       
	)

     

       
62
       
 
       
	if err != nil {

     

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

     

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

     

       
65
       
+
       
			LoggedInUser: user,

     

       
66
       
+
       
		})

     

       
67
       
 
       
		return

     

       
68
       
 
       
	}

     

       
69
       
 
       


     
···

       
74
       
 
       
	)

     

       
75
       
 
       
	if err != nil {

     

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

     

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

     

       
78
       
+
       
			LoggedInUser: user,

     

       
79
       
+
       
		})

     

       
80
       
 
       
		return

     

       
81
       
 
       
	}

     

       
82
       
 
       


     

···

       
1381
       
 
       
	Active       string

     

       
1382
       
 
       
}

     

       
1383
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
1385
       
 
       
	params.Active = "pipelines"

     

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

     
···

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

     

       
1519
       
 
       
}

     

       
1520
       
 
       


     

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

     

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

     

       
1523
       
 
       
}

     

       
1524
       
 
       


     

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

     

···

       
1381
       
 
       
	Active       string

     

       
1382
       
 
       
}

     

       
1383
       
 
       


     

       
1384
       
+
       
type ErrorPageParams struct {

     

       
1385
       
+
       
	LoggedInUser *oauth.User

     

       
1386
       
+
       
}

     

       
1387
       
+
       


     

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

     

       
1389
       
 
       
	params.Active = "pipelines"

     

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

     
···

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

     

       
1523
       
 
       
}

     

       
1524
       
 
       


     

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

     

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

     

       
1527
       
 
       
}

     

       
1528
       
 
       


     

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

     

···

       
10
       
 
       


     

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

     

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

     

       
0
       
 
       

     

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

     

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

     

       
15
       
 
       


     
···

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

     

       
153
       
 
       
		return

     

       
154
       
 
       
	}

     

       
0
       
 
       

     

       
155
       
 
       


     

       
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)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
160
       
 
       
		return

     

       
161
       
 
       
	}

     

       
162
       
 
       


     

       
163
       
 
       
	atom, err := feed.ToAtom()

     

       
164
       
 
       
	if err != nil {

     

       
165
       
-
       
		rp.pages.Error500(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
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
       
 
       


     
···

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

     

       
154
       
 
       
		return

     

       
155
       
 
       
	}

     

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

     

       
157
       
 
       


     

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

     

       
159
       
 
       
	if err != nil {

     

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

     

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

     

       
162
       
+
       
			LoggedInUser: user,

     

       
163
       
+
       
		})

     

       
164
       
 
       
		return

     

       
165
       
 
       
	}

     

       
166
       
 
       


     

       
167
       
 
       
	atom, err := feed.ToAtom()

     

       
168
       
 
       
	if err != nil {

     

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

     

       
170
       
+
       
			LoggedInUser: user,

     

       
171
       
+
       
		})

     

       
172
       
 
       
		return

     

       
173
       
 
       
	}

     

       
174
       
 
       


     

···

       
112
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
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)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
120
       
 
       
		return

     

       
121
       
 
       
	}

     

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

     
···

       
173
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
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)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
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)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
193
       
 
       
		return

     

       
194
       
 
       
	}

     

       
195
       
 
       


     
···

       
202
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
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)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
210
       
 
       
		return

     

       
211
       
 
       
	}

     

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

     
···

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

     

       
215
       
 
       
	if err != nil {

     

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

     

       
217
       
-
       
		s.pages.Error500(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
218
       
 
       
		return

     

       
219
       
 
       
	}

     

       
220
       
 
       
	var repos []models.Repo

     
···

       
233
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
236
       
 
       


     

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

     

       
238
       
 
       
	if err != nil {

     

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

     

       
240
       
-
       
		s.pages.Error500(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
241
       
 
       
		return

     

       
242
       
 
       
	}

     

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

     
···

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

     

       
246
       
 
       
	if err != nil {

     

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

     

       
248
       
-
       
		s.pages.Error500(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
249
       
 
       
		return

     

       
250
       
 
       
	}

     

       
251
       
 
       


     
···

       
384
       
 
       
		s.pages.Error404(w)

     

       
385
       
 
       
		return

     

       
386
       
 
       
	}

     

       
0
       
 
       

     

       
387
       
 
       


     

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

     

       
389
       
 
       
	if err != nil {

     

       
390
       
-
       
		s.pages.Error500(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
391
       
 
       
		return

     

       
392
       
 
       
	}

     

       
393
       
 
       


     
···

       
397
       
 
       


     

       
398
       
 
       
	atom, err := feed.ToAtom()

     

       
399
       
 
       
	if err != nil {

     

       
400
       
-
       
		s.pages.Error500(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
401
       
 
       
		return

     

       
402
       
 
       
	}

     

       
403
       
 
       


     

···

       
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{

     

       
121
       
+
       
			LoggedInUser: user,

     

       
122
       
+
       
		})

     

       
123
       
 
       
		return

     

       
124
       
 
       
	}

     

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

     
···

       
176
       
 
       


     

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

     

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

     

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

     

       
180
       
 
       


     

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

     

       
182
       
 
       
	if err != nil {

     

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

     

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

     

       
185
       
+
       
			LoggedInUser: user,

     

       
186
       
+
       
		})

     

       
187
       
 
       
		return

     

       
188
       
 
       
	}

     

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

     
···

       
195
       
 
       
	)

     

       
196
       
 
       
	if err != nil {

     

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

     

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

     

       
199
       
+
       
			LoggedInUser: user,

     

       
200
       
+
       
		})

     

       
201
       
 
       
		return

     

       
202
       
 
       
	}

     

       
203
       
 
       


     
···

       
210
       
 
       


     

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

     

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

     

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

     

       
214
       
 
       


     

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

     

       
216
       
 
       
	if err != nil {

     

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

     

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

     

       
219
       
+
       
			LoggedInUser: user,

     

       
220
       
+
       
		})

     

       
221
       
 
       
		return

     

       
222
       
 
       
	}

     

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

     
···

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

     

       
226
       
 
       
	if err != nil {

     

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

     

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

     

       
229
       
+
       
			LoggedInUser: user,

     

       
230
       
+
       
		})

     

       
231
       
 
       
		return

     

       
232
       
 
       
	}

     

       
233
       
 
       
	var repos []models.Repo

     
···

       
246
       
 
       


     

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

     

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

     

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

     

       
250
       
 
       


     

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

     

       
252
       
 
       
	if err != nil {

     

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

     

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

     

       
255
       
+
       
			LoggedInUser: user,

     

       
256
       
+
       
		})

     

       
257
       
 
       
		return

     

       
258
       
 
       
	}

     

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

     
···

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

     

       
262
       
 
       
	if err != nil {

     

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

     

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

     

       
265
       
+
       
			LoggedInUser: user,

     

       
266
       
+
       
		})

     

       
267
       
 
       
		return

     

       
268
       
 
       
	}

     

       
269
       
 
       


     
···

       
402
       
 
       
		s.pages.Error404(w)

     

       
403
       
 
       
		return

     

       
404
       
 
       
	}

     

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

     

       
406
       
 
       


     

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

     

       
408
       
 
       
	if err != nil {

     

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

     

       
410
       
+
       
			LoggedInUser: user,

     

       
411
       
+
       
		})

     

       
412
       
 
       
		return

     

       
413
       
 
       
	}

     

       
414
       
 
       


     
···

       
418
       
 
       


     

       
419
       
 
       
	atom, err := feed.ToAtom()

     

       
420
       
 
       
	if err != nil {

     

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

     

       
422
       
+
       
			LoggedInUser: user,

     

       
423
       
+
       
		})

     

       
424
       
 
       
		return

     

       
425
       
 
       
	}

     

       
426