refactor: move computed data code to function to simplify visuals #21

merged
opened by brookjeynes.dev targeting master from push-lokxzmtxxkxo
+14
go.mod
···
github.com/bluesky-social/indigo v0.0.0-20251003000214-3259b215110e
github.com/bluesky-social/jetstream v0.0.0-20250414024304-d17bd81a945e
github.com/carlmjohnson/versioninfo v0.22.5
+
github.com/charmbracelet/log v0.4.2
github.com/go-chi/chi/v5 v5.2.1
github.com/gorilla/sessions v1.4.0
github.com/ipfs/go-cid v0.4.1
···
require (
github.com/a-h/parse v0.0.0-20250122154542-74294addb73e // indirect
github.com/andybalholm/brotli v1.1.0 // indirect
+
github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
github.com/beorn7/perks v1.0.1 // indirect
github.com/cenkalti/backoff/v4 v4.3.0 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
+
github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
+
github.com/charmbracelet/lipgloss v1.1.0 // indirect
+
github.com/charmbracelet/x/ansi v0.8.0 // indirect
+
github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
+
github.com/charmbracelet/x/term v0.2.1 // indirect
github.com/cli/browser v1.3.0 // indirect
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/fatih/color v1.16.0 // indirect
github.com/felixge/httpsnoop v1.0.4 // indirect
github.com/fsnotify/fsnotify v1.7.0 // indirect
+
github.com/go-logfmt/logfmt v0.6.0 // indirect
github.com/go-logr/logr v1.4.2 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
github.com/goccy/go-json v0.10.2 // indirect
···
github.com/lestrrat-go/httprc v1.0.4 // indirect
github.com/lestrrat-go/iter v1.0.2 // indirect
github.com/lestrrat-go/option v1.0.1 // indirect
+
github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
github.com/mattn/go-colorable v0.1.13 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
+
github.com/mattn/go-runewidth v0.0.16 // indirect
github.com/minio/sha256-simd v1.0.1 // indirect
github.com/mr-tron/base58 v1.2.0 // indirect
+
github.com/muesli/termenv v0.16.0 // indirect
github.com/multiformats/go-base32 v0.1.0 // indirect
github.com/multiformats/go-base36 v0.2.0 // indirect
github.com/multiformats/go-multibase v0.2.0 // indirect
···
github.com/prometheus/client_model v0.6.1 // indirect
github.com/prometheus/common v0.54.0 // indirect
github.com/prometheus/procfs v0.15.1 // indirect
+
github.com/rivo/uniseg v0.4.7 // indirect
github.com/segmentio/asm v1.2.0 // indirect
github.com/spaolacci/murmur3 v1.1.0 // indirect
+
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect
gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.46.1 // indirect
···
go.uber.org/multierr v1.11.0 // indirect
go.uber.org/zap v1.26.0 // indirect
golang.org/x/crypto v0.40.0 // indirect
+
golang.org/x/exp v0.0.0-20240604190554-fc45aab8b7f8 // indirect
golang.org/x/mod v0.26.0 // indirect
golang.org/x/sys v0.34.0 // indirect
golang.org/x/time v0.8.0 // indirect
+27
go.sum
···
github.com/a-h/templ v0.3.898/go.mod h1:oLBbZVQ6//Q6zpvSMPTuBK0F3qOtBdFBcGRspcT+VNQ=
github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
+
github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
+
github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
···
github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+
github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
+
github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
+
github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
+
github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
+
github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
+
github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
+
github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE=
+
github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q=
+
github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8=
+
github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
+
github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
+
github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
github.com/cli/browser v1.3.0 h1:LejqCrpWr+1pRqmEPDGnTZOjsMe7sehifLynZJuqJpo=
github.com/cli/browser v1.3.0/go.mod h1:HH8s+fOAxjhQoBUAsKuPCbqUuxZDhQ2/aD+SzsEfBTk=
github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
···
github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
github.com/go-chi/chi/v5 v5.2.1 h1:KOIHODQj58PmL80G2Eak4WdvUzjSJSm0vG72crDCqb8=
github.com/go-chi/chi/v5 v5.2.1/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
+
github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
+
github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
···
github.com/lestrrat-go/option v1.0.0/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=
github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU=
github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=
+
github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+
github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+
github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+
github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM=
github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8=
github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
+
github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
+
github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE=
github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI=
github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0=
···
github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
github.com/redis/go-redis/v9 v9.14.0 h1:u4tNCjXOyzfgeLN+vAZaW1xUooqWDqVEsZN0U01jfAE=
github.com/redis/go-redis/v9 v9.14.0/go.mod h1:huWgSWd8mW6+m0VPhJjSSQ+d6Nh1VICQ6Q5lHuCH/Iw=
+
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
···
github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11/go.mod h1:Wlo/SzPmxVp6vXpGt/zaXhHH0fn4IxgqZc82aKg6bpQ=
github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e h1:28X54ciEwwUxyHn9yrZfl5ojgF4CBNLWX7LR0rvBkf4=
github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so=
+
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+25 -7
internal/server/log/log.go
···
"context"
"log/slog"
"os"
+
+
"github.com/charmbracelet/log"
)
-
// NewHandler sets up a new slog.Handler with the service name as an attribute
func NewHandler(name string) slog.Handler {
-
handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{})
-
-
var attrs []slog.Attr
-
attrs = append(attrs, slog.Attr{Key: "service", Value: slog.StringValue(name)})
-
handler.WithAttrs(attrs)
-
return handler
+
return log.NewWithOptions(os.Stderr, log.Options{
+
ReportTimestamp: true,
+
Prefix: name,
+
Level: log.DebugLevel,
+
})
}
func New(name string) *slog.Logger {
···
return slog.Default()
}
+
+
// Sublogger derives a new logger from an existing one by appending a suffix to
+
// its prefix.
+
func SubLogger(base *slog.Logger, suffix string) *slog.Logger {
+
// Try to get the underlying charmbracelet logger.
+
if cl, ok := base.Handler().(*log.Logger); ok {
+
prefix := cl.GetPrefix()
+
if prefix != "" {
+
prefix = prefix + "/" + suffix
+
} else {
+
prefix = suffix
+
}
+
return slog.New(NewHandler(prefix))
+
}
+
+
// Fallback to no known handler type.
+
return slog.New(NewHandler(suffix))
+
}
+7 -4
internal/db/db.go
···
"context"
"database/sql"
"fmt"
+
"log/slog"
"strings"
_ "github.com/mattn/go-sqlite3"
···
type DB struct {
*sql.DB
+
logger *slog.Logger
}
type Execer interface {
···
PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)
}
-
func Make(dbPath string) (*DB, error) {
+
func Make(ctx context.Context, dbPath string, logger *slog.Logger) (*DB, error) {
opts := []string{
"_foreign_keys=1",
"_journal_mode=WAL",
···
return nil, fmt.Errorf("failed to open db: %w", err)
}
-
ctx := context.Background()
-
conn, err := db.Conn(ctx)
if err != nil {
return nil, err
···
return nil, fmt.Errorf("failed to execute db create statement: %w", err)
}
-
return &DB{db}, nil
+
return &DB{
+
db,
+
logger,
+
}, nil
}
+58 -47
internal/server/handlers/study-session.go
···
import (
"errors"
"fmt"
-
"log"
"net/http"
"strconv"
"time"
···
}
func (h *Handler) HandleStudySessionFeed(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleStudySessionFeed")
+
isFriends, err := strconv.ParseBool(r.URL.Query().Get("friends"))
if err != nil {
-
log.Println("failed to parse friends value:", err)
+
l.Error("failed to parse friends value", "err", err)
isFriends = false
}
···
}
page, err := strconv.ParseInt(pageStr, 10, 64)
if err != nil {
-
log.Println("failed to parse page value:", err)
+
l.Error("failed to parse page value", "err", err)
page = 1
}
if page == 0 {
···
if !isFriends {
feed, err = db.GetStudySessionFeed(h.Db, pageSize+1, int(offset))
if err != nil {
-
log.Println("failed to get global feed:", err)
+
l.Error("failed to get global feed", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")
return
}
err = h.GetBskyProfileHydratedSessionFeed(feed)
if err != nil {
-
log.Println("failed to hydrate bsky profiles:", err)
+
l.Error("failed to hydrate bsky profiles", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")
return
}
} else {
if fetchUserError != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
feed, err = db.GetFriendsStudySessionFeed(h.Db, user.Did, pageSize+1, int(offset))
if err != nil {
-
log.Println("failed to get global feed:", err)
+
l.Error("failed to get global feed", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")
return
}
err = h.GetBskyProfileHydratedSessionFeed(feed)
if err != nil {
-
log.Println("failed to hydrate bsky profiles:", err)
+
l.Error("failed to hydrate bsky profiles", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")
return
}
···
feed, err = ApplyPendingChanges(h, w, r, feed, PendingStudySessionCreation, PendingStudySessionUpdates, PendingStudySessionDeletion)
if err != nil {
-
log.Printf("failed to save yoten-session after processing pending changes: %v", err)
+
l.Error("failed to save yoten-session after processing pending changes", "err", err)
}
nextPage := 0
···
}
func (h *Handler) HandleEditStudySessionPage(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleEditStudySessionPage")
+
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
rkey := chi.URLParam(r, "rkey")
studySession, err := db.GetStudySessionByRkey(h.Db, user.Did, rkey)
if err != nil {
-
log.Println("failed to get study session from db:", err)
+
l.Error("failed to get study session from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to update study session, try again later.")
return
}
if user.Did != studySession.Did {
-
log.Printf("user '%s' does not own record '%s'", user.Did, studySession.Rkey)
+
l.Error("user does not own record", "did", user.Did, "sessionDid", studySession.Did)
htmx.HxError(w, http.StatusUnauthorized, "You do not have permissions to edit this study session.")
return
}
···
case http.MethodGet:
userDefinedActivities, err := db.GetActivitiesByDid(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get user-defined activities:", err)
+
l.Error("failed to get user-defined activities", "err", err)
}
resources, err := db.GetResourcesByDid(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get user-defined resources:", err)
+
l.Error("failed to get user-defined resources", "err", err)
}
preDefinedActivities, err := db.GetPredefinedActivities(h.Db)
if err != nil {
-
log.Println("failed to get pre-defined activities:", err)
+
l.Error("failed to get pre-defined activities", "err", err)
}
currentResource := studySession.Resource
···
languages, err := db.GetProfileLanguages(h.Db, user.Did)
if err != nil {
-
log.Println("failed to fetch profile languages:", err)
+
l.Error("failed to fetch profile languages", "err", err)
}
views.EditStudySessionPage(views.EditStudySessionPageParams{
···
case http.MethodPost:
updatedStudySession, err := h.parseStudySessionForm(r)
if err != nil {
-
log.Println("invalid study session form:", err)
+
l.Error("invalid study session form", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Failed to update study session, ensure all data is valid.")
return
}
···
updatedStudySession.CreatedAt = studySession.CreatedAt
if err := db.ValidateStudySession(updatedStudySession); err != nil {
-
log.Println("invalid study session:", err)
+
l.Error("invalid study session", "err", err)
switch {
case errors.Is(err, db.ErrSessionDescriptionTooLong):
htmx.HxError(w, http.StatusBadRequest, "Study session description cannot be more than 256 characters.")
···
SwapRecord: cid,
})
if err != nil {
-
log.Println("failed to update study session record:", err)
+
l.Error("failed to update study session record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to update study session, try again later.")
return
}
err = SavePendingUpdate(h, w, r, PendingStudySessionUpdates, updatedStudySession)
if err != nil {
-
log.Printf("failed to save yoten-session to add pending study session updates: %v", err)
+
l.Error("failed to save yoten-session to add pending study session updates", "err", err)
}
if !h.Config.Core.Dev {
···
Set("rkey", rkey),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleNewStudySessionPage(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleNewStudySessionPage")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
case http.MethodGet:
profile, err := db.GetProfile(h.Db, user.Did)
if err != nil {
-
log.Printf("failed to find %s in db: %s", user.Did, err)
+
l.Error("failed to find user in db", "did", user.Did, "err", err)
htmx.HxError(w, http.StatusNotFound, "Failed to find user.")
return
}
userDefinedActivities, err := db.GetActivitiesByDid(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get user-defined activities:", err)
+
l.Error("failed to get user-defined activities", "err", err)
}
preDefinedActivities, err := db.GetPredefinedActivities(h.Db)
if err != nil {
-
log.Println("failed to get pre-defined activities:", err)
+
l.Error("failed to get pre-defined activities", "err", err)
}
activeActivities := utils.Filter(userDefinedActivities, func(activity db.Activity) bool {
return activity.Status != db.Deleted
···
resources, err := db.GetResourcesByDid(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get user-defined resources:", err)
+
l.Error("failed to get user-defined resources", "err", err)
}
activeResources := utils.Filter(resources, func(resource db.Resource) bool {
return resource.Status != db.Deleted
···
case http.MethodPost:
newStudySession, err := h.parseStudySessionForm(r)
if err != nil {
-
log.Println("invalid study session form:", err)
+
l.Error("invalid study session form", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Failed to update study session, ensure all data is valid.")
return
}
···
}
if err := db.ValidateStudySession(newStudySession); err != nil {
-
log.Println("invalid study session:", err)
+
l.Error("invalid study session", "err", err)
switch {
case errors.Is(err, db.ErrSessionDescriptionTooLong):
htmx.HxError(w, http.StatusBadRequest, "Study session description cannot be more than 256 characters.")
···
},
})
if err != nil {
-
log.Println("failed to create study session record:", err)
+
l.Error("failed to create study session record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to create study session, try again later.")
return
}
err = SavePendingCreate(h, w, r, PendingStudySessionCreation, newStudySession)
if err != nil {
-
log.Printf("failed to save yoten-session to add pending study session creation: %v", err)
+
l.Error("failed to save yoten-session to add pending study session creation", "err", err)
}
if !h.Config.Core.Dev {
···
Set("date_is_today", newStudySession.Date.Truncate(24*time.Hour).Equal(time.Now().UTC().In(loc).Truncate(24*time.Hour))),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleDeleteStudySession(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleDeleteStudySession")
+
user := h.Oauth.GetUser(r)
if user == nil {
-
log.Println("failed to get logged-in user")
+
l.Error("failed to get logged-in user")
htmx.HxRedirect(w, "/login")
return
}
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxError(w, http.StatusUnauthorized, "Failed to delete study session, try again later.")
return
}
···
case http.MethodDelete:
err := r.ParseForm()
if err != nil {
-
log.Println("failed to parse study session delete form:", err)
+
l.Error("failed to parse study session delete form", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Failed to delete study session, try again later.")
return
}
···
rkey := chi.URLParam(r, "rkey")
studySession, err := db.GetStudySessionByRkey(h.Db, user.Did, rkey)
if err != nil {
-
log.Println("failed to get study session from db:", err)
+
l.Error("failed to get study session from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to delete study session, try again later.")
return
}
if user.Did != studySession.Did {
-
log.Println("failed to delete study session: user does not own record")
+
l.Error("user does not own record", "did", user.Did, "sessionDid", studySession.Did)
htmx.HxError(w, http.StatusUnauthorized, "Failed to delete study session, try again later.")
return
}
···
Rkey: rkey,
})
if err != nil {
-
log.Println("failed to delete study session from PDS:", err)
+
l.Error("failed to delete study session from PDS", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to delete study session, try again later.")
return
}
err = SavePendingDelete(h, w, r, PendingStudySessionDeletion, studySession)
if err != nil {
-
log.Printf("failed to save yoten-session to add pending study session deletion: %v", err)
+
l.Error("failed to save yoten-session to add pending study session deletion", "err", err)
}
if !h.Config.Core.Dev {
···
Set("session_age_seconds", time.Since(studySession.CreatedAt).Seconds()),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleStudySessionPage(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleStudySessionPage")
+
user, _ := bsky.GetUserWithBskyProfile(h.Oauth, r)
didOrHandle := chi.URLParam(r, "user")
if didOrHandle == "" {
···
studySession, err := db.GetStudySessionByRkey(h.Db, ident.DID.String(), rkey)
if err != nil {
-
log.Println("failed to retrieve study session:", err)
+
l.Error("failed to retrieve study session", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to retrieve study session, try again later.")
return
}
bskyProfile, err := bsky.GetBskyProfile(ident.DID.String())
if err != nil {
-
log.Println("failed to retrieve bsky profile for study session:", err)
+
l.Error("failed to retrieve bsky profile for study session", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to retrieve bsky profile, try again later.")
return
}
profile, err := db.GetProfile(h.Db, ident.DID.String())
if err != nil {
-
log.Println("failed to retrieve profile for study session:", err)
+
l.Error("failed to retrieve profile for study session", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to retrieve profile, try again later.")
return
}
···
}
func (h *Handler) HandleStudySessionPageCommentFeed(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleStudySessionPageCommentFeed")
+
user, _ := bsky.GetUserWithBskyProfile(h.Oauth, r)
didOrHandle := chi.URLParam(r, "user")
···
}
page, err := strconv.ParseInt(pageStr, 10, 64)
if err != nil {
-
log.Println("failed to parse page value:", err)
+
l.Error("failed to parse page value", "err", err)
page = 1
}
if page == 0 {
···
commentFeed, err := db.GetCommentsForSession(h.Db, studySessionUri.String(), pageSize+1, int(offset))
if err != nil {
-
log.Println("failed to get comment feed:", err)
+
l.Error("failed to get comment feed", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get comment feed, try again later.")
return
}
···
populatedCommentFeed, err := h.BuildCommentFeed(finalFeed)
if err != nil {
-
log.Println("failed to populate comment feed:", err)
+
l.Error("failed to populate comment feed", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get comment feed, try again later.")
return
}
+31 -26
internal/server/handlers/resource.go
···
import (
"errors"
"fmt"
-
"log"
"net/http"
"time"
···
}
func (h *Handler) HandleNewResourcePage(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleNewResourcePage")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
case http.MethodPost:
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
newResource, err := parseResourceForm(r)
if err != nil {
-
log.Println("invalid resource form:", err)
+
l.Error("invalid resource form", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Failed to create resource, ensure all fields contain valid data.")
return
}
···
newResource.CreatedAt = time.Now().UTC()
if err := db.ValidateResource(newResource); err != nil {
-
log.Println("invalid resource definition:", err)
+
l.Error("invalid resource definition", "err", err)
switch {
case errors.Is(err, db.ErrResourceTitleEmpty):
htmx.HxError(w, http.StatusBadRequest, "Resource must have a title.")
···
if newResource.Link != nil {
linkCheckResult := google.CheckResourceLinkSafety(*newResource.Link)
if linkCheckResult.Err != nil {
-
log.Println("invalid resource definition:", linkCheckResult.Err)
+
l.Error("invalid resource definition", "err", linkCheckResult.Err)
switch {
case errors.Is(linkCheckResult.Err, google.ErrResourceLinkSketchy):
if !h.Config.Core.Dev {
···
},
})
if err != nil {
-
log.Println("failed to create resource record:", err)
+
l.Error("failed to create resource record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to create resource, try again later.")
return
}
err = SavePendingCreate(h, w, r, PendingResourceCreation, newResource)
if err != nil {
-
log.Printf("failed to save yoten-session to add pending resource creation: %v", err)
+
l.Error("failed to save yoten-session to add pending resource creation", "err", err)
}
if !h.Config.Core.Dev {
···
Set("link_provided", newResource.Link != nil),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleDeleteResource(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleDeleteResource")
+
user := h.Oauth.GetUser(r)
if user == nil {
-
log.Println("failed to get logged-in user")
+
l.Error("failed to get logged-in user")
htmx.HxRedirect(w, "/login")
return
}
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxError(w, http.StatusUnauthorized, "Failed to delete resource, try again later.")
return
}
···
rkey := chi.URLParam(r, "rkey")
resource, err := db.GetResourceByRkey(h.Db, user.Did, rkey)
if err != nil {
-
log.Println("failed to get resource from db:", err)
+
l.Error("failed to get resource from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to delete resource, try again later.")
return
}
if user.Did != resource.Did {
-
log.Printf("user '%s' does not own record '%s'", user.Did, rkey)
+
l.Error("user does not own record", "did", user.Did, "resourceDid", resource.Did)
htmx.HxError(w, http.StatusUnauthorized, "You do not have permissions to delete this resource.")
return
}
···
Rkey: resource.Rkey,
})
if err != nil {
-
log.Println("failed to delete resource from PDS:", err)
+
l.Error("failed to delete resource from PDS", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to delete resource, try again later.")
return
}
err = SavePendingDelete(h, w, r, PendingResourceDeletion, resource)
if err != nil {
-
log.Printf("failed to save yoten-session to add pending resource deletion: %v", err)
+
l.Error("failed to save yoten-session to add pending resource deletion", "err", err)
}
if !h.Config.Core.Dev {
···
Set("resource_type", resource.Type),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleEditResourcePage(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleEditResourcePage")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
rkey := chi.URLParam(r, "rkey")
resource, err := db.GetResourceByRkey(h.Db, user.Did, rkey)
if err != nil {
-
log.Println("failed to get resource from db:", err)
+
l.Error("failed to get resource from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to update resource, try again later.")
return
}
if user.Did != resource.Did {
-
log.Printf("user '%s' does not own record '%s'", user.Did, rkey)
+
l.Error("user does not own record", "did", user.Did, "resourceDid", resource.Did)
htmx.HxError(w, http.StatusUnauthorized, "You do not have permissions to edit this resource.")
return
}
···
case http.MethodPost:
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
updatedResource, err := parseResourceForm(r)
if err != nil {
-
log.Println("invalid resource form:", err)
+
l.Error("invalid resource form", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Failed to create resource, ensure all fields contain valid data.")
return
}
···
updatedResource.CreatedAt = resource.CreatedAt
if err := db.ValidateResource(updatedResource); err != nil {
-
log.Println("invalid resource definition:", err)
+
l.Error("invalid resource definition", "err", err)
switch {
case errors.Is(err, db.ErrResourceTitleEmpty):
htmx.HxError(w, http.StatusBadRequest, "Resource must have a title.")
···
if updatedResource.Link != nil && (resource.Link == nil || *updatedResource.Link != *resource.Link) {
linkCheckResult := google.CheckResourceLinkSafety(*updatedResource.Link)
if linkCheckResult.Err != nil {
-
log.Println("invalid resource definition:", linkCheckResult.Err)
+
l.Error("invalid resource link", "link", resource.Link, "threatType", linkCheckResult.ThreatType, "err", linkCheckResult.Err)
switch {
case errors.Is(linkCheckResult.Err, google.ErrResourceLinkSketchy):
if !h.Config.Core.Dev {
···
SwapRecord: cid,
})
if err != nil {
-
log.Println("failed to update resource record:", err)
+
l.Error("failed to update resource record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to update resource, try again later.")
return
}
err = SavePendingUpdate(h, w, r, PendingResourceUpdates, updatedResource)
if err != nil {
-
log.Printf("failed to save yoten-session to add pending resource updates: %v", err)
+
l.Error("failed to save yoten-session to add pending resource updates", "err", err)
}
if !h.Config.Core.Dev {
···
Set("link_provided", updatedResource.Link != nil),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
+36 -27
internal/server/handlers/comment.go
···
package handlers
import (
-
"log"
"net/http"
"strings"
"time"
···
)
func (h *Handler) HandleNewComment(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleNewComment")
+
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
profile, err := db.GetProfile(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
err = r.ParseForm()
if err != nil {
-
log.Println("invalid comment form:", err)
+
l.Error("invalid comment form", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Unable to process comment, please try again later.")
return
}
commentBody := r.FormValue("comment")
if len(strings.TrimSpace(commentBody)) == 0 {
-
log.Println("invalid comment form: missing comment body")
+
l.Error("invalid comment form: missing comment body")
htmx.HxError(w, http.StatusBadRequest, "Comment cannot be empty.")
return
}
studySessionUri := r.FormValue("study_session_uri")
if len(studySessionUri) == 0 {
-
log.Println("invalid comment form: missing study session Uri")
+
l.Error("invalid comment form: missing study session Uri")
htmx.HxError(w, http.StatusBadRequest, "Unable to create comment, please try again later.")
return
}
···
},
})
if err != nil {
-
log.Println("failed to create comment record:", err)
+
l.Error("failed to create comment record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to create comment, try again later.")
return
}
···
err = h.Posthog.Enqueue(event)
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleDeleteComment(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleDeleteComment")
+
user := h.Oauth.GetUser(r)
if user == nil {
-
log.Println("failed to get logged-in user")
+
l.Error("failed to get logged-in user")
htmx.HxRedirect(w, "/login")
return
}
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
rkey := chi.URLParam(r, "rkey")
comment, err := db.GetCommentByRkey(h.Db, user.Did, rkey)
if err != nil {
-
log.Println("failed to get comment from db:", err)
+
l.Error("failed to get comment from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to delete comment, try again later.")
return
}
if user.Did != comment.Did {
-
log.Printf("user '%s' does not own record '%s'", user.Did, rkey)
+
l.Error("user does not own record", "did", user.Did, "commentDid", comment.Did)
htmx.HxError(w, http.StatusUnauthorized, "You do not have permissions to delete this comment.")
return
}
···
Rkey: comment.Rkey,
})
if err != nil {
-
log.Println("failed to delete comment from PDS:", err)
+
l.Error("failed to delete comment from PDS", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to delete comment, try again later.")
return
}
···
err = h.Posthog.Enqueue(event)
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleEditCommentPage(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleEditCommentPage")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
rkey := chi.URLParam(r, "rkey")
comment, err := db.GetCommentByRkey(h.Db, user.Did, rkey)
if err != nil {
-
log.Println("failed to get comment from db:", err)
+
l.Error("failed to get comment from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to update comment, try again later.")
return
}
if user.Did != comment.Did {
-
log.Printf("user '%s' does not own record '%s'", user.Did, rkey)
+
l.Error("user does not own record", "did", user.Did, "commentDid", comment.Did)
htmx.HxError(w, http.StatusUnauthorized, "You do not have permissions to edit this comment.")
return
}
···
case http.MethodPost:
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
err = r.ParseForm()
if err != nil {
-
log.Println("invalid comment form:", err)
+
l.Error("invalid comment form", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Unable to process comment, please try again later.")
return
}
commentBody := r.FormValue("comment")
if len(strings.TrimSpace(commentBody)) == 0 {
-
log.Println("invalid comment form: missing comment body")
+
l.Error("invalid comment form: missing comment body")
htmx.HxError(w, http.StatusBadRequest, "Comment cannot be empty.")
return
}
···
SwapRecord: cid,
})
if err != nil {
-
log.Println("failed to update study session record:", err)
+
l.Error("failed to update study session record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to update comment, try again later.")
return
}
···
err = h.Posthog.Enqueue(event)
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleReply(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleReply")
+
user := h.Oauth.GetUser(r)
if user == nil {
-
log.Println("failed to get logged-in user")
+
l.Error("failed to get logged-in user")
htmx.HxRedirect(w, "/login")
return
}
···
studySessionUri := r.URL.Query().Get("root")
parentCommentUri := r.URL.Query().Get("parent")
if len(studySessionUri) == 0 || len(parentCommentUri) == 0 {
-
log.Println("invalid reply form: study session uri or parent comment uri is empty")
+
l.Error("invalid reply form: study session uri or parent comment uri is empty")
htmx.HxError(w, http.StatusBadRequest, "Unable to process comment, please try again later.")
return
}
···
}
func (h *Handler) HandleCancelCommentEdit(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleCancelCommentEdit")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
rkey := chi.URLParam(r, "rkey")
comment, err := db.GetCommentByRkey(h.Db, user.Did, rkey)
if err != nil {
-
log.Println("failed to get comment from db:", err)
+
l.Error("failed to get comment from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to update comment, try again later.")
return
}
+11 -10
internal/server/handlers/follow.go
···
package handlers
import (
-
"log"
"net/http"
"time"
···
)
func (h *Handler) HandleFollow(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleFollow")
+
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
subjectIdent, err := h.IdResolver.ResolveIdent(r.Context(), subject)
if err != nil {
-
log.Println("failed to follow, invalid did:", err)
+
l.Error("failed to follow, invalid did", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Failed to follow profile, try again later.")
return
}
if user.Did == subjectIdent.DID.String() {
-
log.Println("failed to follow, cannot follow yourself")
+
l.Error("failed to follow, cannot follow yourself")
htmx.HxError(w, http.StatusBadRequest, "You cannot follow yourself.")
return
}
···
}},
})
if err != nil {
-
log.Println("failed to create follow record:", err)
+
l.Error("failed to create follow record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to follow profile, try again later.")
return
}
···
Set("is_mutual_follow", followStatus == db.IsMutual),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
case http.MethodDelete:
follow, err := db.GetFollow(h.Db, user.Did, subjectIdent.DID.String())
if err != nil {
-
log.Println("failed to get follow relationship:", err)
+
l.Error("failed to get follow relationship", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to unfollow profile, try again later.")
return
}
···
Rkey: follow.Rkey,
})
if err != nil {
-
log.Println("failed to delete follow record:", err)
+
l.Error("failed to delete follow record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to unfollow profile, try again later.")
return
}
···
Set("subject_did", subjectIdent.DID.String()),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
+29 -24
internal/server/handlers/activity.go
···
import (
"errors"
"fmt"
-
"log"
"net/http"
"time"
···
}
func (h *Handler) HandleNewActivityPage(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleNewActivityPage")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
case http.MethodPost:
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
newActivity, err := parseActivityForm(r)
if err != nil {
-
log.Println("invalid activity form:", err)
+
l.Error("invalid activity form", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Failed to create activity, ensure all fields contain valid data.")
return
}
···
newActivity.CreatedAt = time.Now().UTC()
if err := db.ValidateActivity(newActivity); err != nil {
-
log.Println("invalid activity def:", err)
+
l.Error("invalid activity def", "err", err)
switch {
case errors.Is(err, db.ErrActivityNameEmpty):
htmx.HxError(w, http.StatusBadRequest, "Activity must have a name.")
···
},
})
if err != nil {
-
log.Println("failed to create activity record:", err)
+
l.Error("failed to create activity record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to create activity, try again later.")
return
}
err = SavePendingCreate(h, w, r, PendingActivityCreation, newActivity)
if err != nil {
-
log.Printf("failed to save yoten-session to add pending activity creation: %v", err)
+
l.Error("failed to save yoten-session to add pending activity creation", "err", err)
}
if !h.Config.Core.Dev {
···
Set("category_count", len(categoriesString)),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleDeleteActivity(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleDeleteActivity")
+
user := h.Oauth.GetUser(r)
if user == nil {
-
log.Println("failed to get logged-in user")
+
l.Error("failed to get logged-in user")
htmx.HxRedirect(w, "/login")
return
}
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxError(w, http.StatusUnauthorized, "Failed to delete activity, try again later.")
return
}
···
rkey := chi.URLParam(r, "rkey")
activity, err := db.GetActivityByRkey(h.Db, user.Did, rkey)
if err != nil {
-
log.Println("failed to get activity from db:", err)
+
l.Error("failed to get activity from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to delete activity, try again later.")
return
}
if user.Did != activity.Did {
-
log.Printf("user '%s' does not own record '%s'", user.Did, rkey)
+
l.Error("user does not own record", "did", user.Did, "activityDid", activity.Did)
htmx.HxError(w, http.StatusUnauthorized, "You do not have permissions to edit this activity.")
return
}
···
Rkey: activity.Rkey,
})
if err != nil {
-
log.Println("failed to delete activity from PDS:", err)
+
l.Error("failed to delete activity from PDS", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to delete activity, try again later.")
return
}
err = SavePendingDelete(h, w, r, PendingActivityDeletion, activity)
if err != nil {
-
log.Printf("failed to save yoten-session to add pending activity deletion: %v", err)
+
l.Error("failed to save yoten-session to add pending activity deletion", "err", err)
}
if !h.Config.Core.Dev {
···
Set("activity_id", activity.ID),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
}
func (h *Handler) HandleEditActivityPage(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleEditActivityPage")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
rkey := chi.URLParam(r, "rkey")
activity, err := db.GetActivityByRkey(h.Db, user.Did, rkey)
if err != nil {
-
log.Println("failed to get activity from db:", err)
+
l.Error("failed to get activity from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to update activity, try again later.")
return
}
if user.Did != activity.Did {
-
log.Printf("user '%s' does not own record '%s'", user.Did, rkey)
+
l.Error("user does not own record", "did", user.Did, "activityDid", activity.Did)
htmx.HxError(w, http.StatusUnauthorized, "You do not have permissions to edit this activity.")
return
}
···
case http.MethodPost:
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
updatedActivity, err := parseActivityForm(r)
if err != nil {
-
log.Println("invalid activity form:", err)
+
l.Error("invalid activity form", "err", err)
htmx.HxError(w, http.StatusBadRequest, "Failed to create activity, ensure all fields contain valid data.")
return
}
···
updatedActivity.CreatedAt = activity.CreatedAt
if err := db.ValidateActivity(updatedActivity); err != nil {
-
log.Println("invalid activity def:", err)
+
l.Error("invalid activity def", "err", err)
switch {
case errors.Is(err, db.ErrActivityNameEmpty):
htmx.HxError(w, http.StatusBadRequest, "Activity must have a name.")
···
SwapRecord: cid,
})
if err != nil {
-
log.Println("failed to update study session record:", err)
+
l.Error("failed to update study session record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to update activity, try again later.")
return
}
err = SavePendingUpdate(h, w, r, PendingActivityUpdates, updatedActivity)
if err != nil {
-
log.Printf("failed to save yoten-session to add pending activity updates: %v", err)
+
l.Error("failed to save yoten-session to add pending activity updates", "err", err)
}
if !h.Config.Core.Dev {
···
Set("category_count", len(categoriesString)),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
+10 -7
internal/server/handlers/notification.go
···
package handlers
import (
-
"log"
"net/http"
"strconv"
···
)
func (h *Handler) HandleNotificationFeed(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleNotificationFeed")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
}
page, err := strconv.ParseInt(pageStr, 10, 64)
if err != nil {
-
log.Println("failed to parse page value:", err)
+
l.Error("failed to parse page value", "err", err)
page = 1
}
if page == 0 {
···
case http.MethodGet:
notifications, err := db.GetNotificationsByDid(h.Db, user.Did, pageSize+1, int(offset))
if err != nil {
-
log.Println("failed to retrieve notifications:", err)
+
l.Error("failed to retrieve notifications", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get notifications, try again later.")
return
}
hydratedNotifications, err := h.getBskyProfileHydratedNotificationFeed(notifications)
if err != nil {
-
log.Println("failed to hydrate notifications with bsky profile:", err)
+
l.Error("failed to hydrate notifications with bsky profile", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get notifications, try again later.")
return
}
···
}
func (h *Handler) HandleNotificationMarkAllRead(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleNotificationMarkAllRead")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
err = db.MarkAllNotificationsAsRead(h.Db, user.Did)
if err != nil {
-
log.Println("failed to mark all notifications:", err)
+
l.Error("failed to mark all notifications", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to mark all notifications as read, try again later.")
return
}
+17 -17
internal/server/handlers/reaction.go
···
package handlers
import (
-
"log"
"net/http"
"slices"
"strconv"
···
)
func (h *Handler) HandleReaction(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleReaction")
+
client, err := h.Oauth.AuthorizedClient(r)
if err != nil {
-
log.Println("failed to get authorized client:", err)
+
l.Error("failed to get authorized client", "err", err)
htmx.HxRedirect(w, "/login")
return
}
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
}
if user.Did == session.Did {
-
log.Println("failed to react to study session, cannot react to your own study session")
+
l.Error("failed to react to study session, cannot react to your own study session")
htmx.HxError(w, http.StatusBadRequest, "You cannot react to your own study sessions.")
return
}
···
reaction, err := db.ReactionFromString(db.ReactionType(reactionId).String())
if err != nil {
-
log.Printf("failed to get reaction types: %v", err)
+
l.Error("failed to get reaction types", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")
return
}
reactionEvents, err := db.GetReactionsForSession(h.Db, subjectDid, subjectRkey)
if err != nil {
-
log.Println("failed to get reactions for study session from db:", err)
+
l.Error("failed to get reactions for study session from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to get global study session feed, try again later.")
return
}
···
case http.MethodPost:
reactionEvent, err := db.GetReactionEvent(h.Db, user.Did, session, reaction.ID)
if err != nil {
-
log.Println("failed to get reaction event from db:", err)
+
l.Error("failed to get reaction event from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to add reaction, try again later.")
return
}
if reactionEvent != nil {
-
log.Println("failed to add reaction, user already reacted")
+
l.Error("failed to add reaction, user already reacted")
htmx.HxError(w, http.StatusBadRequest, "You cannot react multiple times with the same reaction.")
return
}
···
}},
})
if err != nil {
-
log.Println("failed to create reaction record:", err)
+
l.Error("failed to create reaction record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to add reaction, try again later.")
return
}
···
Set("session_rkey", subjectRkey),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
case http.MethodDelete:
reactionEvent, err := db.GetReactionEvent(h.Db, user.Did, session, reaction.ID)
if err != nil {
-
log.Println("failed to get reaction event from db:", err)
+
l.Error("failed to get reaction event from db", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to remove reaction, try again later.")
return
}
···
Rkey: reactionEvent.Rkey,
})
if err != nil {
-
log.Println("failed to delete reaction record:", err)
+
l.Error("failed to delete reaction record", "err", err)
htmx.HxError(w, http.StatusInternalServerError, "Failed to remove reaction, try again later.")
return
}
···
Set("session_rkey", subjectRkey),
})
if err != nil {
-
log.Println("failed to enqueue posthog event:", err)
+
l.Error("failed to enqueue posthog event", "err", err)
}
}
···
})
partials.NewReactions(partials.NewReactionsProps{
-
User: user,
-
SessionRkey: subjectRkey,
-
SessionDid: subjectDid,
-
// Reactions: reactions,
+
User: user,
+
SessionRkey: subjectRkey,
+
SessionDid: subjectDid,
ReactionEvents: reactionEvents,
}).Render(r.Context(), w)
}
+14 -11
internal/server/handlers/stats.go
···
package handlers
import (
-
"log"
"net/http"
"yoten.app/internal/clients/bsky"
···
)
func (h *Handler) HandleTimePerGraphs(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleTimePerGraphs")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
···
chartData, err := db.GetTimePerData(h.Db, user.Did, period)
if err != nil {
-
log.Println("failed to get time per chart data:", err)
+
l.Error("failed to get time per chart data", "err", err)
chartData = db.ChartsData{
ActivityData: []db.ChartData{},
CategoryData: []db.ChartData{},
···
}
func (h *Handler) HandleStatsPage(w http.ResponseWriter, r *http.Request) {
+
l := h.Logger.With("handler", "HandleStatsPage")
+
user, err := bsky.GetUserWithBskyProfile(h.Oauth, r)
if err != nil {
-
log.Println("failed to get logged-in user:", err)
+
l.Error("failed to get logged-in user", "err", err)
htmx.HxRedirect(w, "/login")
return
}
totalStudyTime, err := db.GetTotalStudyTime(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get total study time:", err)
+
l.Error("failed to get total study time", "err", err)
}
totalStudySessions, err := db.GetTotalStudySessions(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get total study study sessions:", err)
+
l.Error("failed to get total study study sessions", "err", err)
}
totalActiveDays, err := db.GetTotalActiveDays(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get total active days:", err)
+
l.Error("failed to get total active days", "err", err)
}
streak, err := db.GetCurrentStreak(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get streak:", err)
+
l.Error("failed to get streak", "err", err)
}
heatmap, err := db.GetHeatmapData(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get heatmap data:", err)
+
l.Error("failed to get heatmap data", "err", err)
}
inputOutputPercentage, err := db.GetInputOutputPercentage(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get input vs output data:", err)
+
l.Error("failed to get input vs output data", "err", err)
}
languageSummary, err := db.GetLanguageSummary(h.Db, user.Did)
if err != nil {
-
log.Println("failed to get language time summary:", err)
+
l.Error("failed to get language time summary", "err", err)
}
languageChartSegments := db.ConvertToDonutChartSegments(languageSummary)
+30 -20
internal/consumer/ingester.go
···
"context"
"encoding/json"
"fmt"
-
"log"
+
"log/slog"
"strings"
"time"
···
type Ingester struct {
Db db.DbWrapper
Config *config.Config
+
Logger *slog.Logger
}
type processFunc func(ctx context.Context, e *models.Event) error
···
}
}()
+
l := i.Logger.With("kind", e.Kind)
switch e.Kind {
case models.EventKindCommit:
switch e.Commit.Collection {
case yoten.ActorProfileNSID:
+
l = l.With("handler", "ingestProfile")
err = i.ingestProfile(e)
case yoten.FeedSessionNSID:
+
l = l.With("handler", "ingestStudySession")
err = i.ingestStudySession(e)
case yoten.ActivityDefNSID:
+
l = l.With("handler", "ingestActivityDef")
err = i.ingestActivityDef(e)
case yoten.FeedResourceNSID:
+
l = l.With("handler", "ingestResource")
err = i.ingestResource(e)
case yoten.GraphFollowNSID:
+
l = l.With("handler", "ingestFollow")
err = i.ingestFollow(e)
case yoten.FeedReactionNSID:
+
l = l.With("handler", "ingestReaction")
err = i.ingestReaction(e)
case yoten.FeedCommentNSID:
+
l = l.With("handler", "ingestComment")
err = i.ingestComment(e)
}
+
l = i.Logger.With("nsid", e.Commit.Collection)
}
if err != nil {
-
log.Printf("failed to ingest event for collection %s: %v", e.Commit.Collection, err)
+
l.Error("failed to ingest event", "err", err)
}
return nil
···
return fmt.Errorf("failed to start transaction: %w", err)
}
-
log.Printf("upserting profile '%s' from pds request", profile.Did)
+
i.Logger.Debug("upserting profile from pds request")
err = db.UpsertProfile(tx, &profile)
if err != nil {
tx.Rollback()
···
date, err := time.Parse(time.RFC3339, record.Date)
if err != nil {
-
log.Printf("invalid record: %s", err)
+
i.Logger.Error("invalid record", "err", err)
return err
}
···
return fmt.Errorf("failed to start transaction: %w", err)
}
-
log.Println("upserting study session from pds request")
+
i.Logger.Debug("upserting study session from pds request")
err = db.UpsertStudySession(tx, &studySession, e.Commit.RKey)
if err != nil {
tx.Rollback()
···
return fmt.Errorf("failed to start transaction: %w", err)
}
-
log.Println("deleting study session from pds request")
+
i.Logger.Debug("deleting study session from pds request")
err = db.DeleteStudySessionByRkey(tx, did, e.Commit.RKey)
if err != nil {
tx.Rollback()
···
return fmt.Errorf("failed to start transaction: %w", err)
}
-
log.Println("upserting activity def from pds request")
+
i.Logger.Debug("upserting activity def from pds request")
err = db.UpsertActivityDef(tx, &activityDef, e.Commit.RKey)
if err != nil {
tx.Rollback()
···
}
return tx.Commit()
case models.CommitOperationDelete:
-
log.Println("deleting activity def from pds request")
+
i.Logger.Debug("deleting activity def from pds request")
err = db.DeleteActivityDefByRkey(i.Db, did, e.Commit.RKey)
}
if err != nil {
···
subjectDid := record.Subject
-
log.Println("upserting follow from pds request")
+
i.Logger.Debug("upserting follow from pds request")
err = db.AddFollow(tx, did, subjectDid, e.Commit.RKey)
if err != nil {
tx.Rollback()
···
subjectUri := fmt.Sprintf("at://%s/%s/%s", did, yoten.GraphFollowNSID, e.Commit.RKey)
err = db.CreateNotification(tx, subjectDid, did, subjectUri, db.NotificationTypeFollow)
if err != nil {
-
log.Println("failed to create notification record:", err)
+
i.Logger.Error("failed to create notification record", "err", err)
}
return tx.Commit()
case models.CommitOperationDelete:
-
log.Println("deleting follow from pds request")
+
i.Logger.Debug("deleting follow from pds request")
err = db.DeleteFollowByRkey(i.Db, did, e.Commit.RKey)
}
if err != nil {
···
CreatedAt: createdAt,
}
-
log.Println("upserting reaction from pds request")
+
i.Logger.Debug("upserting reaction from pds request")
err = db.UpsertReaction(i.Db, reactionEvent)
if err != nil {
tx.Rollback()
···
err = db.CreateNotification(tx, subjectDid.String(), did, subject.String(), db.NotificationTypeReaction)
if err != nil {
-
log.Println("failed to create notification record:", err)
+
i.Logger.Error("failed to create notification record", "err", err)
}
return tx.Commit()
case models.CommitOperationDelete:
-
log.Println("deleting reaction from pds request")
+
i.Logger.Debug("deleting reaction from pds request")
err = db.DeleteReactionByRkey(i.Db, did, e.Commit.RKey)
}
if err != nil {
···
return fmt.Errorf("invalid resource: %w", err)
}
-
log.Println("upserting resource from pds request")
+
i.Logger.Debug("upserting resource from pds request")
err = db.UpsertResource(i.Db, resource, resource.Rkey)
if err != nil {
tx.Rollback()
···
}
return tx.Commit()
case models.CommitOperationDelete:
-
log.Println("deleting resource from pds request")
+
i.Logger.Debug("deleting resource from pds request")
err = db.DeleteResourceByRkey(i.Db, did, e.Commit.RKey)
}
if err != nil {
···
CreatedAt: createdAt,
}
-
log.Println("upserting comment from pds request")
+
i.Logger.Debug("upserting comment from pds request")
err = db.UpsertComment(i.Db, comment)
if err != nil {
tx.Rollback()
···
if subjectDid.String() != did {
err = db.CreateNotification(tx, subjectDid.String(), did, subjectUri.String(), db.NotificationTypeComment)
if err != nil {
-
log.Println("failed to create notification record:", err)
+
i.Logger.Error("failed to create notification record", "err", err)
}
}
···
if comment.ParentCommentUri != nil && comment.ParentCommentUri.Authority().String() != did {
err = db.CreateNotification(tx, comment.ParentCommentUri.Authority().String(), did, parentCommentUri.String(), db.NotificationTypeReply)
if err != nil {
-
log.Println("failed to create notification record:", err)
+
i.Logger.Error("failed to create notification record", "err", err)
}
}
return tx.Commit()
case models.CommitOperationDelete:
-
log.Println("deleting comment from pds request")
+
i.Logger.Debug("deleting comment from pds request")
err = db.DeleteCommentByRkey(i.Db, did, e.Commit.RKey)
}
if err != nil {
+2
internal/server/handlers/router.go
···
"github.com/go-chi/chi/v5"
"yoten.app/internal/server"
+
"yoten.app/internal/server/log"
"yoten.app/internal/server/middleware"
"yoten.app/internal/server/views"
)
···
h.Oauth,
h.Db,
h.IdResolver,
+
log.SubLogger(h.Logger, "middleware"),
)
router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {
+13 -6
internal/server/middleware/middleware.go
···
import (
"context"
"fmt"
-
"log"
+
"log/slog"
"net/http"
"net/url"
"slices"
···
oauth *oauth.OAuth
db *db.DB
idResolver *atproto.Resolver
+
logger *slog.Logger
}
-
func New(oauth *oauth.OAuth, db *db.DB, idResolver *atproto.Resolver) Middleware {
+
func New(oauth *oauth.OAuth, db *db.DB, idResolver *atproto.Resolver, logger *slog.Logger) Middleware {
return Middleware{
oauth: oauth,
db: db,
idResolver: idResolver,
+
logger: logger,
}
}
type middlewareFunc func(http.Handler) http.Handler
func AuthMiddleware(o *oauth.OAuth) middlewareFunc {
+
l := o.Logger.With("middleware", "AuthMiddleware")
+
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
returnURL := "/"
···
sess, err := o.ResumeSession(r)
if err != nil {
-
log.Println("failed to resume session, redirecting...", "err", err, "url", r.URL.String())
+
l.Error("failed to resume session, redirecting...", "err", err, "url", r.URL.String())
redirectFunc(w, r)
return
}
if sess == nil {
-
log.Printf("session is nil, redirecting...")
+
l.Warn("session is nil, redirecting...")
redirectFunc(w, r)
return
}
···
}
func (mw Middleware) ResolveIdent() middlewareFunc {
+
l := mw.logger.With("middleware", "ResolveIdent")
excluded := []string{"favicon.ico"}
return func(next http.Handler) http.Handler {
···
id, err := mw.idResolver.ResolveIdent(r.Context(), didOrHandle)
if err != nil {
-
log.Println("failed to resolve did/handle:", err)
+
l.Error("failed to resolve did/handle", "err", err)
w.WriteHeader(http.StatusNotFound)
views.NotFoundPage(views.NotFoundPageParams{}).Render(r.Context(), w)
return
···
}
func (mw Middleware) LoadUnreadNotificationCount() middlewareFunc {
+
l := mw.logger.With("middleware", "LoadUnreadNotificationCount")
+
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
user := mw.oauth.GetUser(r)
···
count, err := db.GetUnreadNotificationCount(mw.db, user.Did)
if err != nil {
-
log.Println("failed to get notification count:", err)
+
l.Error("failed to get notification count", "err", err)
}
ctx := context.WithValue(r.Context(), UnreadNotificationCountCtxKey, count)
+2 -2
internal/server/handlers/login.go
···
// Basic handle validation
if !strings.Contains(handle, ".") {
l.Error("invalid handle format", "handle", handle)
-
htmx.HxError(w, http.StatusBadGateway, fmt.Sprintf("'%s' is an invalid handle. Did you mean %s.bsky.social?", handle, handle))
+
htmx.HxError(w, http.StatusBadRequest, fmt.Sprintf("'%s' is an invalid handle. Did you mean %s.bsky.social?", handle, handle))
return
}
resolved, err := h.IdResolver.ResolveIdent(context.Background(), handle)
if err != nil {
l.Error("failed to resolve handle", "handle", handle, "err", err)
-
htmx.HxError(w, http.StatusBadGateway, fmt.Sprintf("'%s' is an invalid handle", handle))
+
htmx.HxError(w, http.StatusBadRequest, fmt.Sprintf("'%s' is an invalid handle", handle))
return
} else {
if !h.Config.Core.Dev && resolved.DID.String() != "" {