tracker

8.7 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. import { now, timestamp } from 'hl:time'
22. import { allShows, allEpisodes, showById, seasonsOfShow, episodesOfSeason, showYear, posterUrlOf, isPublicTitle } from './shows.hl'
24. static pageSize = 24
26. static todayStr = () => { return timestamp(now()).slice(0, 10) }
27. static dateOr = (v) => { return v != null && hlTypeName(v) == 'String' && v.length >= 4 ? v : '' }
28. static seriesKey = (latest, release) => { return latest != null && latest != '' ? '1' + latest : '0' + release }
30. // ---- sorting, hand-written (no list sort(), hybriel#1): a bottom-up merge sort, newest key first, stable ----------
31. static mergeDesc = (a, b) => {
32. let out = []
33. let i = 0
34. let j = 0
35. while (i < a.length && j < b.length) {
36. if (b[j].key > a[i].key) { out.push(b[j]) j = j + 1 } else { out.push(a[i]) i = i + 1 }
37. }
38. while (i < a.length) { out.push(a[i]) i = i + 1 }
39. while (j < b.length) { out.push(b[j]) j = j + 1 }
40. return out
41. }
42. static sortDesc = (list) => {
43. if (list.length == 0) { return [] }
44. let runs = []
45. for (x of list) { runs.push([x]) }
46. while (runs.length > 1) {
47. let next = []
48. let k = 0
49. while (k + 1 < runs.length) { next.push(mergeDesc(runs[k], runs[k + 1])) k = k + 2 }
50. if (k < runs.length) { next.push(runs[k]) }
51. runs = next
52. }
53. return runs[0]
54. }
55. // one entry moved to its place: out of the list, then in before the first entry with a smaller key (linear)
56. static placed = (list, entry) => {
57. let out = []
58. let done = false
59. for (x of list) {
60. if (x.id != entry.id) {
61. if (!done && entry.key > x.key) { out.push(entry) done = true }
62. out.push(x)
63. }
64. }
65. if (!done) { out.push(entry) }
66. return out
67. }
68. // one entry out of the list (a title that is not public, mission 054)
69. static without = (list, id) => {
70. let out = []
71. for (x of list) { if (x.id != id) { out.push(x) } }
72. return out
73. }
75. // ---- the index -------------------------------------------------------------------------------------------------
76. static buildIndex = () => {
77. let today = todayStr()
78. let movies = []
79. let seriesIds = []
80. let release = {}
81. for (s of allShows()) {
82. if (s.type == 'movie') { if (isPublicTitle(s)) { movies.push({ id = s.id key = dateOr(s.release) }) } }
83. else if (s.type == 'series') {
84. if (isPublicTitle(s)) { seriesIds.push(s.id) }
85. release[s.id] = dateOr(s.release)
86. }
87. }
88. let latest = {}
89. let upcoming = {}
90. for (e of allEpisodes()) {
91. if (e.show != null && dateOr(e.release) != '') {
92. if (e.release <= today) {
93. let l = latest[e.show]
94. if (l == null || e.release > l) { latest[e.show] = e.release }
95. } else {
96. let u = upcoming[e.show]
97. if (u == null) { u = [] }
98. u.push(e.release)
99. upcoming[e.show] = u
100. }
101. }
102. }
103. let series = []
104. for (id of seriesIds) { series.push({ id = id key = seriesKey(latest[id], release[id]) }) }
105. return { day = today movies = sortDesc(movies) series = sortDesc(series) latest = latest upcoming = upcoming release = release }
106. }
107. static index = buildIndex()
109. // a new day: upcoming episodes that are out now become their series' newest released one
110. static rollDay = () => {
111. let today = todayStr()
112. if (index.day == today) { return null }
113. let moved = false
114. for (id of index.upcoming.keys()) {
115. let rest = []
116. let l = index.latest[id]
117. for (d of index.upcoming[id]) {
118. if (d <= today) {
119. if (l == null || d > l) { l = d }
120. moved = true
121. } else { rest.push(d) }
122. }
123. index.upcoming[id] = rest
124. if (l != null) { index.latest[id] = l }
125. }
126. if (moved) {
127. let series = []
128. for (x of index.series) { series.push({ id = x.id key = seriesKey(index.latest[x.id], index.release[x.id]) }) }
129. index.series = sortDesc(series)
130. }
131. index.day = today
132. return null
133. }
135. // after the sync (or the adult backfill) touched a show: its entry from its own data again (only that show's
136. // seasons/episodes are read) — or out of the list when it is not public (adult or unknown, mission 054)
137. static refreshCatalogShow = (showId) => {
138. rollDay()
139. let show = showById(showId)
140. if (show == null) { return null }
141. let shown = isPublicTitle(show)
142. if (show.type == 'movie') {
143. index.movies = shown ? placed(index.movies, { id = show.id key = dateOr(show.release) }) : without(index.movies, show.id)
144. return null
145. }
146. if (show.type != 'series') { return null }
147. let today = index.day
148. let l = null
149. let up = []
150. for (s of seasonsOfShow(show)) {
151. for (e of episodesOfSeason(s)) {
152. if (dateOr(e.release) != '') {
153. if (e.release <= today) { if (l == null || e.release > l) { l = e.release } } else { up.push(e.release) }
154. }
155. }
156. }
157. index.latest[show.id] = l
158. index.upcoming[show.id] = up
159. index.release[show.id] = dateOr(show.release)
160. index.series = shown ? placed(index.series, { id = show.id key = seriesKey(l, index.release[show.id]) }) : without(index.series, show.id)
161. return null
162. }
164. // ---- what the pages read ---------------------------------------------------------------------------------------
165. // one poster tile: poster, title, year, the show page (movies use the same /shows/<slug> page and its Follow button)
166. static tileOf = (show) => {
167. let y = showYear(show)
168. return { id = show.id title = show.title year = y != null ? y : '' href = '/shows/' + show.urlSegment posterUrl = posterUrlOf(show) }
169. }
170. static tilesOf = (entries) => {
171. let out = []
172. for (x of entries) {
173. let show = showById(x.id)
174. if (show != null) { out.push(tileOf(show)) }
175. }
176. return out
177. }
179. // the homepage: the n latest RELEASED movies (none dated after today) and the n series with the newest released episode
180. static latestMovies = (n) => {
181. rollDay()
182. let want = []
183. for (x of index.movies) {
184. if (want.length < n && x.key != '' && x.key <= index.day) { want.push(x) }
185. if (want.length >= n) { return tilesOf(want) }
186. }
187. return tilesOf(want)
188. }
189. static latestSeries = (n) => {
190. rollDay()
191. let want = []
192. for (x of index.series) {
193. if (want.length < n && x.key.slice(0, 1) == '1') { want.push(x) }
194. if (want.length >= n) { return tilesOf(want) }
195. }
196. return tilesOf(want)
197. }
199. // a page number from the address (`/movies/page/:page`, a String) — anything that is not a whole number ≥ 1 is page 1;
200. // past the last page is the last page
201. static pageNumberOf = (raw, pages) => {
202. if (raw == null) { return 1 }
203. let s = '' + raw
204. if (s == '' || s.length > 6) { return 1 }
205. let i = 0
206. while (i < s.length) {
207. let c = s.charCodeAt(i)
208. if (c < 48 || c > 57) { return 1 }
209. i = i + 1
210. }
211. let p = toNumber(s)
212. if (p < 1) { return 1 }
213. return p > pages ? pages : p
214. }
215. static pagesOf = (count) => {
216. let p = 1
217. while (p * pageSize < count) { p = p + 1 }
218. return p
219. }
220. // { page, pages, tiles } of one list
221. static pageOf = (list, raw) => {
222. let pages = pagesOf(list.length)
223. let page = pageNumberOf(raw, pages)
224. return { page = page pages = pages tiles = tilesOf(list.slice((page - 1) * pageSize, page * pageSize)) }
225. }
226. static moviesPage = (raw) => { rollDay() return pageOf(index.movies, raw) }
227. static seriesPage = (raw) => { rollDay() return pageOf(index.series, raw) }
228. static catalogCounts = () => { return { movies = index.movies.length series = index.series.length } }