tracker

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