tracker

12.5 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 (jobs.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 (jobs.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, jobs.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 { todayStr, dateOr, sortDesc } from './util.hl'
30. import { genresTable, allShows, allEpisodes, showById, seasonsOfShow, episodesOfSeason, showYear, posterUrlOf, isPublicTitle, titleKind, titlePath, cardOf, posterUrlOfName, refreshTitleCaches } from './shows.hl'
32. static pageSize = 24
34. static seriesKey = (&latest, &release) => { return latest != null && latest != '' ? '1' + latest : '0' + release }
35. // a series in a genre list: the plain date (comparable with a movie's release) — its newest released episode, else its release
36. static genreKey = (&latest, &release) => { return latest != null && latest != '' ? latest : release }
38. // ---- the lists' entries (sorted by util.hl sortDesc) -----------------------------------------------------------
39. // one entry moved to its place: out of the list, then in before the first entry with a smaller key (linear)
40. static placed = (&list, &entry) => {
41. out = []
42. let done = false
43. for (x of list) {
44. if (x.id != entry.id) {
45. if (!done && entry.key > x.key) { out.push(entry) done = true }
46. out.push(x)
47. }
48. }
49. if (!done) { out.push(entry) }
50. return out
51. }
52. // one entry out of the list (a title that is not public, mission 054)
53. static without = (&list, &id) => {
54. out = []
55. for (x of list) { if (x.id != id) { out.push(x) } }
56. return out
57. }
59. // ---- the index -------------------------------------------------------------------------------------------------
60. static buildIndex = () => {
61. today = todayStr()
62. movies = []
63. seriesIds = []
64. showIds = []
65. release = {}
66. genreTitles = []
67. for (s of allShows()) {
68. if (s.type == 'movie') { if (isPublicTitle(s)) { movies.push({ id = s.id key = dateOr(s.release) }) } }
69. else if (s.type == 'series') {
70. if (isPublicTitle(s)) { if (titleKind(s) == 'show') { showIds.push(s.id) } else { seriesIds.push(s.id) } }
71. release[s.id] = dateOr(s.release)
72. }
73. if ((s.type == 'movie' || s.type == 'series') && isPublicTitle(s) && s.genres != null && s.genres.length > 0) {
74. genreTitles.push({ id = s.id movie = s.type == 'movie' release = dateOr(s.release) genres = s.genres })
75. }
76. }
77. latest = {}
78. upcoming = {}
79. for (e of allEpisodes()) {
80. // tracker#31: a merged episode is its keeper episode's twin (same date) — not counted twice
81. if (e.show != null && e.mergedInto == null && dateOr(e.release) != '') {
82. if (e.release <= today) {
83. let l = latest[e.show]
84. if (l == null || e.release > l) { latest[e.show] = e.release }
85. } else {
86. let u = upcoming[e.show]
87. if (u == null) { u = [] }
88. u.push(e.release)
89. upcoming[e.show] = u
90. }
91. }
92. }
93. series = []
94. for (id of seriesIds) { series.push({ id = id key = seriesKey(latest[id], release[id]) }) }
95. shows = []
96. for (id of showIds) { shows.push({ id = id key = seriesKey(latest[id], release[id]) }) }
97. byGenre = {}
98. genresOf = {}
99. for (t of genreTitles) {
100. let key = t.movie ? t.release : genreKey(latest[t.id], t.release)
101. for (g of t.genres) {
102. let list = byGenre[g]
103. if (list == null) { list = [] }
104. list.push({ id = t.id key = key })
105. byGenre[g] = list
106. }
107. genresOf[t.id] = t.genres
108. }
109. genres = {}
110. for (g of byGenre.keys()) { genres[g] = sortDesc(byGenre[g]) }
111. return { day = today movies = sortDesc(movies) series = sortDesc(series) shows = sortDesc(shows) latest = latest upcoming = upcoming release = release genres = genres genresOf = genresOf }
112. }
113. static index = buildIndex()
115. // a TV list with every key from the current release maps, sorted again
116. static rekeyed = (&list) => {
117. out = []
118. for (x of list) { out.push({ id = x.id key = seriesKey(index.latest[x.id], index.release[x.id]) }) }
119. return sortDesc(out)
120. }
122. // a new day: upcoming episodes that are out now become their series' newest released one
123. static rollDay = () => {
124. today = todayStr()
125. if (index.day == today) { return null }
126. let moved = false
127. for (id of index.upcoming.keys()) {
128. let rest = []
129. let l = index.latest[id]
130. for (d of index.upcoming[id]) {
131. if (d <= today) {
132. if (l == null || d > l) { l = d }
133. moved = true
134. } else { rest.push(d) }
135. }
136. index.upcoming[id] = rest
137. if (l != null) { index.latest[id] = l }
138. }
139. if (moved) {
140. index.series = rekeyed(index.series)
141. index.shows = rekeyed(index.shows)
142. // the genre lists too: a series' key is its newest released episode (movies keep theirs)
143. for (g of index.genres.keys()) {
144. let list = []
145. 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 }) }
146. index.genres[g] = sortDesc(list)
147. }
148. }
149. index.day = today
150. return null
151. }
153. // one title out of the lists of the genres it was in, then (when public) into those of its current genres
154. static refreshGenres = (&show, &shown, key) => {
155. old = index.genresOf[show.id]
156. if (old != null) {
157. for (g of old) { if (index.genres[g] != null) { index.genres[g] = without(index.genres[g], show.id) } }
158. }
159. index.genresOf[show.id] = null
160. if (!shown || show.genres == null || show.genres.length == 0) { return null }
161. for (g of show.genres) {
162. let list = index.genres[g]
163. if (list == null) { list = [] }
164. index.genres[g] = placed(list, { id = show.id key = key })
165. }
166. index.genresOf[show.id] = show.genres
167. return null
168. }
170. // after the sync (or the adult backfill) touched a show: its entry from its own data again (only that show's
171. // seasons/episodes are read) — or out of the list when it is not public (adult or unknown, mission 054)
172. static refreshCatalogShow = (&showId) => {
173. rollDay()
174. show = showById(showId)
175. if (show == null) { return null }
176. // tracker#30: the lists' slim cache of this title (shows.hl cardOf / episodeRowsOf) from the changed record
177. refreshTitleCaches(show)
178. shown = isPublicTitle(show)
179. if (show.type == 'movie') {
180. index.movies = shown ? placed(index.movies, { id = show.id key = dateOr(show.release) }) : without(index.movies, show.id)
181. refreshGenres(show, shown, dateOr(show.release))
182. return null
183. }
184. if (show.type != 'series') { return null }
185. today = index.day
186. let l = null
187. up = []
188. for (s of seasonsOfShow(show)) {
189. for (e of episodesOfSeason(s)) {
190. if (dateOr(e.release) != '') {
191. if (e.release <= today) { if (l == null || e.release > l) { l = e.release } } else { up.push(e.release) }
192. }
193. }
194. }
195. index.latest[show.id] = l
196. index.upcoming[show.id] = up
197. index.release[show.id] = dateOr(show.release)
198. // in the list of its kind (#21), out of the other one
199. entry = { id = show.id key = seriesKey(l, index.release[show.id]) }
200. isShow = titleKind(show) == 'show'
201. index.series = shown && !isShow ? placed(index.series, entry) : without(index.series, show.id)
202. index.shows = shown && isShow ? placed(index.shows, entry) : without(index.shows, show.id)
203. refreshGenres(show, shown, genreKey(l, index.release[show.id]))
204. return null
205. }
207. // ---- what the pages read ---------------------------------------------------------------------------------------
208. // one poster tile: poster, title, year, the title's page (/movies/, /series/ or /shows/<slug>, shows.hl titlePath — one
209. // component for all three, with its Follow button). tracker#30 (mission 025): from the slim cached card (shows.hl cardOf),
210. // not the whole record with its cast and crew
211. static tilesOf = (&entries) => {
212. out = []
213. for (x of entries) {
214. let c = cardOf(x.id)
215. if (c != null) { out.push({ id = c.id title = c.title year = c.year href = c.href posterUrl = posterUrlOfName(c.posterName) }) }
216. }
217. return out
218. }
220. // the homepage: the n latest RELEASED movies (none dated after today) and the n series with the newest released episode
221. static latestMovies = (&n) => {
222. rollDay()
223. want = []
224. for (x of index.movies) {
225. if (want.length < n && x.key != '' && x.key <= index.day) { want.push(x) }
226. if (want.length >= n) { return tilesOf(want) }
227. }
228. return tilesOf(want)
229. }
230. static latestSeries = (&n) => { rollDay() return latestTv(index.series, n) }
231. static latestShows = (&n) => { rollDay() return latestTv(index.shows, n) }
232. static latestTv = (&list, &n) => {
233. want = []
234. for (x of list) {
235. if (want.length < n && x.key.slice(0, 1) == '1') { want.push(x) }
236. if (want.length >= n) { return tilesOf(want) }
237. }
238. return tilesOf(want)
239. }
241. // a page number from the address (`/movies/page/:page`, a String) — anything that is not a whole number ≥ 1 is page 1;
242. // past the last page is the last page
243. static pageNumberOf = (&raw, &pages) => {
244. if (raw == null) { return 1 }
245. s = '' + raw
246. if (s == '' || s.length > 6) { return 1 }
247. let i = 0
248. while (i < s.length) {
249. let c = s.charCodeAt(i)
250. if (c < 48 || c > 57) { return 1 }
251. i = i + 1
252. }
253. p = toNumber(s)
254. if (p < 1) { return 1 }
255. return p > pages ? pages : p
256. }
257. static pagesOf = (&count) => {
258. let p = 1
259. while (p * pageSize < count) { p = p + 1 }
260. return p
261. }
262. // { page, pages, tiles } of one list
263. static pageOf = (&list, &raw) => {
264. pages = pagesOf(list.length)
265. let page = pageNumberOf(raw, pages)
266. return { page = page pages = pages tiles = tilesOf(list.slice((page - 1) * pageSize, page * pageSize)) }
267. }
268. static moviesPage = (&raw) => { rollDay() return pageOf(index.movies, raw) }
269. static seriesPage = (&raw) => { rollDay() return pageOf(index.series, raw) }
270. static showsPage = (&raw) => { rollDay() return pageOf(index.shows, raw) }
271. static catalogCounts = () => { return { movies = index.movies.length series = index.series.length shows = index.shows.length } }
272. // /genres/<genre> (mission 058): one genre's movies and series, newest first, 24 per page; how many there are
273. static genrePage = (&genreId, &raw) => {
274. rollDay()
275. list = index.genres[genreId]
276. return pageOf(list != null ? list : [], raw)
277. }
278. static genreCount = (&genreId) => {
279. list = index.genres[genreId]
280. return list != null ? list.length : 0
281. }
282. // /genres (tracker#32, the main menu's Genres): every genre that has public titles, A–Z, with how many — the genres table is 27 rows
283. static genreList = () => {
284. keyed = []
285. for (g of genresTable.find(null, null)) {
286. let n = genreCount(g.id)
287. if (n > 0 && g.name != null && g.urlSegment != null) { keyed.push({ key = ('' + g.name).toLowerCase() name = '' + g.name href = '/genres/' + g.urlSegment count = n }) }
288. }
289. desc = sortDesc(keyed)
290. out = []
291. let i = desc.length - 1
292. while (i >= 0) { out.push(desc[i]) i = i - 1 }
293. return out
294. }