mkelvers/mal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add toggle watchlist on anime cards and improve dropdown

Browse Source
This commit is contained in:
mkelvers
2026-05-02 15:28:37 +02:00
committed by Mikkel Elvers
parent 94e60e0d8b
commit cc9ca1ba9e
14 changed files with 396 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
api/anime/handler.go
View File

@@ -83,9 +83,17 @@ func (h *Handler) HandleCatalog(w http.ResponseWriter, r *http.Request) {
// We'll skip DB fetch for continue watching for now if it requires complex session parsing
// Actually we should try to fetch it if we can.
var cw []database.GetContinueWatchingEntriesRow
watchlistMap := make(map[int64]bool)
var watchlistIDs []int64
user, userOk := r.Context().Value(ctxpkg.UserKey).(*database.User)
if userOk && user != nil {
cw, _ = h.db.GetContinueWatchingEntries(r.Context(), user.ID)
watchlist, _ := h.db.GetUserWatchList(r.Context(), user.ID)
watchlistIDs = make([]int64, len(watchlist))
for i, entry := range watchlist {
watchlistMap[entry.AnimeID] = true
watchlistIDs[i] = entry.AnimeID
}
}
if err := templates.GetRenderer().ExecuteTemplate(w, "index.gohtml", map[string]any{
@@ -94,6 +102,8 @@ func (h *Handler) HandleCatalog(w http.ResponseWriter, r *http.Request) {
"ContinueWatching": cw,
"User": user,
"CurrentPath": r.URL.Path,
"WatchlistMap": watchlistMap,
"WatchlistIDs": watchlistIDs,
}); err != nil {
log.Printf("render error: %v", err)
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
@@ -114,15 +124,28 @@ func (h *Handler) HandleBrowse(w http.ResponseWriter, r *http.Request) {
log.Printf("browse error: %v", err)
}
watchlistMap := make(map[int64]bool)
var watchlistIDs []int64
if user != nil {
watchlist, _ := h.db.GetUserWatchList(r.Context(), user.ID)
watchlistIDs = make([]int64, len(watchlist))
for i, entry := range watchlist {
watchlistMap[entry.AnimeID] = true
watchlistIDs[i] = entry.AnimeID
}
}
if err := templates.GetRenderer().ExecuteTemplate(w, "browse.gohtml", map[string]any{
"User": user,
"CurrentPath": r.URL.Path,
"Query": q,
"Type": animeType,
"Status": status,
"OrderBy": orderBy,
"Sort": sort,
"Animes": res.Animes,
"User": user,
"CurrentPath": r.URL.Path,
"Query": q,
"Type": animeType,
"Status": status,
"OrderBy": orderBy,
"Sort": sort,
"Animes": res.Animes,
"WatchlistMap": watchlistMap,
"WatchlistIDs": watchlistIDs,
}); err != nil {
log.Printf("render error: %v", err)
http.Error(w, "Internal Server Error", http.StatusInternalServerError)

110
api/watchlist/handler.go
View File

@@ -1,9 +1,13 @@
package watchlist
import (
"encoding/json"
"log"
"net/http"
"strconv"
ctxpkg "mal/internal/context"
database "mal/internal/db"
"mal/templates"
)
@@ -20,11 +24,61 @@ func (h *Handler) HandleCardWatchlist(w http.ResponseWriter, r *http.Request) {
}
func (h *Handler) HandleUpdateWatchlist(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Not implemented", http.StatusNotImplemented)
if r.Method != http.MethodPost {
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
user, _ := r.Context().Value(ctxpkg.UserKey).(*database.User)
if user == nil {
http.Error(w, "unauthorized", http.StatusUnauthorized)
return
}
var body struct {
AnimeID int64 `json:"animeId"`
Status string `json:"status"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
http.Error(w, "invalid request", http.StatusBadRequest)
return
}
if body.Status == "" {
body.Status = "plan_to_watch"
}
if err := h.service.AddToWatchlist(r.Context(), user.ID, body.AnimeID, body.Status); err != nil {
log.Printf("failed to add to watchlist: %v", err)
http.Error(w, "failed to add to watchlist", http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
}
func (h *Handler) HandleDeleteWatchlist(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Not implemented", http.StatusNotImplemented)
user, _ := r.Context().Value(ctxpkg.UserKey).(*database.User)
if user == nil {
http.Error(w, "unauthorized", http.StatusUnauthorized)
return
}
animeIDStr := r.URL.Path[len("/api/watchlist/"):]
animeID, err := strconv.ParseInt(animeIDStr, 10, 64)
if err != nil {
http.Error(w, "invalid anime id", http.StatusBadRequest)
return
}
if _, err := h.service.RemoveEntry(r.Context(), user.ID, animeID); err != nil {
log.Printf("failed to remove from watchlist: %v", err)
http.Error(w, "failed to remove from watchlist", http.StatusInternalServerError)
return
}
w.Header().Set("HX-Redirect", "/watchlist")
w.WriteHeader(http.StatusOK)
}
func (h *Handler) HandleDeleteContinueWatching(w http.ResponseWriter, r *http.Request) {
@@ -32,9 +86,55 @@ func (h *Handler) HandleDeleteContinueWatching(w http.ResponseWriter, r *http.Re
}
func (h *Handler) HandleGetWatchlist(w http.ResponseWriter, r *http.Request) {
if err := templates.GetRenderer().ExecuteTemplate(w, "not_found.gohtml", map[string]any{
"CurrentPath": r.URL.Path,
}); err != nil {
user, _ := r.Context().Value(ctxpkg.UserKey).(*database.User)
if user == nil {
http.Redirect(w, r, "/login", http.StatusSeeOther)
return
}
entries, err := h.service.GetUserWatchlist(r.Context(), user.ID)
if err != nil {
log.Printf("failed to fetch watchlist: %v", err)
if err := templates.GetRenderer().ExecuteTemplate(w, "not_found.gohtml", map[string]any{
"CurrentPath": r.URL.Path,
}); err != nil {
log.Printf("render error: %v", err)
}
return
}
watchlistByStatus := make(map[string][]database.GetUserWatchListRow)
allEntries := make([]database.GetUserWatchListRow, 0)
for _, entry := range entries {
status := entry.Status
if status == "" {
status = "plan_to_watch"
}
watchlistByStatus[status] = append(watchlistByStatus[status], entry)
allEntries = append(allEntries, entry)
}
data := map[string]any{
"CurrentPath": r.URL.Path,
"WatchlistByStatus": watchlistByStatus,
"AllEntries": allEntries,
"StatusOrder": []string{"watching", "plan_to_watch", "on_hold", "completed", "dropped"},
"StatusLabels": map[string]string{
"watching": "Currently Watching",
"plan_to_watch": "Plan to Watch",
"on_hold": "On Hold",
"completed": "Completed",
"dropped": "Dropped",
},
}
templateName := "watchlist.gohtml"
if r.Header.Get("HX-Request") == "true" {
templateName = "watchlist_partial.gohtml"
}
if err := templates.GetRenderer().ExecuteTemplate(w, templateName, data); err != nil {
log.Printf("render error: %v", err)
}
}

64
api/watchlist/service.go
View File

@@ -9,12 +9,14 @@ import (
"github.com/google/uuid"
"mal/integrations/jikan"
"mal/internal/db"
)
type Service struct {
db database.Querier
sqlDB *sql.DB
db database.Querier
sqlDB *sql.DB
jikanClient *jikan.Client
}
var (
@@ -23,13 +25,41 @@ var (
)
var validStatuses = map[string]struct{}{
"watching": {},
"completed": {},
"dropped": {},
"plan_to_watch": {},
"on_hold": {},
}
func NewService(db database.Querier, sqlDB *sql.DB) *Service {
return &Service{db: db, sqlDB: sqlDB}
func NewService(db database.Querier, sqlDB *sql.DB, jikanClient *jikan.Client) *Service {
return &Service{db: db, sqlDB: sqlDB, jikanClient: jikanClient}
}
func (s *Service) ensureAnimeExists(ctx context.Context, animeID int64) error {
_, err := s.db.GetAnime(ctx, animeID)
if err == nil {
return nil
}
anime, err := s.jikanClient.GetAnimeByID(ctx, int(animeID))
if err != nil {
return fmt.Errorf("failed to fetch anime from jikan: %w", err)
}
_, err = s.db.UpsertAnime(ctx, database.UpsertAnimeParams{
ID: int64(anime.MalID),
TitleOriginal: anime.Title,
TitleEnglish: sql.NullString{String: anime.TitleEnglish, Valid: anime.TitleEnglish != ""},
TitleJapanese: sql.NullString{String: anime.TitleJapanese, Valid: anime.TitleJapanese != ""},
ImageUrl: anime.Images.Jpg.LargeImageURL,
Airing: sql.NullBool{Bool: anime.Airing, Valid: true},
})
if err != nil {
return fmt.Errorf("failed to save anime: %w", err)
}
return nil
}
type AddRequest struct {
@@ -42,34 +72,26 @@ type AddRequest struct {
Airing bool
}
func (s *Service) AddEntry(ctx context.Context, userID string, req AddRequest) error {
if req.AnimeID <= 0 {
func (s *Service) AddToWatchlist(ctx context.Context, userID string, animeID int64, status string) error {
if animeID <= 0 {
return ErrInvalidAnimeID
}
if _, ok := validStatuses[req.Status]; !ok {
if _, ok := validStatuses[status]; !ok {
return ErrInvalidStatus
}
_, err := s.db.UpsertAnime(ctx, database.UpsertAnimeParams{
ID: req.AnimeID,
TitleOriginal: req.TitleOriginal,
TitleEnglish: sql.NullString{String: req.TitleEnglish, Valid: req.TitleEnglish != ""},
TitleJapanese: sql.NullString{String: req.TitleJapanese, Valid: req.TitleJapanese != ""},
ImageUrl: req.ImageURL,
Airing: sql.NullBool{Bool: req.Airing, Valid: true},
})
if err != nil {
return fmt.Errorf("failed to save anime reference: %w", err)
if err := s.ensureAnimeExists(ctx, animeID); err != nil {
return err
}
entryID := uuid.New().String()
_, err = s.db.UpsertWatchListEntry(ctx, database.UpsertWatchListEntryParams{
_, err := s.db.UpsertWatchListEntry(ctx, database.UpsertWatchListEntryParams{
ID: entryID,
UserID: userID,
AnimeID: req.AnimeID,
Status: req.Status,
CurrentEpisode: sql.NullInt64{Int64: 0, Valid: false},
AnimeID: animeID,
Status: status,
CurrentEpisode: sql.NullInt64{Valid: false},
CurrentTimeSeconds: 0,
})
if err != nil {