feat(handlers/reaction): use slogger #16

···

       
1
       
 
       
package handlers

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
-
       
	"log"

     

       
5
       
 
       
	"net/http"

     

       
6
       
 
       
	"slices"

     

       
7
       
 
       
	"strconv"

     
···

       
21
       
 
       
)

     

       
22
       
 
       


     

       
23
       
 
       
func (h *Handler) HandleReaction(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
24
       
 
       
	client, err := h.Oauth.AuthorizedClient(r)

     

       
25
       
 
       
	if err != nil {

     

       
26
       
-
       
		log.Println("failed to get authorized client:", err)

     

       
27
       
 
       
		htmx.HxRedirect(w, "/login")

     

       
28
       
 
       
		return

     

       
29
       
 
       
	}

     

       
30
       
 
       


     

       
31
       
 
       
	user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)

     

       
32
       
 
       
	if err != nil {

     

       
33
       
-
       
		log.Println("failed to get logged-in user:", err)

     

       
34
       
 
       
		htmx.HxRedirect(w, "/login")

     

       
35
       
 
       
		return

     

       
36
       
 
       
	}

     
···

       
53
       
 
       
	}

     

       
54
       
 
       


     

       
55
       
 
       
	if user.Did == session.Did {

     

       
56
       
-
       
		log.Println("failed to react to study session, cannot react to your own study session")

     

       
57
       
 
       
		htmx.HxError(w, http.StatusBadRequest, "You cannot react to your own study sessions.")

     

       
58
       
 
       
		return

     

       
59
       
 
       
	}

     
···

       
73
       
 
       


     

       
74
       
 
       
	reaction, err := db.ReactionFromString(db.ReactionType(reactionId).String())

     

       
75
       
 
       
	if err != nil {

     

       
76
       
-
       
		log.Printf("failed to get reaction types: %v", err)

     

       
77
       
 
       
		htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")

     

       
78
       
 
       
		return

     

       
79
       
 
       
	}

     

       
80
       
 
       


     

       
81
       
 
       
	reactionEvents, err := db.GetReactionsForSession(h.Db, subjectDid, subjectRkey)

     

       
82
       
 
       
	if err != nil {

     

       
83
       
-
       
		log.Println("failed to get reactions for study session from db:", err)

     

       
84
       
 
       
		htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")

     

       
85
       
 
       
		return

     

       
86
       
 
       
	}

     
···

       
89
       
 
       
	case http.MethodPost:

     

       
90
       
 
       
		reactionEvent, err := db.GetReactionEvent(h.Db, user.Did, session, reaction.ID)

     

       
91
       
 
       
		if err != nil {

     

       
92
       
-
       
			log.Println("failed to get reaction event from db:", err)

     

       
93
       
 
       
			htmx.HxError(w, http.StatusInternalServerError, "Failed to add reaction, try again later.")

     

       
94
       
 
       
			return

     

       
95
       
 
       
		}

     

       
96
       
 
       
		if reactionEvent != nil {

     

       
97
       
-
       
			log.Println("failed to add reaction, user already reacted")

     

       
98
       
 
       
			htmx.HxError(w, http.StatusBadRequest, "You cannot react multiple times with the same reaction.")

     

       
99
       
 
       
			return

     

       
100
       
 
       
		}

     
···

       
113
       
 
       
				}},

     

       
114
       
 
       
		})

     

       
115
       
 
       
		if err != nil {

     

       
116
       
-
       
			log.Println("failed to create reaction record:", err)

     

       
117
       
 
       
			htmx.HxError(w, http.StatusInternalServerError, "Failed to add reaction, try again later.")

     

       
118
       
 
       
			return

     

       
119
       
 
       
		}

     
···

       
128
       
 
       
					Set("session_rkey", subjectRkey),

     

       
129
       
 
       
			})

     

       
130
       
 
       
			if err != nil {

     

       
131
       
-
       
				log.Println("failed to enqueue posthog event:", err)

     

       
132
       
 
       
			}

     

       
133
       
 
       
		}

     

       
