tracker

25.7 KB

1. // components/show.hl — a title's own page (tracker.worldapi.org#4): since tracker#21 (mission 068) `/series/:slug`, `/movies/:slug`
2. // and `/shows/:slug` (the last through project.hl showsRoute: a show is rendered there, a series or movie answers 301 to its
3. // own address). tracker#20: the heading is "<Type> | <title>" — Series / Show / Movie in the type's colour (styles.hl
4. // `type-*`), the title white. Creator's words:
5. // "the poster on the left, right of it the title of the show, the genre pills, below the plot summary,
6. // below that the artists just as normal links, separated with comma color red, genres are blue" (the
7. // header) — "then all seasons in reverse order, latest on top, below them collapsable their episodes,
8. // episodes first the round check icon, if the episode was watched by the user looking its solid, if
9. // not its regular, then the episode number, then the title. the last season is not collapsed. click on
10. // the check adds a watch. the season also has a check, if the season is checked or unchecked all its
11. // episodes get checked or unchecked. artists link to /person/<artist-slug> the genre to /genre/<genre-slug>."
12. //
13. // THE ROWS ARE ONE FLAT LIST, not a nested for-loop over seasons > episodes: the vendored build may
14. // still lack the fix for hybriel#86 (a nested for over a reassigned outer list keeps stale inner
15. // cells) — a single-level `for (row of rows)` with a `kind` field, reassigned whole on every click,
16. // is the same proven-safe shape components/main.hl's own header and ident's inbox.hl already use.
17. // `rows` is rebuilt from scratch (seasons/episodes refetched by id, watch rows refetched) on every
18. // toggle — cheap: a show has at most a few dozen episodes per season.
19. //
20. // Mission 047 (the creator, 2026-10-01): a caret at the season header's right edge (down = open, right = collapsed); episode
21. // rows not indented; on a phone the title first, then the poster at full width, then genres/plot/cast; a Follow toggle
22. // next to the title. SIGNED OUT the checks and Follow are visible too: a click opens the "sign in" modal (modal.hl, copied
23. // from components.hybriel) and writes nothing.
24. //
25. // tracker.worldapi.org#17 (mission 057): the caret points DOWN while a season is closed and UP while it is open. Opening a
26. // season shows SKELETON rows at once (min(episodes, 8), a CSS shimmer, styles.hl) and then its episodes from the face
27. // `showSeasonEpisodes`, which takes NO session: a face with `session` makes hl:web re-mount the whole page on the server and
28. // ship every session-derived member back as a `sync` (WebFramework.hl `inbound`) — that, not the episodes, was most of the
29. // old 250–450 ms (real data). The watched state comes from `watchedEpisodes` (this show's watched episodes per season, rendered
30. // with the page and re-synced after every watch face). Closing is client-only (no request). An ADULT show (only its
31. // followers see it) keeps the session face `showRows`: the public face refuses adult seasons.
32. //
33. // tracker.worldapi.org#12: link icons under the title — the show on TMDB, IMDb, TheTVDB, TVmaze (a movie: TMDB + IMDb),
34. // only for the ids it has (shows.hl externalLinksOf), each in a new tab.
35. //
36. // mission 058: #22 every episode row shows its air date (`release`, 'YYYY-MM-DD' like /my/unwatched; none → empty). #23 a
37. // season's check is DERIVED: solid exactly when every one of its episodes is watched (a season without episodes: its own
38. // season watch) — unchecking one episode turns the season off with the face's answer, checking it again turns it on; the
39. // season click watches all when not all are watched, else unwatches all. #24 a MOVIE's page has its own watched check
40. // (watch `targetType = 'movie'`, target = the title's id; face `showToggleMovie`), signed out → the sign-in modal.
41. //
42. parent './main.hl'
43. import Modal from './modal.hl'
44. import { appTitle } from '../project.hl'
45. import { userIdOfSession, loginHref } from '../users.hl'
46. import { isFollowing, setFollowed } from '../follows.hl'
47. import { showBySlug, showById, genreById, personById, seasonsOfShow, episodesOfSeason, seasonById, posterName, externalLinksOf, titleKind } from '../shows.hl'
48. import { watchesOfUser, isWatched, watchedSet, setWatched, setSeasonWatched, watchClassOf } from '../watches.hl'
50. // ---- pure helpers ----------------------------------------------------------------------------
51. // `static`, like calendar.hl's `soonOf` — a PLAIN instance member function that calls an
52. // hl:mpackdb-backed import (seasonsOfShow, episodesOfSeason, watchesOfUser, …) comes back null
53. // when called from an `on server` face (confirmed by running the gate: "'buildRows' is not
54. // callable — it holds null" at the face's call site, even though the SAME call works fine as a
55. // member's own initializer at the top of this file). `static` is the proven-safe shape (calendar's
56. // `soonOf`, called from `calLoad`/`calSettingsLoad`, an mpackdb-backed helper exactly like this one).
57. static initialCollapsed = (seasons) => {
58. let m = {}
59. let i = 0
60. while (i < seasons.length) {
61. if (i > 0) { m[seasons[i].id] = true }
62. i = i + 1
63. }
64. return m
65. }
66. static genreRowsOf = (show) => {
67. let out = []
68. for (gid of show.genres) {
69. let g = genreById(gid)
70. if (g != null) { out.push({ id = g.id name = g.name href = '/genres/' + g.urlSegment }) }
71. }
72. return out
73. }
74. static castRowsOf = (show) => {
75. let out = []
76. for (c of show.cast) {
77. let p = personById(c.person)
78. if (p != null) { out.push({ name = c.actor href = '/person/' + p.urlSegment }) }
79. }
80. return out
81. }
82. // a View attribute must be a literal, a member or a field path — never an inline expression — so
83. // every ternary (watched -> icon class, collapsed -> row class) is resolved HERE, once, into a
84. // plain field the View just reads (row.watchClass, row.rowClass); `watchClassOf` itself lives in
85. // watches.hl (shared with /unwatched and /schedule, "reuse, don't copy")
86. // #22: an episode's air date as the lists show it ('YYYY-MM-DD'), '' when it has none
87. static airDateOf = (e) => { return e.release != null && hlTypeName(e.release) == 'String' ? e.release : '' }
88. // #23: a season is watched when ALL its episodes are (by the ids it lists); one without episodes keeps its own season watch
89. static seasonAllWatched = (s, watched) => {
90. if (s.episodes.length == 0) { return watched['season:' + s.id] == true }
91. for (eid of s.episodes) { if (watched['episode:' + eid] != true) { return false } }
92. return true
93. }
94. static buildRows = (show, uid, collapsed) => {
95. let watched = watchedSet(uid != null ? watchesOfUser(uid) : [])
96. let out = []
97. for (s of seasonsOfShow(show)) {
98. let isCollapsed = collapsed[s.id] == true
99. let label = s.title != null && s.title != '' ? s.title : 'Season ' + s.seasonNumber
100. let seasonWatched = seasonAllWatched(s, watched)
101. out.push({ kind = 'season' isSeason = true isEpisode = false isSkeleton = false id = s.id skeletonCount = s.episodes.length < 8 ? s.episodes.length : 8 label = label episodeCountText = s.episodes.length == 1 ? '1 episode' : s.episodes.length + ' episodes' watched = seasonWatched watchClass = watchClassOf(seasonWatched) collapsed = isCollapsed rowClass = isCollapsed ? 'collapsed' : 'expanded' })
102. if (!isCollapsed) {
103. for (e of episodesOfSeason(s)) {
104. let epWatched = watched['episode:' + e.id] == true
105. out.push({ kind = 'episode' isSeason = false isEpisode = true isSkeleton = false id = e.id seasonId = s.id episodeNumber = e.episodeNumber title = e.title != null ? e.title : '' airDate = airDateOf(e) watched = epWatched watchClass = watchClassOf(epWatched) })
106. }
107. }
108. }
109. return out
110. }
112. // what the client marks the rows of a season it opens with (tracker#17) — only this show's, never the user's whole watch
113. // list (every member is shipped to the browser). Per season with a watched episode: `{ all, except }` — `all` = most of
114. // it is watched, then `except` holds the UNwatched ids, else the watched ones (a fully watched 142-episode season is
115. // `{ all = true except = {} }`, not 142 ids). No entry = nothing watched.
116. static watchedEpisodesOf = (show, uid) => {
117. let m = {}
118. if (uid == null) { return m }
119. let watched = watchedSet(watchesOfUser(uid))
120. for (s of seasonsOfShow(show)) {
121. let yes = {}
122. let no = {}
123. let n = 0
124. for (eid of s.episodes) {
125. if (watched['episode:' + eid] == true) { yes[eid] = true n = n + 1 } else { no[eid] = true }
126. }
127. if (n > 0) { m[s.id] = n * 2 > s.episodes.length ? { all = true except = no } : { all = false except = yes } }
128. }
129. return m
130. }
131. // is this episode watched, by that per-season shape (client-side, pure)
132. static watchedIn = (entry, episodeId) => {
133. if (entry == null) { return false }
134. let listed = entry.except[episodeId] == true
135. return entry.all ? !listed : listed
136. }
138. // ---- the rows as the CLIENT changes them (tracker#17) — pure: no import is reached, so they run in the browser ----------
139. // (`watchClassOf` is an import of the mpackdb-backed watches.hl, so `filledRows` writes its two classes itself)
140. static seasonRowAs = (row, isCollapsed) => {
141. return { kind = 'season' isSeason = true isEpisode = false isSkeleton = false id = row.id skeletonCount = row.skeletonCount label = row.label episodeCountText = row.episodeCountText watched = row.watched watchClass = row.watchClass collapsed = isCollapsed rowClass = isCollapsed ? 'collapsed' : 'expanded' }
142. }
143. // the season opened: its caret up at once, `skeletonCount` placeholder rows under it
144. static openingRows = (rows, seasonId) => {
145. let out = []
146. for (row of rows) {
147. if (row.isSeason && row.id == seasonId) {
148. out.push(seasonRowAs(row, false))
149. let i = 0
150. while (i < row.skeletonCount) {
151. out.push({ kind = 'skeleton' isSeason = false isEpisode = false isSkeleton = true id = seasonId + '-skeleton-' + i seasonId = seasonId })
152. i = i + 1
153. }
154. } else { out.push(row) }
155. }
156. return out
157. }
158. // the season closed: its episode (and skeleton) rows gone, caret down
159. static closedRows = (rows, seasonId) => {
160. let out = []
161. for (row of rows) {
162. if (row.isSeason && row.id == seasonId) { out.push(seasonRowAs(row, true)) }
163. else if (!row.isSeason && row.seasonId == seasonId) { }
164. else { out.push(row) }
165. }
166. return out
167. }
168. // the episodes arrived: they replace the season's skeleton rows. No skeleton of it left (closed meanwhile, or a watch face
169. // already rebuilt every row) → the rows stay as they are (no double rows)
170. static filledRows = (rows, seasonId, episodes, watched) => {
171. let out = []
172. let done = false
173. for (row of rows) {
174. if (row.isSkeleton && row.seasonId == seasonId) {
175. if (!done) {
176. for (e of episodes) {
177. let w = watchedIn(watched[seasonId], e.id)
178. out.push({ kind = 'episode' isSeason = false isEpisode = true isSkeleton = false id = e.id seasonId = seasonId episodeNumber = e.episodeNumber title = e.title airDate = e.airDate watched = w watchClass = w ? 'checkicon solid' : 'checkicon regular' })
179. }
180. done = true
181. }
182. } else { out.push(row) }
183. }
184. return out
185. }
187. // a LOCAL static like buildRows (an imported mpackdb helper called straight from a member's initializer came back false
188. // after a client-side navigation to the page — the gate's follow check)
189. static followingOf = (show, uid) => { return uid != null && isFollowing(uid, show.id) }
190. // #24: has this user watched this movie (a watch `movie:<title id>`)?
191. static movieWatchedOf = (show, uid) => { return uid != null && isWatched(watchesOfUser(uid), 'movie', show.id) }
192. // mission 056: an ADULT title's page (TMDB's flag `adult == true`, mission 054) is "Not found" for everyone who does not
193. // follow it (signed out too); a follower sees it as before. Unknown (`null`) is not hidden here — only in the lists.
194. // With hybriel ≥ 73267707 (#121/#122) `showRow`/`found` are server sites re-derived after every session face with the page's
195. // slug, so an Unfollow on the page hides it at once (the gate proves it; the old build left the page up until a reload).
196. // Mission 054's try (`found = … && !adultHiddenFor(showRow, me)`, `collapsed`/`rows` from `found`) broke the checks.
197. static adultHiddenFor = (show, uid) => { return show.adult == true && !followingOf(show, uid) }
198. // the page's show — null when there is none OR it is hidden for this user: every member is shipped to the browser, so the
199. // row of a hidden title must never be one
200. static visibleShow = (slug, uid) => {
201. let s = showBySlug(slug)
202. return s != null && adultHiddenFor(s, uid) ? null : s
203. }
204. // the initial open/closed seasons and the title's kind (tracker#20/#21: the heading's type word) from the SLUG alone (not from
205. // `showRow`, which reads the session — see `collapsed`) — one slug lookup for both
206. static slugInfoOf = (slug) => {
207. let s = showBySlug(slug)
208. return s != null ? { collapsed = initialCollapsed(seasonsOfShow(s)) kind = titleKind(s) } : { collapsed = {} kind = 'series' }
209. }
211. // ---- reactive members -----------------------------------------------------------------------
212. slug = null
213. session = null
214. userId = userIdOfSession(session)
215. signedIn = userId != null
216. // SESSION SYNC (mission 047; since hybriel #121/#122, mission 056): a face taking `session` answers with a `sync` of every
217. // member derived from session that reaches an import (here `showRow`, `found`, `following`, `rows`, …), re-derived on the
218. // server with the page's route params but the MOUNT's other state — so client state (`collapsed`) must never derive from
219. // them. `me` stays the plain copy mission 047 introduced.
220. me = userId
222. showRow = visibleShow(slug, me)
223. found = showRow != null
224. notFound = showRow == null
226. // the Follow toggle: "Follow" = the inverted button (accent border), "Following" = the filled one
227. following = found ? followingOf(showRow, me) : false
228. followClass = following ? 'follow' : 'follow inverted'
229. followText = following ? 'Following' : 'Follow'
230. signInHref = loginHref
232. // #24: a movie's watched check (same icon/classes as the episodes); the classes written out, not `watchClassOf` (an import of
233. // the mpackdb-backed watches.hl cannot run in the browser when the member is re-derived there)
234. isMovie = found && showRow.type == 'movie'
235. movieWatched = isMovie ? movieWatchedOf(showRow, me) : false
236. movieWatchClass = movieWatched ? 'checkicon solid' : 'checkicon regular'
237. movieWatchText = movieWatched ? 'Watched' : 'Not watched'
238. signInText = isMovie ? 'You need to sign in to follow movies and mark them watched.' : 'You need to sign in to follow shows and mark episodes.'
240. title = found ? showRow.title : ''
241. // tracker#20: "Series | Reacher" — the kind from the slug (pure strings here: they are re-derived in the browser too)
242. slugInfo = slugInfoOf(slug)
243. pageKind = slugInfo.kind
244. typeText = pageKind == 'movie' ? 'Movie' : (pageKind == 'show' ? 'Show' : 'Series')
245. typeClass = 'type-word type-' + pageKind
246. summary = found && showRow.summary != null ? showRow.summary : ''
247. poster = found ? posterName(showRow) : null
248. hasPoster = poster != null
249. posterUrl = hasPoster ? '/posters/' + poster : ''
250. // mission 060 (tracker.worldapi.org#27): the short id under the poster (none yet while the backfill has not reached it)
251. shortId = found && showRow.shortId != null ? '' + showRow.shortId : ''
252. hasShortId = shortId != ''
254. genreRows = found ? genreRowsOf(showRow) : []
255. hasGenres = genreRows.length > 0
256. castRows = found ? castRowsOf(showRow) : []
257. hasCast = castRows.length > 0
258. linkRows = found ? externalLinksOf(showRow) : []
259. hasLinks = linkRows.length > 0
261. // NOT from `showRow`/`found`: they read the session (via `me`), so a member derived from them is re-derived on the server
262. // after every session face with the MOUNT's state — `collapsed` (client state) would snap back to the initial seasons (mission
263. // 056: the 2nd episode click in a re-opened season did nothing). The season ids of a hidden page are no secret.
264. collapsed = slugInfo.collapsed
265. rows = found ? buildRows(showRow, me, collapsed) : []
266. hasRows = rows.length > 0
267. watchedEpisodes = found ? watchedEpisodesOf(showRow, me) : {}
268. // an adult page (followers only) opens its seasons through the session face `showRows`
269. adultShow = found && showRow.adult == true
271. __title = found ? title + ' — ' + appTitle : appTitle
273. View {
274. showPage {
275. if (notFound) {
276. article { class = "main"
277. h1 { "Not found" }
278. p { "This show doesn't exist." }
279. }
280. }
281. if (found) {
282. showHeader {
283. showPoster {
284. if (hasPoster) { img { src = posterUrl alt = title } }
285. if (hasShortId) { shortIdLabel { id = "shortid" title = "Short id" shortId } }
286. }
287. showMeta {
288. showTitle {
289. h1 { class = "typed" typeWord { class = typeClass typeText } typeSep { "|" } typeName { title } }
290. button { id = "follow" type = "button" class = followClass followText on click(e) { emit toggleFollow(e) } }
291. }
292. if (isMovie) {
293. movieWatch {
294. button { id = "moviewatch" type = "button" class = movieWatchClass "aria-label" = "mark movie watched"
295. svg { viewBox = "0 0 24 24" width = "22" height = "22" "aria-hidden" = "true"
296. circle { cx = "12" cy = "12" r = "10" }
297. path { d = "M7 12.5 L10.5 16 L17 8.5" }
298. }
299. on click(e) { emit toggleMovie(e) }
300. }
301. movieWatchLabel { movieWatchText }
302. }
303. }
304. if (hasLinks) {
305. showLinks {
306. for (l of linkRows) { a { class = "extlink" href = l.href target = "_blank" rel = "noopener" title = l.title "aria-label" = l.title "data-site" = l.site l.label } }
307. }
308. }
309. if (hasGenres) {
310. showGenres {
311. for (g of genreRows) { a { class = "genre-pill" href = g.href g.name } }
312. }
313. }
314. showSummary { summary }
315. if (hasCast) {
316. showCast {
317. for (c of castRows) { a { class = "artist-link" href = c.href c.name } }
318. }
319. }
320. }
321. }
322. if (hasRows) {
323. showSeasons {
324. for (row of rows) {
325. if (row.isSeason) {
326. seasonRow { class = row.rowClass
327. button { type = "button" class = row.watchClass value = row.id "aria-label" = "mark season watched"
328. svg { viewBox = "0 0 24 24" width = "22" height = "22" "aria-hidden" = "true"
329. circle { cx = "12" cy = "12" r = "10" }
330. path { d = "M7 12.5 L10.5 16 L17 8.5" }
331. }
332. on click(e) { emit toggleSeason(row.id) }
333. }
334. button { type = "button" class = "season-toggle" value = row.id
335. seasonLabel { row.label }
336. seasonCount { row.episodeCountText }
337. seasonCaret { "aria-hidden" = "true"
338. svg { viewBox = "0 0 24 24" width = "20" height = "20"
339. path { d = "M6 9 L12 15 L18 9" }
340. }
341. }
342. on click(e) { emit toggleCollapse(row.id) }
343. }
344. }
345. }
346. if (row.isEpisode) {
347. episodeRow {
348. button { type = "button" class = row.watchClass value = row.id "aria-label" = "mark episode watched"
349. svg { viewBox = "0 0 24 24" width = "22" height = "22" "aria-hidden" = "true"
350. circle { cx = "12" cy = "12" r = "10" }
351. path { d = "M7 12.5 L10.5 16 L17 8.5" }
352. }
353. on click(e) { emit toggleEpisode(row.id) }
354. }
355. episodeNumber { row.episodeNumber }
356. episodeTitle { row.title }
357. episodeDate { row.airDate }
358. }
359. }
360. if (row.isSkeleton) {
361. skeletonRow { "aria-hidden" = "true"
362. skeletonCheck { }
363. skeletonNumber { }
364. skeletonTitle { }
365. }
366. }
367. }
368. }
369. }
370. Modal { id = "signin" title = "Sign in"
371. p { signInText }
372. footer {
373. button { type = "button" value = "close" "Close" }
374. a { id = "signin-link" class = "button" href = signInHref "Sign in with ident" }
375. }
376. }
377. }
378. }
379. }
381. // Every rebuild of `rows` happens SERVER-SIDE, never by calling `buildRows` from a client handler:
382. // a member function whose body reaches an hl:mpackdb-backed import (seasonsOfShow, episodesOfSeason,
383. // watchesOfUser, …) compiles to nothing on the client (no case ever assigns it — a genuine Hybriel
384. // gap, filed under `issues`) even though the client bundle still calls it, so `this.buildRows(...)`
385. // throws "not a function" in the browser. The client here only ever ASSIGNS the `rows` the server
386. // already built (`rows = r.rows`) — never calls a tainted local helper itself. `slug` goes along so
387. // the face can refetch the show without depending on implicit access to a sibling member.
388. //
389. // tracker#17: opening shows the skeleton rows BEFORE the request; the answer replaces them unless the season was closed
390. // meanwhile (then nothing). An error closes the season again. Closing never asks the server.
391. on toggleCollapse(seasonId) {
392. let m = collapsed
393. if (collapsed[seasonId] != true) {
394. m[seasonId] = true
395. collapsed = m
396. rows = closedRows(rows, seasonId)
397. return null
398. }
399. m[seasonId] = false
400. collapsed = m
401. rows = openingRows(rows, seasonId)
402. if (adultShow) {
403. let a = emit server showRows(slug, collapsed)
404. if (collapsed[seasonId] == true) { return null }
405. if (a == null || a.error != null) { m[seasonId] = true collapsed = m rows = closedRows(rows, seasonId) return null }
406. rows = a.rows
407. return null
408. }
409. let r = emit server showSeasonEpisodes('' + seasonId)
410. if (collapsed[seasonId] == true) { return null }
411. if (r == null || r.error != null) { m[seasonId] = true collapsed = m rows = closedRows(rows, seasonId) return null }
412. rows = filledRows(rows, seasonId, r.episodes, watchedEpisodes)
413. }
415. // signed out: the modal, nothing is sent
416. on toggleEpisode(episodeId) {
417. if (!signedIn) { document.getElementById('signin').showModal() return null }
418. let r = emit server showToggleEpisode(slug, '' + episodeId, collapsed)
419. if (r == null || r.error != null) { return null }
420. rows = r.rows
421. }
423. on toggleSeason(seasonId) {
424. if (!signedIn) { document.getElementById('signin').showModal() return null }
425. let r = emit server showToggleSeason(slug, '' + seasonId, collapsed)
426. if (r == null || r.error != null) { return null }
427. rows = r.rows
428. }
430. // #24: the movie's own check — signed out the modal, nothing sent
431. on toggleMovie(e) {
432. if (!signedIn) { document.getElementById('signin').showModal() return null }
433. let r = emit server showToggleMovie(slug)
434. if (r == null || r.error != null) { return null }
435. movieWatched = r.watched
436. movieWatchClass = r.watched ? 'checkicon solid' : 'checkicon regular'
437. movieWatchText = r.watched ? 'Watched' : 'Not watched'
438. }
440. on toggleFollow(e) {
441. if (!signedIn) { document.getElementById('signin').showModal() return null }
442. let r = emit server showToggleFollow(slug)
443. if (r == null || r.error != null) { return null }
444. following = r.following
445. followClass = r.following ? 'follow' : 'follow inverted'
446. followText = r.following ? 'Following' : 'Follow'
447. }
449. // ---- the faces (the trailing `session` is always the server's: hybriel#16) ----
450. // every row for these open/closed seasons — only an ADULT show's page still uses it (its followers; tracker#17)
451. on server showRows(slug, collapsed, session) {
452. let show = showBySlug(slug)
453. let uid = userIdOfSession(session)
454. if (show == null || adultHiddenFor(show, uid)) { return { error = 'no such show' } }
455. return { ok = true rows = buildRows(show, uid, collapsed) }
456. }
458. // tracker#17: one season's episodes, in order — public data, so NO `session` (no page re-mount, no sync: the fast path).
459. // Refuses a season of an adult title (those pages use showRows above).
460. on server showSeasonEpisodes(seasonId) {
461. if (seasonId == null || hlTypeName(seasonId) != 'String') { return { error = 'no such season' } }
462. let season = seasonById(seasonId)
463. if (season == null) { return { error = 'no such season' } }
464. let show = showById(season.show)
465. if (show == null || show.adult == true) { return { error = 'no such season' } }
466. let out = []
467. for (e of episodesOfSeason(season)) { out.push({ id = e.id episodeNumber = e.episodeNumber title = e.title != null ? e.title : '' airDate = airDateOf(e) }) }
468. return { ok = true episodes = out }
469. }
471. on server showToggleEpisode(slug, episodeId, collapsed, session) {
472. let show = showBySlug(slug)
473. if (show == null) { return { error = 'no such show' } }
474. let uid = userIdOfSession(session)
475. if (uid == null) { return { error = 'you are not signed in' } }
476. if (adultHiddenFor(show, uid)) { return { error = 'no such show' } }
477. let rows = watchesOfUser(uid)
478. let watched = isWatched(rows, 'episode', episodeId) == false
479. let ok = setWatched(uid, 'episode', episodeId, rows, watched)
480. if (!ok) { return { error = 'could not save the watch' } }
481. return { ok = true rows = buildRows(show, uid, collapsed) }
482. }
484. on server showToggleSeason(slug, seasonId, collapsed, session) {
485. let show = showBySlug(slug)
486. if (show == null) { return { error = 'no such show' } }
487. let uid = userIdOfSession(session)
488. if (uid == null) { return { error = 'you are not signed in' } }
489. if (adultHiddenFor(show, uid)) { return { error = 'no such show' } }
490. let season = seasonById(seasonId)
491. if (season == null) { return { error = 'no such season' } }
492. let rows = watchesOfUser(uid)
493. // #23: not all episodes watched → watch them all; all watched → unwatch them all
494. let watched = !seasonAllWatched(season, watchedSet(rows))
495. let ok = setSeasonWatched(uid, seasonId, season.episodes, rows, watched)
496. if (!ok) { return { error = 'could not save the watch' } }
497. return { ok = true rows = buildRows(show, uid, collapsed) }
498. }
500. // #24: a movie's watched check (only a movie: a series is watched by its episodes)
501. on server showToggleMovie(slug, session) {
502. let show = showBySlug(slug)
503. if (show == null || show.type != 'movie') { return { error = 'no such movie' } }
504. let uid = userIdOfSession(session)
505. if (uid == null) { return { error = 'you are not signed in' } }
506. if (adultHiddenFor(show, uid)) { return { error = 'no such movie' } }
507. let rows = watchesOfUser(uid)
508. let watched = isWatched(rows, 'movie', show.id) == false
509. if (!setWatched(uid, 'movie', show.id, rows, watched)) { return { error = 'could not save the watch' } }
510. return { ok = true watched = watched }
511. }
513. on server showToggleFollow(slug, session) {
514. let show = showBySlug(slug)
515. if (show == null) { return { error = 'no such show' } }
516. let uid = userIdOfSession(session)
517. if (uid == null) { return { error = 'you are not signed in' } }
518. let follow = isFollowing(uid, show.id) == false
519. if (!setFollowed(uid, show.id, follow)) { return { error = 'could not save the follow' } }
520. return { ok = true following = follow }
521. }