tracker

11.3 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 two rows (10 each) and /movies, /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. // GENRES (mission 058, tracker#25, /genres/<genre>): per genre id one list of its public movies AND series, newest first by
23. // ONE date for both kinds: a movie's `release`, a series' newest released episode (none → its own `release`). Built in the
24. // same scans; `refreshCatalogShow` moves the title in the lists of its old genres (`genresOf`) and its current ones.
25. import { now, timestamp } from 'hl:time'
26. import { allShows, allEpisodes, showById, seasonsOfShow, episodesOfSeason, showYear, posterUrlOf, isPublicTitle } from './shows.hl'
28. static pageSize = 24
30. static todayStr = () => { return timestamp(now()).slice(0, 10) }
31. static dateOr = (v) => { return v != null && hlTypeName(v) == 'String' && v.length >= 4 ? v : '' }
32. static seriesKey = (latest, release) => { return latest != null && latest != '' ? '1' + latest : '0' + release }
33. // a series in a genre list: the plain date (comparable with a movie's release) — its newest released episode, else its release
34. static genreKey = (latest, release) => { return latest != null && latest != '' ? latest : release }
36. // ---- sorting, hand-written (no list sort(), hybriel#1): a bottom-up merge sort, newest key first, stable ----------
37. static mergeDesc = (a, b) => {
38. let out = []
39. let i = 0
40. let j = 0
41. while (i < a.length && j < b.length) {
42. if (b[j].key > a[i].key) { out.push(b[j]) j = j + 1 } else { out.push(a[i]) i = i + 1 }
43. }
44. while (i < a.length) { out.push(a[i]) i = i + 1 }
45. while (j < b.length) { out.push(b[j]) j = j + 1 }
46. return out
47. }
48. static sortDesc = (list) => {
49. if (list.length == 0) { return [] }
50. let runs = []
51. for (x of list) { runs.push([x]) }
52. while (runs.length > 1) {
53. let next = []
54. let k = 0
55. while (k + 1 < runs.length) { next.push(mergeDesc(runs[k], runs[k + 1])) k = k + 2 }
56. if (k < runs.length) { next.push(runs[k]) }
57. runs = next
58. }
59. return runs[0]
60. }
61. // one entry moved to its place: out of the list, then in before the first entry with a smaller key (linear)
62. static placed = (list, entry) => {
63. let out = []
64. let done = false
65. for (x of list) {
66. if (x.id != entry.id) {
67. if (!done && entry.key > x.key) { out.push(entry) done = true }
68. out.push(x)
69. }
70. }
71. if (!done) { out.push(entry) }
72. return out
73. }
74. // one entry out of the list (a title that is not public, mission 054)
75. static without = (list, id) => {
76. let out = []
77. for (x of list) { if (x.id != id) { out.push(x) } }
78. return out
79. }
81. // ---- the index -------------------------------------------------------------------------------------------------
82. static buildIndex = () => {
83. let today = todayStr()
84. let movies = []
85. let seriesIds = []
86. let release = {}
87. let genreTitles = []
88. for (s of allShows()) {
89. if (s.type == 'movie') { if (isPublicTitle(s)) { movies.push({ id = s.id key = dateOr(s.release) }) } }
90. else if (s.type == 'series') {
91. if (isPublicTitle(s)) { seriesIds.push(s.id) }
92. release[s.id] = dateOr(s.release)
93. }
94. if ((s.type == 'movie' || s.type == 'series') && isPublicTitle(s) && s.genres != null && s.genres.length > 0) {
95. genreTitles.push({ id = s.id movie = s.type == 'movie' release = dateOr(s.release) genres = s.genres })
96. }
97. }
98. let latest = {}
99. let upcoming = {}
100. for (e of allEpisodes()) {
101. if (e.show != null && dateOr(e.release) != '') {
102. if (e.release <= today) {
103. let l = latest[e.show]
104. if (l == null || e.release > l) { latest[e.show] = e.release }
105. } else {
106. let u = upcoming[e.show]
107. if (u == null) { u = [] }
108. u.push(e.release)
109. upcoming[e.show] = u
110. }
111. }
112. }
113. let series = []
114. for (id of seriesIds) { series.push({ id = id key = seriesKey(latest[id], release[id]) }) }
115. let byGenre = {}
116. let genresOf = {}
117. for (t of genreTitles) {
118. let key = t.movie ? t.release : genreKey(latest[t.id], t.release)
119. for (g of t.genres) {
120. let list = byGenre[g]
121. if (list == null) { list = [] }
122. list.push({ id = t.id key = key })
123. byGenre[g] = list
124. }
125. genresOf[t.id] = t.genres
126. }
127. let genres = {}
128. for (g of byGenre.keys()) { genres[g] = sortDesc(byGenre[g]) }
129. return { day = today movies = sortDesc(movies) series = sortDesc(series) latest = latest upcoming = upcoming release = release genres = genres genresOf = genresOf }
130. }
131. static index = buildIndex()
133. // a new day: upcoming episodes that are out now become their series' newest released one
134. static rollDay = () => {
135. let today = todayStr()
136. if (index.day == today) { return null }
137. let moved = false
138. for (id of index.upcoming.keys()) {
139. let rest = []
140. let l = index.latest[id]
141. for (d of index.upcoming[id]) {
142. if (d <= today) {
143. if (l == null || d > l) { l = d }
144. moved = true
145. } else { rest.push(d) }
146. }
147. index.upcoming[id] = rest
148. if (l != null) { index.latest[id] = l }
149. }
150. if (moved) {
151. let series = []
152. for (x of index.series) { series.push({ id = x.id key = seriesKey(index.latest[x.id], index.release[x.id]) }) }
153. index.series = sortDesc(series)
154. // the genre lists too: a series' key is its newest released episode (movies keep theirs)
155. for (g of index.genres.keys()) {
156. let list = []
157. 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 }) }
158. index.genres[g] = sortDesc(list)
159. }
160. }
161. index.day = today
162. return null
163. }
165. // one title out of the lists of the genres it was in, then (when public) into those of its current genres
166. static refreshGenres = (show, shown, key) => {
167. let old = index.genresOf[show.id]
168. if (old != null) {
169. for (g of old) { if (index.genres[g] != null) { index.genres[g] = without(index.genres[g], show.id) } }
170. }
171. index.genresOf[show.id] = null
172. if (!shown || show.genres == null || show.genres.length == 0) { return null }
173. for (g of show.genres) {
174. let list = index.genres[g]
175. if (list == null) { list = [] }
176. index.genres[g] = placed(list, { id = show.id key = key })
177. }
178. index.genresOf[show.id] = show.genres
179. return null
180. }
182. // after the sync (or the adult backfill) touched a show: its entry from its own data again (only that show's
183. // seasons/episodes are read) — or out of the list when it is not public (adult or unknown, mission 054)
184. static refreshCatalogShow = (showId) => {
185. rollDay()
186. let show = showById(showId)
187. if (show == null) { return null }
188. let shown = isPublicTitle(show)
189. if (show.type == 'movie') {
190. index.movies = shown ? placed(index.movies, { id = show.id key = dateOr(show.release) }) : without(index.movies, show.id)
191. refreshGenres(show, shown, dateOr(show.release))
192. return null
193. }
194. if (show.type != 'series') { return null }
195. let today = index.day
196. let l = null
197. let up = []
198. for (s of seasonsOfShow(show)) {
199. for (e of episodesOfSeason(s)) {
200. if (dateOr(e.release) != '') {
201. if (e.release <= today) { if (l == null || e.release > l) { l = e.release } } else { up.push(e.release) }
202. }
203. }
204. }
205. index.latest[show.id] = l
206. index.upcoming[show.id] = up
207. index.release[show.id] = dateOr(show.release)
208. index.series = shown ? placed(index.series, { id = show.id key = seriesKey(l, index.release[show.id]) }) : without(index.series, show.id)
209. refreshGenres(show, shown, genreKey(l, index.release[show.id]))
210. return null
211. }
213. // ---- what the pages read ---------------------------------------------------------------------------------------
214. // one poster tile: poster, title, year, the show page (movies use the same /shows/<slug> page and its Follow button)
215. static tileOf = (show) => {
216. let y = showYear(show)
217. return { id = show.id title = show.title year = y != null ? y : '' href = '/shows/' + show.urlSegment posterUrl = posterUrlOf(show) }
218. }
219. static tilesOf = (entries) => {
220. let out = []
221. for (x of entries) {
222. let show = showById(x.id)
223. if (show != null) { out.push(tileOf(show)) }
224. }
225. return out
226. }
228. // the homepage: the n latest RELEASED movies (none dated after today) and the n series with the newest released episode
229. static latestMovies = (n) => {
230. rollDay()
231. let want = []
232. for (x of index.movies) {
233. if (want.length < n && x.key != '' && x.key <= index.day) { want.push(x) }
234. if (want.length >= n) { return tilesOf(want) }
235. }
236. return tilesOf(want)
237. }
238. static latestSeries = (n) => {
239. rollDay()
240. let want = []
241. for (x of index.series) {
242. if (want.length < n && x.key.slice(0, 1) == '1') { want.push(x) }
243. if (want.length >= n) { return tilesOf(want) }
244. }
245. return tilesOf(want)
246. }
248. // a page number from the address (`/movies/page/:page`, a String) — anything that is not a whole number ≥ 1 is page 1;
249. // past the last page is the last page
250. static pageNumberOf = (raw, pages) => {
251. if (raw == null) { return 1 }
252. let s = '' + raw
253. if (s == '' || s.length > 6) { return 1 }
254. let i = 0
255. while (i < s.length) {
256. let c = s.charCodeAt(i)
257. if (c < 48 || c > 57) { return 1 }
258. i = i + 1
259. }
260. let p = toNumber(s)
261. if (p < 1) { return 1 }
262. return p > pages ? pages : p
263. }
264. static pagesOf = (count) => {
265. let p = 1
266. while (p * pageSize < count) { p = p + 1 }
267. return p
268. }
269. // { page, pages, tiles } of one list
270. static pageOf = (list, raw) => {
271. let pages = pagesOf(list.length)
272. let page = pageNumberOf(raw, pages)
273. return { page = page pages = pages tiles = tilesOf(list.slice((page - 1) * pageSize, page * pageSize)) }
274. }
275. static moviesPage = (raw) => { rollDay() return pageOf(index.movies, raw) }
276. static seriesPage = (raw) => { rollDay() return pageOf(index.series, raw) }
277. static catalogCounts = () => { return { movies = index.movies.length series = index.series.length } }
278. // /genres/<genre> (mission 058): one genre's movies and series, newest first, 24 per page; how many there are
279. static genrePage = (genreId, raw) => {
280. rollDay()
281. let list = index.genres[genreId]
282. return pageOf(list != null ? list : [], raw)
283. }
284. static genreCount = (genreId) => {
285. let list = index.genres[genreId]
286. return list != null ? list.length : 0
287. }