tracker

14.9 KB

1. // people.hl — THE PERSON PAGE's data (tracker.worldapi.org#16, components/person.hl `/person/<slug>`): a person by slug,
2. // their facts and filmography, and the ONE-TIME fetch of their whole filmography from TMDB on the first visit. Creator:
3. // "the movies come from artist scrolls. when one clicks on an artist that has no dataset yet the old version fetched that
4. // artist and its entire bibilogrqphy so its profile was complete".
5. //
6. // personBySlug(slug) the person (slug = `urlSegment`) — a slug → id map built once (15k people, one scan)
7. // personInfoOf(p) name, photo URL, born/died lines, bio
8. // filmographyOf(p) their credits (`p.shows`): poster, title, year, role, kind — newest first, adult titles hidden
9. // personFillStep(id) ONE step of the fetch, called again and again by the page until it answers `done`:
10. // 1st call: GET <TMDB>/person/<tmdbId>?append_to_response=combined_credits (ONE request: details +
11. // every cast/crew credit) + the photo (w185, like the posters); the person's facts are updated;
12. // every next call stores the next `fillBatch` titles; the last one links the credits and marks
13. // the person complete (`filmographyAt`, ms). hl:web serves one request at a time — between two
14. // steps every other request is served, so a person with 300 credits never holds the server.
15. //
16. // COMPLETE = `filmographyAt` set: never fetched again (the daily sync may refresh followed people later — not built).
17. // Migrated people are NOT complete (153 of them carry the old tracker's credits — kept, the fetch adds the rest).
18. // A title we don't have → a MINIMAL show record (title, year, type, tmdbId, `adult`, overview, genres by TMDB id, language;
19. // no seasons, no poster file — the daily sync / a backfill brings those), shaped like search.hl importTitle's
20. // (`oldId tmdb-<tv|movie>-<id>`, a free slug), indexed for the search and put into the public lists (catalog.hl).
21. // The person's credits (`shows`, the migrated field): [{ show, character, posterPath, adult }] — `character` is the role
22. // text (the characters, then crew jobs like "Director", " / " between them); `posterPath` = TMDB's, so the page can show
23. // TMDB's small poster (w92, like search's web rows) until we have the file. ADULT (TMDB's flag, mission 054): a row is
24. // shown only for a PUBLIC title (shows.hl `isPublicTitle`: `adult == false`, unknown hidden like the public lists) whose
25. // credit is not adult either (mission 056 merge).
26. // ONE PROCESS PER STORAGE (hybriel#21); new rows get self-assigned 16-hex ids (hybriel#113), like tmdbsync.hl.
27. import { now } from 'hl:time'
28. import { fetch } from 'hl:fetch'
29. import { randomBytes } from 'hl:crypto'
30. import { writeFile, mkDir, exists } from 'hl:fs'
31. import { personsTable, showsTable, genresTable, storageDir, showById, showYear, posterUrlOf, isPublicTitle } from './shows.hl'
32. import { tmdbGet, tmdbImageBase, textOr } from './tmdbsync.hl'
33. import { titleIdByTmdb, indexShow, slugOf } from './search.hl'
34. import { refreshCatalogShow, sortDesc } from './catalog.hl'
36. static profilesDir = storageDir + '/profiles'
37. // titles stored per step (real data: see STATUS.md ticket #16 for the per-step time)
38. static fillBatch = 40
40. static listOr = (v) => { return v == null ? [] : v }
42. // ---- the person -------------------------------------------------------------------------------------------------
43. static slugIndex = { built = false ids = {} }
44. static personBySlug = (slug) => {
45. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
46. if (!slugIndex.built) {
47. let m = {}
48. for (p of personsTable.find(null, null)) { if (p.urlSegment != null) { m[p.urlSegment] = p.id } }
49. slugIndex.ids = m
50. slugIndex.built = true
51. }
52. let id = slugIndex.ids[slug]
53. return id == null ? null : personsTable.fetch(id)
54. }
56. static isComplete = (p) => { return p.filmographyAt != null }
57. // the page asks TMDB for this person: not complete yet, and TMDB knows them
58. static needsFill = (p) => { return !isComplete(p) && p.tmdbId != null }
60. // the photo: /profiles/<oldId>.<ext> (project.hl profileRoute) — only when the file is there (the migrated `image` = 'jpg'
61. // of 129 people never came with a file)
62. static profileName = (p) => {
63. if (p.oldId == null || p.image == null || p.image == '') { return null }
64. return p.oldId + '.' + p.image
65. }
66. static photoUrlOf = (p) => {
67. let name = profileName(p)
68. return name != null && exists(profilesDir + '/' + name) ? '/profiles/' + name : ''
69. }
71. static monthNames = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
72. // '1986-03-04' → '4 March 1986'; a bare year or anything else as it is
73. static dateText = (d) => {
74. let t = textOr(d)
75. if (t == null) { return null }
76. if (t.length < 10) { return t }
77. let m = toNumber(t.slice(5, 7))
78. let day = toNumber(t.slice(8, 10))
79. if (m == null || day == null || m < 1 || m > 12) { return t }
80. return day + ' ' + monthNames[m - 1] + ' ' + t.slice(0, 4)
81. }
83. // { name, photoUrl, born, died, bio } — every field a plain string ('' = none)
84. static personInfoOf = (p) => {
85. let born = dateText(p.birthDate)
86. let place = textOr(p.birthPlace)
87. let bornText = ''
88. if (born != null && place != null) { bornText = 'Born ' + born + ' in ' + place } else if (born != null) { bornText = 'Born ' + born } else if (place != null) { bornText = 'Born in ' + place }
89. let died = dateText(p.deathDate)
90. return { name = p.name != null ? p.name : '' photoUrl = photoUrlOf(p) born = bornText died = died != null ? 'Died ' + died : ''
91. bio = textOr(p.biography) != null ? p.biography : '' }
92. }
94. // ---- the filmography --------------------------------------------------------------------------------------------
95. // the credits, one row per title (a title twice — the migrated credit and TMDB's — is ONE row, roles merged), newest
96. // first by the title's release ('YYYY-MM-DD', else its year), undated last; only public titles (no adult/unknown)
97. static filmographyOf = (p) => {
98. let byShow = {}
99. let order = []
100. for (c of listOr(p.shows)) {
101. if (c != null && c.show != null) {
102. let role = textOr(c.character)
103. let prev = byShow[c.show]
104. if (prev == null) {
105. byShow[c.show] = { role = role != null ? role : '' posterPath = textOr(c.posterPath) adult = c.adult == true }
106. order.push(c.show)
107. } else {
108. let x = prev
109. if (role != null && !(' / ' + x.role + ' / ').includes(' / ' + role + ' / ')) { x.role = x.role == '' ? role : x.role + ' / ' + role }
110. if (x.posterPath == null) { x.posterPath = textOr(c.posterPath) }
111. if (c.adult == true) { x.adult = true }
112. byShow[c.show] = x
113. }
114. }
115. }
116. let list = []
117. for (sid of order) {
118. let c = byShow[sid]
119. let s = showById(sid)
120. if (isPublicTitle(s) && !c.adult) {
121. let y = showYear(s)
122. let release = textOr(s.release)
123. let key = release != null && release.length >= 4 ? release : (y != null ? y : '')
124. let poster = posterUrlOf(s)
125. if (poster == '/posters/none' && c.posterPath != null) { poster = tmdbImageBase + '/w92' + c.posterPath }
126. list.push({ key = key id = s.id title = s.title year = y != null ? y : '' href = '/shows/' + s.urlSegment posterUrl = poster
127. role = c.role typeLabel = s.type == 'movie' ? 'Movie' : 'Series' })
128. }
129. }
130. let out = []
131. let undated = []
132. for (r of sortDesc(list)) { if (r.key == '') { undated.push(r) } else { out.push(r) } }
133. for (r of undated) { out.push(r) }
134. return out
135. }
137. // ---- the fetch ------------------------------------------------------------------------------------------------
138. // person id → { items, pos, credits, added, requests, started, steps } while a fetch is under way (in memory: a restart
139. // loses it — the titles stored so far are found again by TMDB id, nothing is duplicated)
140. static jobs = {}
142. // TMDB genre id → ours (our genres carry TMDB's id)
143. static genreMap = { built = false ids = {} }
144. static genreIdsOfTmdb = (tmdbIds) => {
145. if (!genreMap.built) {
146. let m = {}
147. for (g of genresTable.find(null, null)) { if (g.tmdbId != null) { m['' + g.tmdbId] = g.id } }
148. genreMap.ids = m
149. genreMap.built = true
150. }
151. let out = []
152. for (t of listOr(tmdbIds)) {
153. let id = genreMap.ids['' + t]
154. if (id != null && !out.includes(id)) { out.push(id) }
155. }
156. return out
157. }
159. // TMDB's combined_credits → one item per title (cast AND crew of the same title merged), TV + movies only
160. static creditItems = (cc) => {
161. let byKey = {}
162. let order = []
163. let all = []
164. if (cc != null) {
165. for (c of listOr(cc.cast)) { all.push({ credit = c role = textOr(c.character) }) }
166. for (c of listOr(cc.crew)) { all.push({ credit = c role = textOr(c.job) }) }
167. }
168. for (a of all) {
169. let c = a.credit
170. let kind = c.media_type
171. if ((kind == 'tv' || kind == 'movie') && c.id != null && hlTypeName(c.id) == 'Number') {
172. let k = kind + ':' + c.id
173. let known = byKey[k]
174. if (known == null) {
175. let name = kind == 'tv' ? textOr(c.name) : textOr(c.title)
176. if (name != null) {
177. byKey[k] = { kind = kind tmdbId = c.id title = name release = textOr(kind == 'tv' ? c.first_air_date : c.release_date)
178. overview = textOr(c.overview) language = textOr(c.original_language) genreIds = listOr(c.genre_ids)
179. posterPath = textOr(c.poster_path) adult = c.adult == true role = a.role != null ? a.role : '' }
180. order.push(k)
181. }
182. } else if (a.role != null && !(' / ' + known.role + ' / ').includes(' / ' + a.role + ' / ')) {
183. let x = known
184. x.role = x.role == '' ? a.role : x.role + ' / ' + a.role
185. byKey[k] = x
186. }
187. }
188. }
189. let out = []
190. for (k of order) { out.push(byKey[k]) }
191. return out
192. }
194. // the photo: w185 → storage/mpackdb/profiles/<oldId>.<ext> — { requests, image, tmdbProfile, failed }
195. static syncProfile = (p, profilePath) => {
196. let out = { requests = 0 image = p.image tmdbProfile = p.tmdbProfile failed = null }
197. if (textOr(profilePath) == null || p.oldId == null) { return out }
198. let parts = profilePath.split('.')
199. let ext = parts[parts.length - 1].toLowerCase()
200. if (ext != 'jpg' && ext != 'jpeg' && ext != 'png' && ext != 'webp') { return out }
201. let file = profilesDir + '/' + p.oldId + '.' + ext
202. if (exists(file) && p.tmdbProfile == profilePath && p.image == ext) { return out }
203. out.requests = 1
204. let r = fetch(tmdbImageBase + '/w185' + profilePath, { headers = { 'user-agent' = 'tracker.worldapi.org (person page)' } timeoutMs = 20000 })
205. if (r == null || r.status != 200 || r.body == null || r.body.length == 0) {
206. out.failed = 'photo ' + profilePath + ': ' + (r == null ? 'no answer' : 'HTTP ' + r.status)
207. return out
208. }
209. mkDir(profilesDir)
210. writeFile(file, toBytes(r.body), 420)
211. out.image = ext
212. out.tmdbProfile = profilePath
213. return out
214. }
216. // step 1: TMDB's person + credits; the facts (a TMDB value that is empty never overwrites ours) and the photo
217. static startFill = (p) => {
218. let t0 = now()
219. let d = tmdbGet('/person/' + p.tmdbId + '?append_to_response=combined_credits')
220. if (d.failed != null) { return { error = 'TMDB: ' + d.failed } }
221. let items = creditItems(d.combined_credits)
222. let photo = syncProfile(p, d.profile_path)
223. let x = p
224. if (textOr(d.biography) != null) { x.biography = d.biography }
225. if (textOr(d.birthday) != null) { x.birthDate = d.birthday }
226. if (textOr(d.deathday) != null) { x.deathDate = d.deathday }
227. if (textOr(d.place_of_birth) != null) { x.birthPlace = d.place_of_birth }
228. if (textOr(x.imdbId) == null && textOr(d.imdb_id) != null) { x.imdbId = d.imdb_id }
229. if (d.adult != null) { x.adult = d.adult == true }
230. x.image = photo.image
231. x.tmdbProfile = photo.tmdbProfile
232. if (personsTable.update(x.id, x) == null) { return { error = 'could not store the person: ' + personsTable.lastError() } }
233. if (photo.failed != null) { console.log('person fill: ' + p.name + ': ' + photo.failed) }
234. jobs[p.id] = { items = items pos = 0 credits = [] added = 0 requests = 1 + photo.requests started = t0 steps = 1 tmdbMs = now() - t0 }
235. return { done = false pos = 0 total = items.length }
236. }
238. // a title we don't have: the minimal record (shape: search.hl importTitle) → its id, or null
239. static addMinimalTitle = (cr, pid, pname) => {
240. let kindType = cr.kind == 'tv' ? 'series' : 'movie'
241. let rel = cr.release
242. let yr = rel != null && rel.length >= 4 ? toNumber(rel.slice(0, 4)) : null
243. let slug = slugOf(cr.title, cr.tmdbId)
244. let record = {
245. id = randomBytes(8, 'hex') title = cr.title summary = cr.overview != null ? cr.overview : '' tmdbSummary = cr.overview tmdbId = cr.tmdbId
246. language = cr.language type = kindType release = rel year = yr image = null
247. urlSegment = slug episodesCount = null homepage = null imdbId = null seasonsCount = null
248. status = null tagline = null tvdbId = null tvmzId = null genres = genreIdsOfTmdb(cr.genreIds)
249. cast = [{ person = pid character = cr.role actor = pname }] seasons = [] oldId = 'tmdb-' + cr.kind + '-' + cr.tmdbId
250. adult = cr.adult imported = now()
251. }
252. if (showsTable.put(record) == null) {
253. console.log('person fill: "' + cr.title + '" not stored: ' + showsTable.lastError())
254. return null
255. }
256. indexShow(record)
257. refreshCatalogShow(record.id)
258. return record.id
259. }
261. // every next step: the next `fillBatch` titles; the last one links the credits and marks the person complete
262. static fillStep = (p, jobIn) => {
263. let job = jobIn
264. let total = job.items.length
265. let end = job.pos + fillBatch
266. if (end > total) { end = total }
267. let credits = job.credits
268. let added = job.added
269. let pid = p.id
270. let pname = p.name
271. let i = job.pos
272. while (i < end) {
273. let item = job.items[i]
274. let sid = titleIdByTmdb(item.kind == 'tv' ? 'series' : 'movie', item.tmdbId)
275. if (sid == null) {
276. sid = addMinimalTitle(item, pid, pname)
277. if (sid != null) { added = added + 1 }
278. }
279. if (sid != null) { credits.push({ show = sid character = item.role posterPath = item.posterPath adult = item.adult }) }
280. i = i + 1
281. }
282. job.pos = end
283. job.credits = credits
284. job.added = added
285. job.steps = job.steps + 1
286. jobs[pid] = job
287. if (end < total) { return { done = false pos = end total = total } }
289. // done: the credits (+ the migrated ones TMDB no longer lists), complete
290. let have = {}
291. let all = []
292. for (c of credits) { have[c.show] = true all.push(c) }
293. for (c of listOr(p.shows)) { if (c != null && c.show != null && have[c.show] != true) { all.push(c) } }
294. let x = p
295. x.shows = all
296. x.filmographyAt = now()
297. if (personsTable.update(x.id, x) == null) { return { error = 'could not store the filmography: ' + personsTable.lastError() } }
298. personsTable.persist()
299. showsTable.persist()
300. jobs[pid] = null
301. console.log('person fill: ' + pname + ' (tmdb ' + p.tmdbId + ') credits=' + total + ' added=' + added + ' requests=' + job.requests + ' steps=' + job.steps + ' tmdbMs=' + job.tmdbMs + ' ms=' + (now() - job.started))
302. return { done = true pos = total total = total added = added }
303. }
305. // one step for the person with this id: { done, pos, total } or { error }
306. static personFillStep = (personId) => {
307. let p = personsTable.fetch(personId)
308. if (p == null) { return { error = 'no such person' } }
309. if (isComplete(p)) { return { done = true } }
310. if (p.tmdbId == null) { return { error = 'TMDB does not know this person' } }
311. let job = jobs[personId]
312. if (job == null) { return startFill(p) }
313. return fillStep(p, job)
314. }