Merge pull request #291 from mchestr/feat/discord-marked-media

Admin Discord: Marked Media view (see what users marked)

Author: mchestr

actions/__tests__/discord-marked-media.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Tests for actions/discord-activity.ts - getDiscordMarkedMedia
+ *
+ * Covers: admin gating, per-type summary, mark-type/source/search/date filters,
+ * pagination, serialization, and error handling.
+ */
+
+import { getDiscordMarkedMedia } from "@/actions/discord-activity"
+import { requireAdmin } from "@/lib/admin"
+import { prisma } from "@/lib/prisma"
+
+jest.mock("@/lib/admin", () => ({
+  requireAdmin: jest.fn(),
+}))
+
+jest.mock("@/lib/prisma", () => ({
+  prisma: {
+    userMediaMark: {
+      findMany: jest.fn(),
+      count: jest.fn(),
+      groupBy: jest.fn(),
+    },
+  },
+}))
+
+jest.mock("@/lib/utils/logger", () => ({
+  createLogger: () => ({ info: jest.fn(), error: jest.fn(), warn: jest.fn() }),
+}))
+
+const mockRequireAdmin = requireAdmin as jest.MockedFunction<typeof requireAdmin>
+const findMany = prisma.userMediaMark.findMany as jest.Mock
+const count = prisma.userMediaMark.count as jest.Mock
+const groupBy = prisma.userMediaMark.groupBy as jest.Mock
+
+function makeRow(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "mark-1",
+    title: "The Office",
+    year: 2005,
+    mediaType: "TV_SERIES",
+    markType: "KEEP_FOREVER",
+    seasonNumber: null,
+    episodeNumber: null,
+    parentTitle: null,
+    note: null,
+    markedVia: "discord",
+    markedAt: new Date("2026-07-01T12:00:00Z"),
+    radarrTitleSlug: null,
+    sonarrTitleSlug: "the-office",
+    user: { id: "u1", name: "Alice", email: "a@x.com", image: null },
+    ...overrides,
+  }
+}
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  mockRequireAdmin.mockResolvedValue(undefined)
+  findMany.mockResolvedValue([])
+  count.mockResolvedValue(0)
+  groupBy.mockResolvedValue([])
+})
+
+describe("getDiscordMarkedMedia", () => {
+  it("requires admin access", async () => {
+    await getDiscordMarkedMedia()
+    expect(mockRequireAdmin).toHaveBeenCalled()
+  })
+
+  it("returns a per-type summary covering all mark types (zero-filled)", async () => {
+    groupBy.mockResolvedValue([
+      { markType: "KEEP_FOREVER", _count: { _all: 3 } },
+      { markType: "POOR_QUALITY", _count: { _all: 1 } },
+    ])
+
+    const result = await getDiscordMarkedMedia()
+
+    expect(result.success).toBe(true)
+    // All 6 mark types present, missing ones zero-filled.
+    expect(result.summary).toHaveLength(6)
+    const byType = Object.fromEntries(result.summary.map((s) => [s.markType, s.count]))
+    expect(byType.KEEP_FOREVER).toBe(3)
+    expect(byType.POOR_QUALITY).toBe(1)
+    expect(byType.FINISHED_WATCHING).toBe(0)
+  })
+
+  it("serializes marks with user info and ISO timestamps", async () => {
+    findMany.mockResolvedValue([makeRow()])
+    count.mockResolvedValue(1)
+
+    const result = await getDiscordMarkedMedia()
+
+    expect(result.marks).toHaveLength(1)
+    expect(result.marks[0]).toMatchObject({
+      title: "The Office",
+      markType: "KEEP_FOREVER",
+      markedVia: "discord",
+      markedAt: "2026-07-01T12:00:00.000Z",
+      user: { name: "Alice", email: "a@x.com" },
+    })
+    expect(result.total).toBe(1)
+  })
+
+  it("filters the list by mark type but keeps the summary scoped to date/source only", async () => {
+    await getDiscordMarkedMedia({ markType: "POOR_QUALITY" as never })
+
+    // List query includes markType…
+    expect(findMany.mock.calls[0][0].where.markType).toBe("POOR_QUALITY")
+    // …but the summary groupBy where does NOT (so counts stay comparable).
+    expect(groupBy.mock.calls[0][0].where.markType).toBeUndefined()
+  })
+
+  it("applies a case-insensitive title search to the list", async () => {
+    await getDiscordMarkedMedia({ search: "office" })
+    expect(findMany.mock.calls[0][0].where.title).toEqual({
+      contains: "office",
+      mode: "insensitive",
+    })
+  })
+
+  it("maps source=discord to markedVia and source=web through verbatim", async () => {
+    await getDiscordMarkedMedia({ source: "discord" })
+    expect(findMany.mock.calls[0][0].where.markedVia).toBe("discord")
+
+    jest.clearAllMocks()
+    findMany.mockResolvedValue([])
+    count.mockResolvedValue(0)
+    groupBy.mockResolvedValue([])
+    await getDiscordMarkedMedia({ source: "web" })
+    expect(findMany.mock.calls[0][0].where.markedVia).toBe("web")
+  })
+
+  it("does not filter by source when source is 'all'", async () => {
+    await getDiscordMarkedMedia({ source: "all" })
+    expect(findMany.mock.calls[0][0].where.markedVia).toBeUndefined()
+  })
+
+  it("applies date range to markedAt", async () => {
+    await getDiscordMarkedMedia({ startDate: "2026-07-01", endDate: "2026-07-31" })
+    const where = findMany.mock.calls[0][0].where
+    expect(where.markedAt.gte).toBeInstanceOf(Date)
+    expect(where.markedAt.lt).toBeInstanceOf(Date)
+  })
+
+  it("passes take/skip for pagination", async () => {
+    await getDiscordMarkedMedia({ limit: 10, offset: 20 })
+    expect(findMany.mock.calls[0][0].take).toBe(10)
+    expect(findMany.mock.calls[0][0].skip).toBe(20)
+  })
+
+  it("returns a safe error shape when the query throws", async () => {
+    findMany.mockRejectedValue(new Error("db down"))
+    const result = await getDiscordMarkedMedia()
+    expect(result.success).toBe(false)
+    expect(result.marks).toEqual([])
+    expect(result.total).toBe(0)
+    expect(result.summary).toEqual([])
+  })
+})