134
       
 
       


     
···

       
153
       
 
       
	case http.MethodDelete:

     

       
154
       
 
       
		reactionEvent, err := db.GetReactionEvent(h.Db, user.Did, session, reaction.ID)

     

       
155
       
 
       
		if err != nil {

     

       
156
       
-
       
			log.Println("failed to get reaction event from db:", err)

     

       
157
       
 
       
			htmx.HxError(w, http.StatusInternalServerError, "Failed to remove reaction, try again later.")

     

       
158
       
 
       
			return

     

       
159
       
 
       
		}

     
···

       
164
       
 
       
			Rkey:       reactionEvent.Rkey,

     

       
165
       
 
       
		})

     

       
166
       
 
       
		if err != nil {

     

       
167
       
-
       
			log.Println("failed to delete reaction record:", err)

     

       
168
       
 
       
			htmx.HxError(w, http.StatusInternalServerError, "Failed to remove reaction, try again later.")

     

       
169
       
 
       
			return

     

       
170
       
 
       
		}

     
···

       
179
       
 
       
					Set("session_rkey", subjectRkey),

     

       
180
       
 
       
			})

     

       
181
       
 
       
			if err != nil {

     

       
182
       
-
       
				log.Println("failed to enqueue posthog event:", err)

     

       
183
       
 
       
			}

     

       
184
       
 
       
		}

     

       
185
       
 
       


     
···

       
188
       
 
       
		})

     

       
189
       
 
       


     

       
190
       
 
       
		partials.NewReactions(partials.NewReactionsProps{

     

       
191
       
-
       
			User:        user,

     

       
192
       
-
       
			SessionRkey: subjectRkey,

     

       
193
       
-
       
			SessionDid:  subjectDid,

     

       
194
       
-
       
			// Reactions:      reactions,

     

       
195
       
 
       
			ReactionEvents: reactionEvents,

     

       
196
       
 
       
		}).Render(r.Context(), w)

     

       
197
       
 
       
	}

     

···

       
1
       
 
       
package handlers

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
0
       
 
       

     

       
4
       
 
       
	"net/http"

     

       
5
       
 
       
	"slices"

     

       
6
       
 
       
	"strconv"

     
···

       
20
       
 
       
)

     

       
21
       
 
       


     

       
22
       
 
       
func (h *Handler) HandleReaction(w http.ResponseWriter, r *http.Request) {

     

       
23
       
+
       
	l := h.Logger.With("handler", "HandleReaction")

     

       
24
       
+
       


     

       
25
       
 
       
	client, err := h.Oauth.AuthorizedClient(r)

     

       
26
       
 
       
	if err != nil {

     

       
27
       
+
       
		l.Error("failed to get authorized client", "err", err)

     

       
28
       
 
       
		htmx.HxRedirect(w, "/login")

     

       
29
       
 
       
		return

     

       
30
       
 
       
	}

     

       
31
       
 
       


     

       
32
       
 
       
	user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)

     

       
33
       
 
       
	if err != nil {

     

       
34
       
+
       
		l.Error("failed to get logged-in user", "err", err)

     

       
35
       
 
       
		htmx.HxRedirect(w, "/login")

     

       
36
       
 
       
		return

     

       
37
       
 
       
	}

     
···

       
54
       
 
       
	}

     

       
55
       
 
       


     

       
56
       
 
       
	if user.Did == session.Did {

     

       
57
       
+
       
		l.Error("failed to react to study session, cannot react to your own study session")

     

       
58
       
 
       
		htmx.HxError(w, http.StatusBadRequest, "You cannot react to your own study sessions.")

     

       
59
       
 
       
		return

     

       
60
       
 
       
	}

     
···

       
74
       
 
       


     

       
75
       
 
       
	reaction, err := db.ReactionFromString(db.ReactionType(reactionId).String())

     

       
76
       
 
       
	if err != nil {

     

       
77
       
+
       
		l.Error("failed to get reaction types", "err", err)

     

       
78
       
 
       
		htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")

     

       
79
       
 
       
		return

     

       
80
       
 
       
	}

     

       
