tracker

12.9 KB

1. // catalog.hl — THE PUBLIC LISTS (tracker.worldapi.org#13): every movie, newest release first, and every series, the one
2. // whose newest RELEASED episode is newest first — the homepage's rows (10 each) and /movies, /series, /shows (24 per page).
3. // Movies and series are both rows of `shows` (`type` 'movie' / 'series', the old tracker's shape).
4. //
5. // BUILT ONCE when the app starts — one scan of shows and of episodes (real data: 9,453 shows, 232k episodes, ~1 s) — and
6. // kept in memory as two sorted lists of { id, key }. A request only slices its page and fetches those 24 shows: no scan.
7. // Kept up to date without a rebuild:
8. // - the daily TMDB sync (project.hl syncTick) calls `refreshCatalogShow(id)` after each show: its entry is recomputed
9. // from its own seasons/episodes (new episodes, moved release dates) and moved to its new place;
10. // - a NEW DAY: an episode upcoming yesterday may be out today — each series keeps the release dates of its upcoming
11. // episodes (`upcoming`), and the first read of a new day moves the ones that are out into `latest` and re-sorts.
12. // tools/sync-tmdb.hl runs with the app stopped (hybriel#21): the next start builds the lists afresh.
13. //
14. // ADULT TITLES (mission 054): only a title with `adult == false` (shows.hl isPublicTitle) is in the two lists — unknown is
15. // hidden. The adult backfill (project.hl backfillTick) calls `refreshCatalogShow(id)` per title, so the lists fill as the
16. // flags arrive. The series' release maps (latest/upcoming/release) hold every series, shown or not.
17. //
18. // ORDER: a movie by its `release` ('YYYY-MM-DD'; none → last). A series by its newest released episode (release ≤
19. // today, UTC like the rest of the app); a series with none released yet comes after all that have one, by its own
20. // `release`. Ties keep the table's order. `key` is one string so one comparison sorts: series '1<date>' / '0<date>'.
21. //
22. // SERIES AND SHOWS (tracker.worldapi.org#21, mission 068): the TV titles are two lists by their kind (shows.hl `titleKind`) —
23. // /series and the homepage's Series row, /shows and its Shows row — both in the order above. `refreshCatalogShow` puts a title
24. // into the list of its CURRENT kind (the kind backfill, project.hl kindTick, calls it when TMDB's type moves a title).
25. //
26. // GENRES (mission 058, tracker#25, /genres/<genre>): per genre id one list of its public movies AND series, newest first by
27. // ONE date for both kinds: a movie's `release`, a series' newest released episode (none → its own `release`). Built in the
28. // same scans; `refreshCatalogShow` moves the title in the lists of its old genres (`genresOf`) and its current ones.
29. import { now, timestamp } from 'hl:time'
30. import { allShows, allEpisodes, showById, seasonsOfShow, episodesOfSeason, showYear, posterUrlOf, isPublicTitle, titleKind, titlePath, cardOf, posterUrlOfName, refreshTitleCaches } from './shows.hl'
32. static pageSize = 24
34. static todayStr = () => { return timestamp(now()).slice(0, 10) }
35. static dateOr = (&v) => { return v != null && hlTypeName(v) == 'String' && v.length >= 4 ? v : '' }
36. static seriesKey = (&latest, &release) => { return latest != null && latest != '' ? '1' + latest : '0' + release }
37. // a series in a genre list: the plain date (comparable with a movie's release) — its newest released episode, else its release
38. static genreKey = (&latest, &release) => { return latest != null && latest != '' ? latest : release }
40. // ---- sorting, hand-written (no list sort(), hybriel#1): a bottom-up merge sort, newest key first, stable ----------
41. static mergeDesc = (&a, &b) => {
42. let out = []
43. let i = 0
44. let j = 0
45. while (i < a.length && j < b.length) {
46. if (b[j].key > a[i].key) { out.push(b[j]) j = j + 1 } else { out.push(a[i]) i = i + 1 }
47. }
48. while (i < a.length) { out.push(a[i]) i = i + 1 }
49. while (j < b.length) { out.push(b[j]) j = j + 1 }
50. return out
51. }
52. static sortDesc = (&list) => {
53. if (list.length == 0) { return [] }
54. let runs = []
55. for (x of list) { runs.push([x]) }
56. while (runs.length > 1) {
57. let next = []
58. let k = 0
59. while (k + 1 < runs.length) { next.push(mergeDesc(runs[k], runs[k + 1])) k = k + 2 }
60. if (k < runs.length) { next.push(runs[k]) }
61. runs = next
62. }
63. return runs[0]
64. }
65. // one entry moved to its place: out of the list, then in before the first entry with a smaller key (linear)
66. static placed = (&list, &entry) => {
67. let out = []
68. let done = false
69. for (x of list) {
70. if (x.id != entry.id) {
71. if (!done && entry.key > x.key) { out.push(entry) done = true }
72. out.push(x)
73. }
74. }
75. if (!done) { out.push(entry) }
76. return out
77. }
78. // one entry out of the list (a title that is not public, mission 054)
79. static without = (&list, &id) => {
80. let out = []
81. for (x of list) { if (x.id != id) { out.push(x) } }
82. return out
83. }
85. // ---- the index -------------------------------------------------------------------------------------------------
86. static buildIndex = () => {
87. let today = todayStr()
88. let movies = []
89. let seriesIds = []
90. let showIds = []
91. let release = {}
92. let genreTitles = []
93. for (s of allShows()) {
94. if (s.type == 'movie') { if (isPublicTitle(s)) { movies.push({ id = s.id key = dateOr(s.release) }) } }
95. else if (s.type == 'series') {
96. if (isPublicTitle(s)) { if (titleKind(s) == 'show') { showIds.push(s.id) } else { seriesIds.push(s.id) } }
97. release[s.id] = dateOr(s.release)
98. }
99. if ((s.type == 'movie' || s.type == 'series') && isPublicTitle(s) && s.genres != null && s.genres.length > 0) {
100. genreTitles.push({ id = s.id movie = s.type == 'movie' release = dateOr(s.release) genres = s.genres })
101. }
102. }
103. let latest = {}
104. let upcoming = {}
105. for (e of allEpisodes()) {
106. // tracker#31: a merged episode is its keeper episode's twin (same date) — not counted twice
107. if (e.show != null && e.mergedInto == null && dateOr(e.release) != '') {
108. if (e.release <= today) {
109. let l = latest[e.show]
110. if (l == null || e.release > l) { latest[e.show] = e.release }
111. } else {
112. let u = upcoming[e.show]
113. if (u == null) { u = [] }
114. u.push(e.release)
115. upcoming[e.show] = u
116. }
117. }
118. }
119. let series = []
120. for (id of seriesIds) { series.push({ id = id key = seriesKey(latest[id], release[id]) }) }
121. let shows = []
122. for (id of showIds) { shows.push({ id = id key = seriesKey(latest[id], release[id]) }) }
123. let byGenre = {}
124. let genresOf = {}
125. for (t of genreTitles) {
126. let key = t.movie ? t.release : genreKey(latest[t.id], t.release)
127. for (g of t.genres) {
128. let list = byGenre[g]
129. if (list == null) { list = [] }
130. list.push({ id = t.id key = key })
131. byGenre[g] = list
132. }
133. genresOf[t.id] = t.genres
134. }
135. let genres = {}
136. for (g of byGenre.keys()) { genres[g] = sortDesc(byGenre[g]) }
137. return { day = today movies = sortDesc(movies) series = sortDesc(series) shows = sortDesc(shows) latest = latest upcoming = upcoming release = release genres = genres genresOf = genresOf }
138. }
139. static index = buildIndex()
141. // a TV list with every key from the current release maps, sorted again
142. static rekeyed = (&list) => {
143. let out = []
144. for (x of list) { out.push({ id = x.id key = seriesKey(index.latest[x.id], index.release[x.id]) }) }
145. return sortDesc(out)
146. }
148. // a new day: upcoming episodes that are out now become their series' newest released one
149. static rollDay = () => {
150. let today = todayStr()
151. if (index.day == today) { return null }
152. let moved = false
153. for (id of index.upcoming.keys()) {
154. let rest = []
155. let l = index.latest[id]
156. for (d of index.upcoming[id]) {
157. if (d <= today) {
158. if (l == null || d > l) { l = d }
159. moved = true
160. } else { rest.push(d) }
161. }
162. index.upcoming[id] = rest
163. if (l != null) { index.latest[id] = l }
164. }
165. if (moved) {
166. index.series = rekeyed(index.series)
167. index.shows = rekeyed(index.shows)
168. // the genre lists too: a series' key is its newest released episode (movies keep theirs)
169. for (g of index.genres.keys()) {
170. let list = []
171. for (x of index.genres[g]) { list.push({ id = x.id key = index.release[x.id] != null ? genreKey(index.latest[x.id], index.release[x.id]) : x.key }) }
172. index.genres[g] = sortDesc(list)
173. }
174. }
175. index.day = today
176. return null
177. }
179. // one title out of the lists of the genres it was in, then (when public) into those of its current genres
180. static refreshGenres = (&show, &shown, key) => {
181. let old = index.genresOf[show.id]
182. if (old != null) {
183. for (g of old) { if (index.genres[g] != null) { index.genres[g] = without(index.genres[g], show.id) } }
184. }
185. index.genresOf[show.id] = null
186. if (!shown || show.genres == null || show.genres.length == 0) { return null }
187. for (g of show.genres) {
188. let list = index.genres[g]
189. if (list == null) { list = [] }
190. index.genres[g] = placed(list, { id = show.id key = key })
191. }
192. index.genresOf[show.id] = show.genres
193. return null
194. }
196. // after the sync (or the adult backfill) touched a show: its entry from its own data again (only that show's
197. // seasons/episodes are read) — or out of the list when it is not public (adult or unknown, mission 054)
198. static refreshCatalogShow = (&showId) => {
199. rollDay()
200. let show = showById(showId)
201. if (show == null) { return null }
202. // tracker#30: the lists' slim cache of this title (shows.hl cardOf / episodeRowsOf) from the changed record
203. refreshTitleCaches(show)
204. let shown = isPublicTitle(show)
205. if (show.type == 'movie') {
206. index.movies = shown ? placed(index.movies, { id = show.id key = dateOr(show.release) }) : without(index.movies, show.id)
207. refreshGenres(show, shown, dateOr(show.release))
208. return null
209. }
210. if (show.type != 'series') { return null }
211. let today = index.day
212. let l = null
213. let up = []
214. for (s of seasonsOfShow(show)) {
215. for (e of episodesOfSeason(s)) {
216. if (dateOr(e.release) != '') {
217. if (e.release <= today) { if (l == null || e.release > l) { l = e.release } } else { up.push(e.release) }
218. }
219. }
220. }
221. index.latest[show.id] = l
222. index.upcoming[show.id] = up
223. index.release[show.id] = dateOr(show.release)
224. // in the list of its kind (#21), out of the other one
225. let entry = { id = show.id key = seriesKey(l, index.release[show.id]) }
226. let isShow = titleKind(show) == 'show'
227. index.series = shown && !isShow ? placed(index.series, entry) : without(index.series, show.id)
228. index.shows = shown && isShow ? placed(index.shows, entry) : without(index.shows, show.id)
229. refreshGenres(show, shown, genreKey(l, index.release[show.id]))
230. return null
231. }
233. // ---- what the pages read ---------------------------------------------------------------------------------------
234. // one poster tile: poster, title, year, the title's page (/movies/, /series/ or /shows/<slug>, shows.hl titlePath — one
235. // component for all three, with its Follow button). tracker#30 (mission 025): from the slim cached card (shows.hl cardOf),
236. // not the whole record with its cast and crew
237. static tilesOf = (&entries) => {
238. let out = []
239. for (x of entries) {
240. let c = cardOf(x.id)
241. if (c != null) { out.push({ id = c.id title = c.title year = c.year href = c.href posterUrl = posterUrlOfName(c.posterName) }) }
242. }
243. return out
244. }
246. // the homepage: the n latest RELEASED movies (none dated after today) and the n series with the newest released episode
247. static latestMovies = (&n) => {
248. rollDay()
249. let want = []
250. for (x of index.movies) {
251. if (want.length < n && x.key != '' && x.key <= index.day) { want.push(x) }
252. if (want.length >= n) { return tilesOf(want) }
253. }
254. return tilesOf(want)
255. }
256. static latestSeries = (&n) => { rollDay() return latestTv(index.series, n) }
257. static latestShows = (&n) => { rollDay() return latestTv(index.shows, n) }
258. static latestTv = (&list, &n) => {
259. let want = []
260. for (x of list) {
261. if (want.length < n && x.key.slice(0, 1) == '1') { want.push(x) }
262. if (want.length >= n) { return tilesOf(want) }
263. }
264. return tilesOf(want)
265. }
267. // a page number from the address (`/movies/page/:page`, a String) — anything that is not a whole number ≥ 1 is page 1;
268. // past the last page is the last page
269. static pageNumberOf = (&raw, &pages) => {
270. if (raw == null) { return 1 }
271. let s = '' + raw
272. if (s == '' || s.length > 6) { return 1 }
273. let i = 0
274. while (i < s.length) {
275. let c = s.charCodeAt(i)
276. if (c < 48 || c > 57) { return 1 }
277. i = i + 1
278. }
279. let p = toNumber(s)
280. if (p < 1) { return 1 }
281. return p > pages ? pages : p
282. }
283. static pagesOf = (&count) => {
284. let p = 1
285. while (p * pageSize < count) { p = p + 1 }
286. return p
287. }
288. // { page, pages, tiles } of one list
289. static pageOf = (&list, &raw) => {
290. let pages = pagesOf(list.length)
291. let page = pageNumberOf(raw, pages)
292. return { page = page pages = pages tiles = tilesOf(list.slice((page - 1) * pageSize, page * pageSize)) }
293. }
294. static moviesPage = (&raw) => { rollDay() return pageOf(index.movies, raw) }
295. static seriesPage = (&raw) => { rollDay() return pageOf(index.series, raw) }
296. static showsPage = (&raw) => { rollDay() return pageOf(index.shows, raw) }
297. static catalogCounts = () => { return { movies = index.movies.length series = index.series.length shows = index.shows.length } }
298. // /genres/<genre> (mission 058): one genre's movies and series, newest first, 24 per page; how many there are
299. static genrePage = (&genreId, &raw) => {
300. rollDay()
301. let list = index.genres[genreId]
302. return pageOf(list != null ? list : [], raw)
303. }
304. static genreCount = (&genreId) => {
305. let list = index.genres[genreId]
306. return list != null ? list.length : 0
307. }