actions/discord-activity.ts

@@ -18,7 +18,12 @@ import {
 import { prisma } from "@/lib/prisma"
 import { toEndOfDayExclusive } from "@/lib/utils/formatters"
 import { createLogger } from "@/lib/utils/logger"
-import type { DiscordCommandType, DiscordCommandStatus } from "@/lib/generated/prisma"
+import type {
+  DiscordCommandType,
+  DiscordCommandStatus,
+  MarkType,
+  Prisma,
+} from "@/lib/generated/prisma"
 
 const logger = createLogger("DISCORD_ACTIVITY_ACTIONS")
 
@@ -405,3 +410,118 @@ export async function getDiscordDetailedStats(params: GetStatsParams) {
     }
   }
 }
+
+const ALL_MARK_TYPES: MarkType[] = [
+  "FINISHED_WATCHING",
+  "NOT_INTERESTED",
+  "KEEP_FOREVER",
+  "REWATCH_CANDIDATE",
+  "POOR_QUALITY",
+  "WRONG_VERSION",
+]
+
+export interface GetMarkedMediaParams {
+  markType?: MarkType
+  /** "discord" | "web" | undefined (all sources). Matched against markedVia. */
+  source?: string
+  search?: string
+  startDate?: string
+  endDate?: string
+  limit?: number
+  offset?: number
+}
+
+/**
+ * Admin view of the ACTUAL media people have marked, sourced from the
+ * `UserMediaMark` table (the source of truth) rather than inferred from command
+ * log args. Answers "what did people mark as X?" with a per-type summary plus a
+ * filterable, paginated list. Includes marks from every source (Discord + web)
+ * with a `markedVia` badge.
+ */
+export async function getDiscordMarkedMedia(params: GetMarkedMediaParams = {}) {
+  await requireAdmin()
+
+  try {
+    const startDate = params.startDate ? new Date(params.startDate) : undefined
+    const endDate = toEndOfDayExclusive(params.endDate)
+
+    // Date range applies to when the mark was made.
+    const markedAtFilter: Prisma.DateTimeFilter = {}
+    if (startDate) markedAtFilter.gte = startDate
+    if (endDate) markedAtFilter.lt = endDate
+    const hasDateFilter = startDate != null || endDate != null
+
+    const baseWhere: Prisma.UserMediaMarkWhereInput = {}
+    if (hasDateFilter) baseWhere.markedAt = markedAtFilter
+    if (params.source === "discord") baseWhere.markedVia = "discord"
+    else if (params.source && params.source !== "all") baseWhere.markedVia = params.source
+
+    // Full filter also narrows by type + title search (summary ignores those so
+    // the per-type counts always reflect the same date/source scope).
+    const listWhere: Prisma.UserMediaMarkWhereInput = { ...baseWhere }
+    if (params.markType) listWhere.markType = params.markType
+    if (params.search && params.search.trim()) {
+      listWhere.title = { contains: params.search.trim(), mode: "insensitive" }
+    }
+
+    const limit = params.limit ?? 25
+    const offset = params.offset ?? 0
+
+    const [rows, total, byTypeGroups] = await Promise.all([
+      prisma.userMediaMark.findMany({
+        where: listWhere,
+        orderBy: { markedAt: "desc" },
+        take: limit,
+        skip: offset,
+        include: {
+          user: { select: { id: true, name: true, email: true, image: true } },
+        },
+      }),
+      prisma.userMediaMark.count({ where: listWhere }),
+      prisma.userMediaMark.groupBy({
+        by: ["markType"],
+        where: baseWhere,
+        _count: { _all: true },
+      }),
+    ])
+
+    const countByType = new Map(byTypeGroups.map((g) => [g.markType, g._count._all]))
+    const summary = ALL_MARK_TYPES.map((markType) => ({
+      markType,
+      count: countByType.get(markType) ?? 0,
+    }))
+
+    const marks = rows.map((row) => ({
+      id: row.id,
+      title: row.title,
+      year: row.year,
+      mediaType: row.mediaType,
+      markType: row.markType,
+      seasonNumber: row.seasonNumber,
+      episodeNumber: row.episodeNumber,
+      parentTitle: row.parentTitle,
+      note: row.note,
+      markedVia: row.markedVia,
+      markedAt: row.markedAt.toISOString(),
+      radarrTitleSlug: row.radarrTitleSlug,
+      sonarrTitleSlug: row.sonarrTitleSlug,
+      user: {
+        id: row.user.id,
+        name: row.user.name,
+        email: row.user.email,
+        image: row.user.image,
+      },
+    }))
+
+    return { success: true, marks, total, summary }
+  } catch (error) {
+    logger.error("Failed to get Discord marked media", error instanceof Error ? error : undefined)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get marked media",
+      marks: [],
+      total: 0,
+      summary: [],
+    }
+  }
+}