back round 0 view raw
feat(handlers/reaction): use slogger #16

merged
opened by
brookjeynes.dev 2 months ago targeting master from push-trrpxxyxxmot
Signed-off-by: brookjeynes me@brookjeynes.dev
options
unified split
Changed files
+17 -17
internal
server
handlers
reaction.go
+17 -17
internal/server/handlers/reaction.go
···

       1
       1
        
       package handlers

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"log"

     

       5
       4
        
       	"net/http"

     

       6
       5
        
       	"slices"

     

       7
       6
        
       	"strconv"

     
···

       21
       20
        
       )

     

       22
       21
        
       

     

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

     

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

     

       24
       24
       +
       

     

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

     

       25
       26
        
       	if err != nil {

     

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

     

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

     

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

     

       28
       29
        
       		return

     

       29
       30
        
       	}

     

       30
       31
        
       

     

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

     

       32
       33
        
       	if err != nil {

     

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

     

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

     

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

     

       35
       36
        
       		return

     

       36
       37
        
       	}

     
···

       53
       54
        
       	}

     

       54
       55
        
       

     

       55
       56
        
       	if user.Did == session.Did {

     

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

     

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

     

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

     

       58
       59
        
       		return

     

       59
       60
        
       	}

     
···

       73
       74
        
       

     

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

     

       75
       76
        
       	if err != nil {

     

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

     

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

     

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

     

       78
       79
        
       		return

     

       79
       80
        
       	}

     

       80
       81
        
       

     

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

     

       82
       83
        
       	if err != nil {

     

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

     

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

     

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

     

       85
       86
        
       		return

     

       86
       87
        
       	}

     
···

       89
       90
        
       	case http.MethodPost:

     

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

     

       91
       92
        
       		if err != nil {

     

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

     

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

     

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

     

       94
       95
        
       			return

     

       95
       96
        
       		}

     

       96
       97
        
       		if reactionEvent != nil {

     

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

     

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

     

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

     

       99
       100
        
       			return

     

       100
       101
        
       		}

     
···

       113
       114
        
       				}},

     

       114
       115
        
       		})

     

       115
       116
        
       		if err != nil {

     

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

     

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

     

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

     

       118
       119
        
       			return

     

       119
       120
        
       		}

     
···

       128
       129
        
       					Set("session_rkey", subjectRkey),

     

       129
       130
        
       			})

     

       130
       131
        
       			if err != nil {

     

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

     

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

     

       132
       133
        
       			}

     

       133
       134
        
       		}

     

       134
       135
        
       

     
···

       153
       154
        
       	case http.MethodDelete:

     

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

     

       155
       156
        
       		if err != nil {

     

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

     

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

     

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

     

       158
       159
        
       			return

     

       159
       160
        
       		}

     
···

       164
       165
        
       			Rkey:       reactionEvent.Rkey,

     

       165
       166
        
       		})

     

       166
       167
        
       		if err != nil {

     

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

     

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

     

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

     

       169
       170
        
       			return

     

       170
       171
        
       		}

     
···

       179
       180
        
       					Set("session_rkey", subjectRkey),

     

       180
       181
        
       			})

     

       181
       182
        
       			if err != nil {

     

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

     

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

     

       183
       184
        
       			}

     

       184
       185
        
       		}

     

       185
       186
        
       

     
···

       188
       189
        
       		})

     

       189
       190
        
       

     

       190
       191
        
       		partials.NewReactions(partials.NewReactionsProps{

     

       191
       191
       -
       			User:        user,

     

       192
       192
       -
       			SessionRkey: subjectRkey,

     

       193
       193
       -
       			SessionDid:  subjectDid,

     

       194
       194
       -
       			// Reactions:      reactions,

     

       192
       192
       +
       			User:           user,

     

       193
       193
       +
       			SessionRkey:    subjectRkey,

     

       194
       194
       +
       			SessionDid:     subjectDid,

     

       195
       195
        
       			ReactionEvents: reactionEvents,

     

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

     

       197
       197
        
       	}