brookjeynes.dev
Signed-off-by: brookjeynes me@brookjeynes.dev
+56
-40
internal/server/handlers/profile.go
+56
-40
internal/server/handlers/profile.go
···
3
3
import (
4
4
"errors"
5
5
"fmt"
6
-
"log"
6
+
"log/slog"
7
7
"net/http"
8
8
"strconv"
9
9
"time"
···
30
30
PendingProfileUpdate string = "pending_profile_update"
31
31
)
32
32
33
-
func parseProfileForm(r *http.Request) (db.Profile, error) {
33
+
func parseProfileForm(r *http.Request, logger *slog.Logger) (db.Profile, error) {
34
34
err := r.ParseForm()
35
35
if err != nil {
36
36
return db.Profile{}, fmt.Errorf("invalid profile form: %w", err)
···
45
45
for _, code := range languageCodes {
46
46
language, ok := db.Languages[db.LanguageCode(code)]
47
47
if !ok {
48
-
log.Printf("invalid language code submitted: %s", code)
48
+
logger.Warn("invalid language code submitted", "languageCode", code)
49
49
continue
50
50
}
51
51
languages = append(languages, language)
···
62
62
}
63
63
64
64
func (h *Handler) HandleProfilePage(w http.ResponseWriter, r *http.Request) {
65
+
l := h.Logger.With("handler", "HandleProfilePage")
66
+
65
67
didOrHandle := chi.URLParam(r, "user")
66
68
if didOrHandle == "" {
67
69
http.Error(w, "Bad request", http.StatusBadRequest)
···
102
104
103
105
totalStudyTime, err = db.GetTotalStudyTime(h.Db, profileDid)
104
106
if err != nil {
105
-
log.Println("failed to get total study time:", err)
107
+
l.Error("failed to get total study time", "err", err)
106
108
}
107
109
108
110
totalStudySessions, _ = db.GetTotalStudySessions(h.Db, profileDid)
109
111
if err != nil {
110
-
log.Println("failed to get total study study sessions:", err)
112
+
l.Error("failed to get total study study sessions", "err", err)
111
113
}
112
114
113
115
followers, following, _ = db.GetFollowerFollowingCount(h.Db, profileDid)
114
116
if err != nil {
115
-
log.Println("failed to get follow stats:", err)
117
+
l.Error("failed to get follow stats", "err", err)
116
118
}
117
119
118
120
streak, _ = db.GetCurrentStreak(h.Db, profileDid)
119
121
if err != nil {
120
-
log.Println("failed to get streak:", err)
122
+
l.Error("failed to get streak", "err", err)
121
123
}
122
124
123
125
if user != nil {
···
128
130
})
129
131
130
132
if err := g.Wait(); err != nil {
131
-
log.Printf("failed to fetch critical profile data for %s: %v", profileDid, err)
133
+
l.Error("failed to fetch critical profile data for", "did", profileDid, "err", err)
132
134
htmx.HxError(w, http.StatusInternalServerError, "Failed to fetch profile data, try again later.")
133
135
return
134
136
}
···
160
162
161
163
err := h.Posthog.Enqueue(capture)
162
164
if err != nil {
163
-
log.Println("failed to enqueue posthog event:", err)
165
+
l.Error("failed to enqueue posthog event", "err", err)
164
166
}
165
167
}
166
168
···
178
180
}
179
181
180
182
func (h *Handler) HandleEditProfilePage(w http.ResponseWriter, r *http.Request) {
183
+
l := h.Logger.With("handler", "HandleEditProfilePage")
184
+
181
185
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
182
186
if err != nil {
183
-
log.Println("failed to get logged-in user:", err)
187
+
l.Error("failed to get logged-in user", "err", err)
184
188
htmx.HxRedirect(w, "/login")
185
189
return
186
190
}
187
191
188
192
profile, err := h.GetUserProfileWithAvatar(user.Did)
189
193
if err != nil {
190
-
log.Printf("failed to find %s in db: %s", user.Did, err)
194
+
l.Error("failed to find user in db", "did", user.Did, "err", err)
191
195
w.WriteHeader(http.StatusNotFound)
192
196
views.NotFoundPage(views.NotFoundPageParams{}).Render(r.Context(), w)
193
197
return
194
198
}
195
199
196
200
if user.Did != profile.Did {
197
-
log.Printf("user '%s' does not own record '%s'", user.Did, profile.Did)
201
+
l.Error("user does not own record", "did", user.Did, "profileDid", profile.Did)
198
202
htmx.HxError(w, http.StatusUnauthorized, "You do not have permissions to edit this profile.")
199
203
return
200
204
}
···
214
218
case http.MethodPost:
215
219
client, err := h.Oauth.AuthorizedClient(r)
216
220
if err != nil {
217
-
log.Println("failed to get authorized client:", err)
221
+
l.Error("failed to get authorized client", "err", err)
218
222
htmx.HxRedirect(w, "/login")
219
223
return
220
224
}
221
225
222
-
updatedProfile, err := parseProfileForm(r)
226
+
updatedProfile, err := parseProfileForm(r, l)
223
227
if err != nil {
224
-
log.Println("invalid profile form:", err)
228
+
l.Error("invalid profile form", "err", err)
225
229
htmx.HxError(w, http.StatusBadRequest, "Failed to update profile, ensure all fields contain valid data.")
226
230
return
227
231
}
···
236
240
}
237
241
238
242
if err := db.ValidateProfile(updatedProfile); err != nil {
239
-
log.Println("invalid profile:", err)
243
+
l.Error("invalid profile", "err", err)
240
244
switch {
241
245
case errors.Is(err, db.ErrProfileNameTooLong):
242
246
htmx.HxError(w, http.StatusBadRequest, "Profile name cannot be more than 64 characters.")
···
280
284
SwapRecord: cid,
281
285
})
282
286
if err != nil {
283
-
log.Println("failed to put profile record:", err)
287
+
l.Error("failed to put profile record", "err", err)
284
288
htmx.HxError(w, http.StatusInternalServerError, "Failed to update PDS, try again later.")
285
289
return
286
290
}
287
291
288
292
err = SavePendingUpdate(h, w, r, PendingProfileUpdate, profile)
289
293
if err != nil {
290
-
log.Printf("failed to save yoten-session to add pending profile update: %v", err)
294
+
l.Error("failed to save yoten-session to add pending profile update", "err", err)
291
295
}
292
296
293
297
if !h.Config.Core.Dev {
···
308
312
Properties: properties,
309
313
})
310
314
if err != nil {
311
-
log.Println("failed to enqueue posthog identify event:", err)
315
+
l.Error("failed to enqueue posthog identify event", "err", err)
312
316
}
313
317
314
318
err = h.Posthog.Enqueue(posthog.Capture{
···
316
320
Event: ph.ProfileRecordEditedEvent,
317
321
})
318
322
if err != nil {
319
-
log.Println("failed to enqueue posthog event:", err)
323
+
l.Error("failed to enqueue posthog event", "err", err)
320
324
}
321
325
}
322
326
···
325
329
}
326
330
327
331
func (h *Handler) HandleResourcesPage(w http.ResponseWriter, r *http.Request) {
332
+
l := h.Logger.With("handler", "HandleResourcesPage")
333
+
328
334
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
329
335
if err != nil {
330
-
log.Println("failed to get logged-in user:", err)
336
+
l.Error("failed to get logged-in user", "err", err)
331
337
htmx.HxRedirect(w, "/login")
332
338
return
333
339
}
334
340
335
341
resources, err := db.GetResourcesByDid(h.Db, user.Did)
336
342
if err != nil {
337
-
log.Println("failed to get resources:", err)
343
+
l.Error("failed to get resources", "err", err)
338
344
htmx.HxError(w, http.StatusInternalServerError, "Failed to retrieve profile resources, try again later.")
339
345
return
340
346
}
341
347
342
348
resources, err = ApplyPendingChanges(h, w, r, resources, PendingResourceCreation, PendingResourceUpdates, PendingResourceDeletion)
343
349
if err != nil {
344
-
log.Printf("failed to save yoten-session after processing pending changes: %v", err)
350
+
l.Error("failed to save yoten-session after processing pending changes", "err", err)
345
351
}
346
352
347
353
activeResources := utils.Filter(resources, func(resource db.Resource) bool {
···
355
361
}
356
362
357
363
func (h *Handler) HandleActivitiesPage(w http.ResponseWriter, r *http.Request) {
364
+
l := h.Logger.With("handler", "HandleActivitiesPage")
365
+
358
366
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
359
367
if err != nil {
360
-
log.Println("failed to get logged-in user:", err)
368
+
l.Error("failed to get logged-in user", "err", err)
361
369
htmx.HxRedirect(w, "/login")
362
370
return
363
371
}
364
372
365
373
activities, err := db.GetActivitiesByDid(h.Db, user.Did)
366
374
if err != nil {
367
-
log.Println("failed to get activities:", err)
375
+
l.Error("failed to get activities", "err", err)
368
376
htmx.HxError(w, http.StatusInternalServerError, "Failed to retrieve profile activities, try again later.")
369
377
return
370
378
}
371
379
372
380
activities, err = ApplyPendingChanges(h, w, r, activities, PendingActivityCreation, PendingActivityUpdates, PendingActivityDeletion)
373
381
if err != nil {
374
-
log.Printf("failed to save yoten-session after processing pending changes: %v", err)
382
+
l.Error("failed to save yoten-session after processing pending changes", "err", err)
375
383
}
376
384
377
385
activeActivities := utils.Filter(activities, func(activity db.Activity) bool {
···
400
408
}
401
409
402
410
func (h *Handler) HandleProfileFeed(w http.ResponseWriter, r *http.Request) {
411
+
l := h.Logger.With("handler", "HandleProfileFeed")
412
+
403
413
didOrHandle := chi.URLParam(r, "user")
404
414
if didOrHandle == "" {
405
415
http.Error(w, "Bad request", http.StatusBadRequest)
···
415
425
416
426
profile, err := h.GetUserProfileWithAvatar(ident.DID.String())
417
427
if err != nil {
418
-
log.Printf("failed to find %s in db: %s", ident.DID.String(), err)
428
+
l.Error("failed to find user in db", "did", ident.DID.String(), "err", err)
419
429
w.WriteHeader(http.StatusNotFound)
420
430
views.NotFoundPage(views.NotFoundPageParams{}).Render(r.Context(), w)
421
431
return
···
423
433
424
434
bskyProfile, err := bsky.GetBskyProfile(ident.DID.String())
425
435
if err != nil {
426
-
log.Println("failed to get bsky profile:", err)
436
+
l.Error("failed to get bsky profile", "err", err)
427
437
w.WriteHeader(http.StatusNotFound)
428
438
views.NotFoundPage(views.NotFoundPageParams{}).Render(r.Context(), w)
429
439
return
···
435
445
}
436
446
page, err := strconv.ParseInt(pageStr, 10, 64)
437
447
if err != nil {
438
-
log.Println("failed to parse page value:", err)
448
+
l.Error("failed to parse page value", "err", err)
439
449
page = 1
440
450
}
441
451
if page == 0 {
···
447
457
448
458
sessions, err := db.GetStudySessionLogs(h.Db, ident.DID.String(), pageSize+1, int(offset))
449
459
if err != nil {
450
-
log.Println("failed to get study sessions:", err)
460
+
l.Error("failed to get study sessions", "err", err)
451
461
w.WriteHeader(http.StatusNotFound)
452
462
views.NotFoundPage(views.NotFoundPageParams{}).Render(r.Context(), w)
453
463
return
···
455
465
456
466
sessions, err = ApplyPendingChanges(h, w, r, sessions, PendingStudySessionCreation, PendingStudySessionUpdates, PendingStudySessionDeletion)
457
467
if err != nil {
458
-
log.Printf("failed to save yoten-session after processing pending changes: %v", err)
468
+
l.Error("failed to save yoten-session after processing pending changes", "err", err)
459
469
}
460
470
461
471
feed := []*db.StudySessionFeedItem{}
···
493
503
}
494
504
495
505
func (h *Handler) HandleFriendsPage(w http.ResponseWriter, r *http.Request) {
506
+
l := h.Logger.With("handler", "HandleFriendsPage")
507
+
496
508
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
497
509
if err != nil {
498
-
log.Println("failed to get logged-in user:", err)
510
+
l.Error("failed to get logged-in user", "err", err)
499
511
htmx.HxRedirect(w, "/login")
500
512
return
501
513
}
502
514
503
515
followers, following, err := db.GetFollowerFollowingCount(h.Db, user.Did)
504
516
if err != nil {
505
-
log.Printf("getting follow stats repos for %s: %s", user.Did, err)
517
+
l.Error("failed to get follow stats", "err", err)
506
518
}
507
519
508
520
views.FriendsPage(views.FriendsPageParams{
···
513
525
}
514
526
515
527
func (h *Handler) HandleFriendsFeed(w http.ResponseWriter, r *http.Request) {
528
+
l := h.Logger.With("handler", "HandleFriendsFeed")
529
+
516
530
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
517
531
if err != nil {
518
-
log.Println("failed to get logged-in user")
532
+
l.Error("failed to get logged-in user")
519
533
htmx.HxRedirect(w, "/login")
520
534
return
521
535
}
···
529
543
}
530
544
page, err := strconv.ParseInt(pageStr, 10, 64)
531
545
if err != nil {
532
-
log.Println("failed to parse page value:", err)
546
+
l.Error("failed to parse page value", "err", err)
533
547
page = 1
534
548
}
535
549
if page == 0 {
···
545
559
if mode == partials.Following {
546
560
feed, err := db.GetFollowing(h.Db, user.Did, pageSize+1, int(offset))
547
561
if err != nil {
548
-
log.Println("failed to get following list:", err)
562
+
l.Error("failed to get following list", "err", err)
549
563
htmx.HxError(w, http.StatusInternalServerError, "Failed to get following list, try again later.")
550
564
return
551
565
}
552
566
bskyHydratedFeed, err = h.GetHydratedFollowerProfiles(feed)
553
567
if err != nil {
554
-
log.Println("failed to hydrate bsky profiles:", err)
568
+
l.Error("failed to hydrate bsky profiles", "err", err)
555
569
htmx.HxError(w, http.StatusInternalServerError, "Failed to get following list, try again later.")
556
570
return
557
571
}
558
572
} else {
559
573
feed, err := db.GetFollowers(h.Db, user.Did, pageSize+1, int(offset))
560
574
if err != nil {
561
-
log.Println("failed to get followers list:", err)
575
+
l.Error("failed to get followers list", "err", err)
562
576
htmx.HxError(w, http.StatusInternalServerError, "Failed to get followers list, try again later.")
563
577
return
564
578
}
565
579
bskyHydratedFeed, err = h.GetHydratedFollowerProfiles(feed)
566
580
if err != nil {
567
-
log.Println("failed to hydrate bsky profiles:", err)
581
+
l.Error("failed to hydrate bsky profiles", "err", err)
568
582
htmx.HxError(w, http.StatusInternalServerError, "Failed to get following list, try again later.")
569
583
return
570
584
}
···
586
600
}
587
601
588
602
func (h *Handler) HandleNotificationsPage(w http.ResponseWriter, r *http.Request) {
603
+
l := h.Logger.With("handler", "HandleNotificationsPage")
604
+
589
605
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
590
606
if err != nil {
591
-
log.Println("failed to get logged-in user:", err)
607
+
l.Error("failed to get logged-in user", "err", err)
592
608
htmx.HxRedirect(w, "/login")
593
609
return
594
610
}