Florian Wilde
40fb49fb21
CI / pruefen (pull_request) Canceled after 0s
War ein Film einmal als gesehen markiert, gab es keinen Weg zurueck: im
Zustand "gesehen" stand statt eines Knopfes ein <p> — ein Etikett ohne
Klickziel. Der Statuswechsel konnte das nicht heilen, weil "gesehen" aus den
Sichtungen abgeleitet wird und setStatus() die absichtlich nicht anfasst.
Und eine Gegenfunktion fuer Filme gab es nicht: unmarkEpisodes() und
unmarkSeason() waren da, ein unmarkMovie() nie geschrieben.
unmarkMovie() ist auf run: entry.currentRun und episodeId: null eingegrenzt.
Wer einen Film dreimal gesehen hat, hat drei Sichtungen — ohne die
Eingrenzung loeschte das Zuruecknehmen alle drei und verfaelschte
rueckwirkend die Statistik.
Die gruene Plakette bleibt stehen, ist jetzt aber klickbar, so wie sich
Episodenhaekchen auch abwaehlen lassen. Ueber die Schnittstelle geht es mit
DELETE {"action":"movie"} als Gegenstueck zum gleichnamigen POST, ohne dass
man die watchIds kennen muss.
Drei Tests: Zuruecknehmen samt erneutem Abhaken, die Eingrenzung auf den
laufenden Durchlauf, und dass Serien abgewiesen werden. Klickweg und
Endpunkt gegen einen Produktionsbau geprueft.
Der im Issue vermutete Nebenpunkt trifft nicht zu: report() blendet das
Zuruecknehmen nur bei ids.length > 0 ein, ein wirkungsloses Angebot gab es
also nie.
Refs #5
105 lines
3.2 KiB
TypeScript
105 lines
3.2 KiB
TypeScript
import { z } from "zod";
|
|
import { apiError, readJson, withApi } from "@/lib/api";
|
|
import { prisma } from "@/lib/db";
|
|
import {
|
|
markEpisodesWatched,
|
|
markMovieWatched,
|
|
markSeasonWatched,
|
|
markUpTo,
|
|
undoWatches,
|
|
unmarkEpisodes,
|
|
unmarkMovie,
|
|
watchNextEpisode,
|
|
} from "@/lib/library";
|
|
|
|
/** GET — die Sichtungen eines Eintrags, jüngste zuerst. */
|
|
export const GET = withApi(async (_request, user, context) => {
|
|
const { entryId } = await context.params;
|
|
if (!entryId) return apiError("Es fehlt die Kennung des Eintrags.", 400);
|
|
|
|
const watches = await prisma.watch.findMany({
|
|
where: { userId: user.id, entryId },
|
|
orderBy: { watchedAt: "desc" },
|
|
take: 500,
|
|
include: { episode: { select: { seasonNumber: true, episodeNumber: true, name: true } } },
|
|
});
|
|
|
|
return {
|
|
total: watches.length,
|
|
items: watches.map((watch) => ({
|
|
id: watch.id,
|
|
run: watch.run,
|
|
watchedAt: watch.watchedAt,
|
|
minutes: watch.minutes,
|
|
episode: watch.episode,
|
|
})),
|
|
};
|
|
});
|
|
|
|
const postSchema = z.union([
|
|
z.object({ action: z.literal("next") }),
|
|
z.object({ action: z.literal("movie") }),
|
|
z.object({
|
|
action: z.literal("episodes"),
|
|
episodeIds: z.array(z.string().min(1)).min(1).max(500),
|
|
}),
|
|
z.object({ action: z.literal("season"), seasonId: z.string().min(1) }),
|
|
z.object({ action: z.literal("upTo"), episodeId: z.string().min(1) }),
|
|
]);
|
|
|
|
/**
|
|
* POST — etwas als gesehen markieren.
|
|
*
|
|
* Die Antwort enthält immer `watchIds`. Damit lässt sich die Aktion über
|
|
* DELETE gezielt zurücknehmen, ohne raten zu müssen, was dazugehörte.
|
|
*/
|
|
export const POST = withApi(async (request, user, context) => {
|
|
const { entryId } = await context.params;
|
|
if (!entryId) return apiError("Es fehlt die Kennung des Eintrags.", 400);
|
|
|
|
const body = await readJson(request, postSchema);
|
|
|
|
switch (body.action) {
|
|
case "next":
|
|
return watchNextEpisode(user.id, entryId);
|
|
case "movie":
|
|
return markMovieWatched(user.id, entryId);
|
|
case "episodes":
|
|
return markEpisodesWatched(user.id, entryId, body.episodeIds);
|
|
case "season":
|
|
return markSeasonWatched(user.id, entryId, body.seasonId);
|
|
case "upTo":
|
|
return markUpTo(user.id, entryId, body.episodeId);
|
|
}
|
|
});
|
|
|
|
const deleteSchema = z.union([
|
|
z.object({ watchIds: z.array(z.string().min(1)).min(1).max(500) }),
|
|
z.object({ episodeIds: z.array(z.string().min(1)).min(1).max(500) }),
|
|
z.object({ action: z.literal("movie") }),
|
|
]);
|
|
|
|
/**
|
|
* DELETE — Sichtungen zurücknehmen.
|
|
*
|
|
* Drei Wege: gezielt über `watchIds` (die Antwort eines POST), über
|
|
* `episodeIds`, oder mit `{"action":"movie"}` als Gegenstück zum
|
|
* gleichnamigen POST — dafür braucht man die `watchIds` nicht zu kennen.
|
|
* Zurückgenommen wird immer nur der laufende Durchlauf.
|
|
*/
|
|
export const DELETE = withApi(async (request, user, context) => {
|
|
const { entryId } = await context.params;
|
|
if (!entryId) return apiError("Es fehlt die Kennung des Eintrags.", 400);
|
|
|
|
const body = await readJson(request, deleteSchema);
|
|
|
|
if ("watchIds" in body) {
|
|
await undoWatches(user.id, entryId, body.watchIds);
|
|
} else if ("episodeIds" in body) {
|
|
await unmarkEpisodes(user.id, entryId, body.episodeIds);
|
|
} else {
|
|
await unmarkMovie(user.id, entryId);
|
|
}
|
|
return { ok: true };
|
|
});
|