81
       
 
       


     

       
82
       
 
       
	reactionEvents, err := db.GetReactionsForSession(h.Db, subjectDid, subjectRkey)

     

       
83
       
 
       
	if err != nil {

     

       
84
       
+
       
		l.Error("failed to get reactions for study session from db", "err", err)

     

       
85
       
 
       
		htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")

     

       
86
       
 
       
		return

     

       
87
       
 
       
	}

     
···

       
90
       
 
       
	case http.MethodPost:

     

       
91
       
 
       
		reactionEvent, err := db.GetReactionEvent(h.Db, user.Did, session, reaction.ID)

     

       
92
       
 
       
		if err != nil {

     

       
93
       
+
       
			l.Error("failed to get reaction event from db", "err", err)

     

       
94
       
 
       
			htmx.HxError(w, http.StatusInternalServerError, "Failed to add reaction, try again later.")

     

       
95
       
 
       
			return

     

       
96
       
 
       
		}

     

       
97
       
 
       
		if reactionEvent != nil {

     

       
98
       
+
       
			l.Error("failed to add reaction, user already reacted")

     

       
99
       
 
       
			htmx.HxError(w, http.StatusBadRequest, "You cannot react multiple times with the same reaction.")

     

       
100
       
 
       
			return

     

       
101
       
 
       
		}

     
···

       
114
       
 
       
				}},

     

       
115
       
 
       
		})

     

       
116
       
 
       
		if err != nil {

     

       
117
       
+
       
			l.Error("failed to create reaction record", "err", err)

     

       
118
       
 
       
			htmx.HxError(w, http.StatusInternalServerError, "Failed to add reaction, try again later.")

     

       
119
       
 
       
			return

     

       
120
       
 
       
		}

     
···

       
129
       
 
       
					Set("session_rkey", subjectRkey),

     

       
130
       
 
       
			})

     

       
131
       
 
       
			if err != nil {

     

       
132
       
+
       
				l.Error("failed to enqueue posthog event", "err", err)

     

       
133
       
 
       
			}

     

       
134
       
 
       
		}

     

       
135
       
 
       


     
···

       
154
       
 
       
	case http.MethodDelete:

     

       
155
       
 
       
		reactionEvent, err := db.GetReactionEvent(h.Db, user.Did, session, reaction.ID)

     

       
156
       
 
       
		if err != nil {

     

       
157
       
+
       
			l.Error("failed to get reaction event from db", "err", err)

     

       
158
       
 
       
			htmx.HxError(w, http.StatusInternalServerError, "Failed to remove reaction, try again later.")

     

       
159
       
 
       
			return

     

       
160
       
 
       
		}

     
···

       
165
       
 
       
			Rkey:       reactionEvent.Rkey,

     

       
166
       
 
       
		})

     

       
167
       
 
       
		if err != nil {

     

       
168
       
+
       
			l.Error("failed to delete reaction record", "err", err)

     

       
169
       
 
       
			htmx.HxError(w, http.StatusInternalServerError, "Failed to remove reaction, try again later.")

     

       
170
       
 
       
			return

     

       
171
       
 
       
		}

     
···

       
180
       
 
       
					Set("session_rkey", subjectRkey),

     

       
181
       
 
       
			})

     

       
182
       
 
       
			if err != nil {

     

       
183
       
+
       
				l.Error("failed to enqueue posthog event", "err", err)

     

       
184
       
 
       
			}

     

       
185
       
 
       
		}

     

       
186
       
 
       


     
···

       
189
       
 
       
		})

     

       
190
       
 
       


     

       
191
       
 
       
		partials.NewReactions(partials.NewReactionsProps{

     

       
192
       
+
       
			User:           user,

     

       
193
       
+
       
			SessionRkey:    subjectRkey,

     

       
194
       
+
       
			SessionDid:     subjectDid,

     

       
0
       
 
       

     

       
195
       
 
       
			ReactionEvents: reactionEvents,

     

       
196
       
 
       
		}).Render(r.Context(), w)

     

       
197
       
 
       
	}