tracker

26.8 KB

1. // lib/sync.hl — THE TMDB SYNC OF ONE TITLE (tracker.worldapi.org#9; tmdbsync.hl before mission 028 — its requests are in tmdb.hl,
2. // its small helpers in sync-helpers.hl, the backfills in backfill.hl): for every show SOMEONE follows, fetch the show's
3. // details, seasons and episodes from TMDB and bring storage/mpackdb/ up to date, plus the show's poster.
4. // Used by BOTH runners: the daily run inside the app (jobs.hl `syncTick`, one show per step) and the
5. // command-line tool (tools/sync-tmdb.hl). Reference for the API use: the old tracker's
6. // crates/sync/commands/sync.js (read-only).
7. //
8. // GET <TMDB_BASE_URL>/tv/<tmdbId>?append_to_response=external_ids,aggregate_credits the details (status,
9. // counts, overview, poster_path, seasons[])
10. // + external_ids (imdb_id, tvdb_id) + the cast/crew
11. // of every season (tracker#28: the answer goes back
12. // as `res.details`, the caller stores the credits —
13. // credits.hl applyCredits; no extra request)
14. // GET <TMDB_BASE_URL>/tv/<tmdbId>?append_to_response=season/1,season/2… up to 20 seasons with their
15. // episodes in ONE request
16. // GET <TMDB_IMAGE_URL>/w342<poster_path> the poster → storage/mpackdb/posters/
17. // Authorization: Bearer $TMDB_READ_TOKEN
18. // GET <TVMAZE_BASE_URL>/lookup/shows?imdb=tt… (else ?thetvdb=<id>) the TVmaze id, ONLY when the show
19. // has none (301 → /shows/<id>, 404 = unknown)
20. // GET <TVMAZE_BASE_URL>/shows/<tvmzId>?embed=episodes a SERIES on TVmaze with its episodes (#15), see
21. // below; its summary → `tvmazeSummary` (tracker#18),
22. // its status → `tvmazeStatus` (tracker#35)
23. // A MOVIE (`type = 'movie'`, 7814 of the migrated rows, 1 followed): only
24. // GET <TMDB_BASE_URL>/movie/<tmdbId>?append_to_response=external_ids,credits its imdb id + poster (+ credits); no seasons,
25. // status, overview (it is no TV show)
26. //
27. // EXTERNAL IDS (tracker.worldapi.org#12, the show page's link icons): a MISSING imdbId/tvdbId is filled from TMDB's
28. // external_ids, a missing tvmzId from TVmaze's lookup — an id the show already has is NEVER overwritten.
29. // RULES (ticket): new seasons/episodes are ADDED, existing ones UPDATED (title, summary, release) —
30. // matched by tmdbId, never duplicated; NOTHING is deleted. An episode without a tmdbId (161 migrated ones)
31. // is matched by its S/E number instead and gets the tmdbId. Tracker#39 (mission 032): so is an episode whose tmdbId TMDB no longer
32. // lists in that season — TMDB re-creates episodes now and then (Scrubs S1E1: 326465 → 6992247); the old id is kept as
33. // `migratedTmdbId`. Before, such a migrated episode stayed and a SECOND one of the same number was added (850 on the live copy,
34. // merged by merge.hl). A season (no tmdbId in the migrated data) is
35. // matched by (show, seasonNumber). A TMDB value that is empty/null never overwrites a stored one.
36. // Season 0 ("Specials") is only synced for a show that already has a season 0 (else every followed show
37. // would suddenly flood /my/unwatched with specials); a TMDB season with no episodes is not created.
38. //
39. // TVMAZE MERGE (tracker.worldapi.org#15): AFTER TMDB, a series with a tvmzId gets TVmaze's episode list (one request)
40. // and TVmaze FILLS GAPS only — matched by season/episode number: a missing episode (and its season) is ADDED, an empty
41. // title or air date of an existing one is FILLED; a value TMDB gave is never overwritten. A placeholder title
42. // ("Episode 4", "TBA") counts as empty — and TMDB's own placeholder never overwrites a real title either (else the
43. // two would flip it every day). When TMDB later lists the episode, the TMDB step adopts it by number (it has no tmdbId)
44. // and TMDB's values win. TVmaze specials (no episode number) are skipped, season 0 only if the show has one. SAFETY:
45. // when the two number a show differently (fewer than 80 % of the episodes both know air within a day of each other or
46. // share the title — `numberingAgrees`), TVmaze is ignored for that show (`tvmazeSkipped`). Summaries are not taken
47. // (TVmaze's are HTML; the ticket asks for episodes, air dates, titles). The SHOW's TVmaze summary is kept, HTML stripped, as
48. // `tvmazeSummary` (tracker#18; the page shows summary > tmdbSummary > tvmazeSummary, shows.hl summaryOf).
49. //
50. // WHICH TITLES, WHEN (tracker#18): the daily run asks TMDB's and TVmaze's change lists first and syncs only the titles of ours
51. // that changed — dailysync.hl. THE SHOW RECORD (title, tagline, homepage, status, genres …) is refreshed from the same details
52. // answer by details.hl `applySynced`.
53. //
54. // IDS ARE SELF-ASSIGNED (randomBytes, like watches.hl): hl:mpackdb's own generated @id can repeat within
55. // one millisecond, which is what made update() lose rows (hybriel#113, fixed upstream, not in the vendored
56. // build) — a table holding only unique ids is safe to update().
57. //
58. // ONE PROCESS PER STORAGE: hl:mpackdb does not coordinate two processes (hybriel#21) — the in-app run uses
59. // the app's own open tables (imported from shows.hl); the tool only ever runs against a stopped app or a copy.
60. import { now } from 'hl:time'
61. import { newId, textOr } from './util.hl'
62. import { showsTable, seasonsTable, episodesTable, kindOfTitle } from './shows.hl'
63. import { tmdbGet, numIdOr, externalIdsFor, tvmazeEpisodes, tvmazeShow, syncPoster, adultOf } from './tmdb.hl'
64. import { isPlaceholderTitle, numberingAgrees, wantedSeasonNumbers, batchesOf, changedText, isMigratedRow } from './sync-helpers.hl'
66. // Merge TVmaze's episodes of a series into what we have AFTER the TMDB step (gaps only, rules at the top).
67. // `seasonsByNumber` / `epByNumber` = the show's seasons by number and episodes by '<s>x<e>', as the TMDB step left them.
68. // Answers { tvmazeRequests, newSeasons, newEpisodes, filledEpisodes, skipped, errors, error, showSeasons }.
69. static mergeTvmaze = (title, &showKey, tvmzId, seasonsIn, episodesIn, &showSeasonsIn) => {
70. seasonsByNumber = seasonsIn
71. epByNumber = episodesIn
72. out = { tvmazeRequests = 1 newSeasons = 0 newEpisodes = 0 filledEpisodes = 0 skipped = 0 errors = 0 error = '' showSeasons = showSeasonsIn summary = null status = null }
73. got = tvmazeEpisodes(tvmzId)
74. if (got.failed != null) { out.errors = 1 out.error = title + ': ' + got.failed return out }
75. out.summary = got.summary
76. out.status = got.status
77. // the numbered episodes TVmaze has in seasons we take (no specials; season 0 only when the show has one)
78. list = []
79. for (te of got.list) {
80. if (numIdOr(te.season) != null && numIdOr(te.number) != null) { list.push(te) }
81. else if (te.season == 0 && numIdOr(te.number) != null && seasonsByNumber['0'] != null) { list.push(te) }
82. }
83. if (!numberingAgrees(epByNumber, list).ok) { out.skipped = 1 return out }
85. added = {}
86. addedFirstDate = {}
87. for (te of list) {
88. let key = te.season + 'x' + te.number
89. let e = epByNumber[key]
90. if (e == null) {
91. let seasonKey = seasonsByNumber['' + te.season] != null ? seasonsByNumber['' + te.season].id : null
92. if (seasonKey == null) {
93. if (added['' + te.season] == null) { added['' + te.season] = [] addedFirstDate['' + te.season] = textOr(te.airdate) seasonsByNumber['' + te.season] = { id = newId() isNew = true } }
94. seasonKey = seasonsByNumber['' + te.season].id
95. }
96. let fresh = { id = newId() episodeNumber = te.number seasonNumber = te.season
97. title = textOr(te.name) summary = '' release = textOr(te.airdate)
98. show = showKey season = seasonKey tmdbId = null tvmzId = te.id oldId = 'tvmaze-episode:' + te.id }
99. if (episodesTable.put(fresh) == null) {
100. out.errors = out.errors + 1
101. out.error = title + ': TVmaze episode ' + te.id + ' not stored: ' + episodesTable.lastError()
102. } else {
103. if (added['' + te.season] == null) { added['' + te.season] = [] }
104. let l = added['' + te.season]
105. l.push(fresh.id)
106. added['' + te.season] = l
107. epByNumber[key] = fresh
108. out.newEpisodes = out.newEpisodes + 1
109. }
110. } else {
111. let changed = false
112. if (isPlaceholderTitle(e.title) && !isPlaceholderTitle(te.name)) { e.title = te.name changed = true }
113. if (textOr(e.release) == null && textOr(te.airdate) != null) { e.release = te.airdate changed = true }
114. if (changed) {
115. if (episodesTable.update(e.id, e) == null) {
116. out.errors = out.errors + 1
117. out.error = title + ': episode ' + e.id + ' not filled from TVmaze: ' + episodesTable.lastError()
118. } else {
119. epByNumber[key] = e
120. out.filledEpisodes = out.filledEpisodes + 1
121. }
122. }
123. }
124. }
125. // the seasons that got episodes: an existing one is updated, a new one stored and linked to the show
126. showSeasons = []
127. for (sid of showSeasonsIn) { showSeasons.push(sid) }
128. for (n of added.keys()) {
129. let ids = added[n]
130. let s = seasonsByNumber[n]
131. if (ids.length > 0 && s.isNew == true) {
132. let season = { id = s.id seasonNumber = toNumber(n) title = 'Season ' + n release = addedFirstDate[n] summary = ''
133. show = showKey episodes = ids oldId = 'tvmaze-season:' + tvmzId + ':' + n }
134. if (seasonsTable.put(season) == null) {
135. out.errors = out.errors + 1
136. out.error = title + ': TVmaze season ' + n + ' not stored: ' + seasonsTable.lastError()
137. } else {
138. showSeasons.push(season.id)
139. out.newSeasons = out.newSeasons + 1
140. }
141. } else if (ids.length > 0) {
142. let season = seasonsTable.fetch(s.id)
143. let eps = []
144. for (eid of season.episodes) { eps.push(eid) }
145. for (eid of ids) { eps.push(eid) }
146. season.episodes = eps
147. if (seasonsTable.update(season.id, season) == null) {
148. out.errors = out.errors + 1
149. out.error = title + ': season ' + season.id + ' not updated: ' + seasonsTable.lastError()
150. }
151. }
152. }
153. out.showSeasons = showSeasons
154. return out
155. }
157. // a MOVIE: one request — its imdb id (if missing) and its poster; nothing else of the record is touched. `pre` = that
158. // request's answer when the caller already made it (details.hl firstStep, tracker#26), else null
159. static syncMovie = (show, res, &pre) => {
160. out = res
161. out.requests = 1
162. details = pre != null ? pre : tmdbGet('/movie/' + show.tmdbId + '?append_to_response=external_ids,credits')
163. if (details.failed != null) { out.errors = 1 out.error = show.title + ': ' + details.failed return out }
164. if (pre == null) { out.details = details }
165. ids = externalIdsFor(show, details.external_ids, false, false)
166. out.ids = ids.filled
167. poster = syncPoster(show, details.poster_path, details.backdrop_path)
168. out.requests = out.requests + poster.requests
169. out.posters = poster.saved
170. if (poster.failed != null) { out.errors = out.errors + 1 out.error = show.title + ': ' + poster.failed }
171. m = show
172. m.imdbId = ids.imdbId
173. m.image = poster.image
174. m.tmdbPoster = poster.tmdbPoster
175. m.posterFromBackdrop = poster.fromBackdrop
176. // tracker#33 (mission 032): the runtime in minutes (TMDB's 0 = unknown, not stored)
177. if (numIdOr(details.runtime) != null && details.runtime > 0) { m.runtime = details.runtime }
178. if (adultOf(details) != null) { m.adult = adultOf(details) }
179. m.tmdbSync = now()
180. if (showsTable.update(m.id, m) == null) { out.errors = out.errors + 1 out.error = show.title + ': movie not updated: ' + showsTable.lastError() }
181. return out
182. }
184. // Sync ONE show (by our id). Answers counts: { requests, tvmazeRequests, newSeasons, newEpisodes, updatedEpisodes,
185. // updatedSeasons, posters, ids, tvmazeEpisodes, tvmazeSeasons, tvmazeFilled, tvmazeSkipped, errors, error } + `details` (the
186. // details answer with its credits when this call asked for it, else null — tracker#28: the caller stores the credits). Never throws for a TMDB failure — it is counted and the show left as is.
187. static syncShow = (&showId) => { return syncShowPart(showId, null, null) }
188. // the same with the details request (`/tv|movie/<id>?append_to_response=external_ids…`) already answered — `pre`, counted as
189. // this show's first request — so details.hl (tracker#26) asks TMDB once for details, ids AND the cast
190. static syncShowWith = (&showId, &pre) => { return syncShowPart(showId, pre, null) }
191. // ONE PART of a series' sync (tracker#26: a talk show with 4,000 episodes took 10 s in one step, blocking every request):
192. // `only` = { seasons (the TMDB season numbers of this part), finish (false: only those seasons — new ones linked to the show,
193. // nothing else; true: the ids, TVmaze, poster and the show record), tvmaze (false: no TVmaze lookup/merge — tracker#18's light
194. // step) }; null = everything at once. `pre` is required with `only` (its request is the caller's: a part counts only its own
195. // requests).
196. static emptyResult = () => { return { requests = 0 tvmazeRequests = 0 newSeasons = 0 newEpisodes = 0 updatedEpisodes = 0 updatedSeasons = 0 posters = 0 ids = 0 tvmazeEpisodes = 0 tvmazeSeasons = 0 tvmazeFilled = 0 tvmazeSkipped = 0 errors = 0 error = '' details = null } }
197. static syncShowPart = (&showId, &pre, &only) => {
198. let res = emptyResult()
199. show = showsTable.fetch(showId)
200. if (show == null) { res.errors = 1 res.error = 'no show ' + showId return res }
201. if (show.tmdbId == null) { res.errors = 1 res.error = show.title + ': no tmdbId' return res }
202. if (show.type == 'movie') { return syncMovie(show, res, pre) }
204. res.requests = only != null ? 0 : 1
205. details = pre != null ? pre : tmdbGet('/tv/' + show.tmdbId + '?append_to_response=external_ids,aggregate_credits')
206. if (details.failed != null) { res.errors = 1 res.error = show.title + ': ' + details.failed return res }
207. if (pre == null) { res.details = details }
209. // what we have: seasons by number, episodes by tmdbId and by S/E number
210. // (tracker#18: a part reads only ITS seasons' episodes, unless it finishes with the TVmaze merge, which compares them all —
211. // Today, 15,716 episodes, read them all for a one-season change: 20 s and GBs of memory)
212. tvmazeToo = only == null || only.tvmaze != false
213. allEpisodes = only == null || (only.finish && tvmazeToo)
214. seasonsByNumber = {}
215. epByTmdb = {}
216. epByNumber = {}
217. for (sid of show.seasons) {
218. let s = seasonsTable.fetch(sid)
219. if (s != null) {
220. seasonsByNumber['' + s.seasonNumber] = s
221. let epIds = allEpisodes || only.seasons.includes(s.seasonNumber) ? s.episodes : []
222. for (eid of epIds) {
223. let e = episodesTable.fetch(eid)
224. if (e != null) {
225. if (e.tmdbId != null) { epByTmdb['' + e.tmdbId] = e }
226. epByNumber[e.seasonNumber + 'x' + e.episodeNumber] = e
227. }
228. }
229. }
230. }
232. // plain locals for the record literals below: inside a literal, an entry named `show`/`season` would shadow
233. // the variable for every later entry (SPEC "A literal's entries are evaluated in order")
234. showKey = show.id
235. showTmdb = show.tmdbId
236. let showSeasons = []
237. for (sid of show.seasons) { showSeasons.push(sid) }
238. let showChanged = false
240. let wanted = wantedSeasonNumbers(details, seasonsByNumber)
241. if (only != null) {
242. part = []
243. for (n of wanted) { if (only.seasons.includes(n)) { part.push(n) } }
244. wanted = part
245. }
246. for (batch of batchesOf(wanted, 20)) {
247. let names = []
248. for (n of batch) { names.push('season/' + n) }
249. res.requests = res.requests + 1
250. let withSeasons = tmdbGet('/tv/' + show.tmdbId + '?append_to_response=' + names.join(','))
251. if (withSeasons.failed != null) {
252. res.errors = res.errors + 1
253. res.error = show.title + ': ' + withSeasons.failed
254. } else {
255. for (n of batch) {
256. let ts = withSeasons['season/' + n]
257. if (ts != null && ts.episodes != null) {
258. let season = seasonsByNumber['' + n]
259. let seasonIsNew = season == null
260. let seasonChanged = false
261. if (seasonIsNew) {
262. season = { id = newId() seasonNumber = n title = textOr(ts.name) != null ? ts.name : 'Season ' + n
263. release = textOr(ts.air_date) summary = textOr(ts.overview) != null ? ts.overview : ''
264. show = showKey episodes = [] oldId = 'tmdb-season:' + showTmdb + ':' + n }
265. } else {
266. let seasonMigrated = isMigratedRow(season)
267. if (changedText(season.title, textOr(ts.name))) {
268. if (seasonMigrated && season.migratedTitle == null && textOr(season.title) != null) { season.migratedTitle = season.title }
269. season.title = ts.name seasonChanged = true
270. }
271. if (changedText(season.summary, textOr(ts.overview))) {
272. if (seasonMigrated && season.migratedSummary == null && textOr(season.summary) != null) { season.migratedSummary = season.summary }
273. season.summary = ts.overview seasonChanged = true
274. }
275. if (changedText(season.release, textOr(ts.air_date))) { season.release = ts.air_date seasonChanged = true }
276. }
277. let seasonKey = season.id
278. let seasonEpisodes = []
279. for (eid of season.episodes) { seasonEpisodes.push(eid) }
280. // tracker#39: the episode ids TMDB lists in this season now — a stored one with an id not among them is stale
281. let listed = {}
282. for (te of ts.episodes) { if (te.id != null) { listed['' + te.id] = true } }
283. for (te of ts.episodes) {
284. if (te.id != null && te.episode_number != null) {
285. let e = epByTmdb['' + te.id]
286. if (e == null) {
287. let byNum = epByNumber[n + 'x' + te.episode_number]
288. if (byNum != null && (byNum.tmdbId == null || listed['' + byNum.tmdbId] != true)) { e = byNum }
289. }
290. if (e == null) {
291. let fresh = { id = newId() episodeNumber = te.episode_number seasonNumber = n
292. title = textOr(te.name) summary = textOr(te.overview) != null ? te.overview : '' release = textOr(te.air_date)
293. show = showKey season = seasonKey tmdbId = te.id oldId = 'tmdb-episode:' + te.id }
294. let putId = episodesTable.put(fresh)
295. if (putId == null) {
296. res.errors = res.errors + 1
297. res.error = show.title + ': episode ' + te.id + ' not stored: ' + episodesTable.lastError()
298. } else {
299. seasonEpisodes.push(fresh.id)
300. epByTmdb['' + te.id] = fresh
301. epByNumber[n + 'x' + te.episode_number] = fresh
302. res.newEpisodes = res.newEpisodes + 1
303. seasonChanged = true
304. }
305. } else {
306. let changed = false
307. if (e.tmdbId != te.id) {
308. if (e.tmdbId != null && e.migratedTmdbId == null) { e.migratedTmdbId = e.tmdbId }
309. if (e.tmdbId != null) { epByTmdb['' + e.tmdbId] = null }
310. e.tmdbId = te.id
311. changed = true
312. }
313. // #15: TMDB's "Episode 4" never replaces a real title (one TVmaze filled, or the migrated one)
314. let epMigrated = isMigratedRow(e)
315. if (changedText(e.title, textOr(te.name)) && !(isPlaceholderTitle(te.name) && !isPlaceholderTitle(e.title))) {
316. if (epMigrated && e.migratedTitle == null && textOr(e.title) != null) { e.migratedTitle = e.title }
317. e.title = te.name changed = true
318. }
319. if (changedText(e.summary, textOr(te.overview))) {
320. if (epMigrated && e.migratedSummary == null && textOr(e.summary) != null) { e.migratedSummary = e.summary }
321. e.summary = te.overview changed = true
322. }
323. if (changedText(e.release, textOr(te.air_date))) { e.release = te.air_date changed = true }
324. if (changed) {
325. if (episodesTable.update(e.id, e) == null) {
326. res.errors = res.errors + 1
327. res.error = show.title + ': episode ' + e.id + ' not updated: ' + episodesTable.lastError()
328. } else {
329. epByTmdb['' + e.tmdbId] = e
330. epByNumber[e.seasonNumber + 'x' + e.episodeNumber] = e
331. res.updatedEpisodes = res.updatedEpisodes + 1
332. }
333. }
334. }
335. }
336. }
337. season.episodes = seasonEpisodes
338. if (seasonIsNew) {
339. if (seasonsTable.put(season) == null) {
340. res.errors = res.errors + 1
341. res.error = show.title + ': season ' + n + ' not stored: ' + seasonsTable.lastError()
342. } else {
343. seasonsByNumber['' + n] = season
344. showSeasons.push(season.id)
345. showChanged = true
346. res.newSeasons = res.newSeasons + 1
347. }
348. } else if (seasonChanged) {
349. if (seasonsTable.update(season.id, season) == null) {
350. res.errors = res.errors + 1
351. res.error = show.title + ': season ' + season.id + ' not updated: ' + seasonsTable.lastError()
352. } else {
353. res.updatedSeasons = res.updatedSeasons + 1
354. }
355. }
356. }
357. }
358. }
359. }
361. // a part that is not the last: only the new seasons are linked to the show (the next part reads them)
362. if (only != null && !only.finish) {
363. if (showChanged) {
364. show.seasons = showSeasons
365. if (showsTable.update(show.id, show) == null) { res.errors = res.errors + 1 res.error = show.title + ': show not updated: ' + showsTable.lastError() }
366. }
367. return res
368. }
370. // the external ids (tracker.worldapi.org#12): missing ones from TMDB's external_ids, a missing TVmaze id from TVmaze
371. ids = externalIdsFor(show, details.external_ids, true, tvmazeToo)
372. res.ids = ids.filled
373. res.tvmazeRequests = ids.tvmazeRequests
374. if (ids.failed != null) { res.errors = res.errors + 1 res.error = show.title + ': ' + ids.failed }
376. // tracker.worldapi.org#15: what TVmaze has and TMDB not yet (new episodes/seasons, empty titles and air dates)
377. let tvmazeSummary = null
378. let tvmazeStatus = null
379. if (numIdOr(ids.tvmzId) != null && tvmazeToo) {
380. tvm = mergeTvmaze(show.title, showKey, ids.tvmzId, seasonsByNumber, epByNumber, showSeasons)
381. res.tvmazeRequests = res.tvmazeRequests + tvm.tvmazeRequests
382. res.tvmazeEpisodes = tvm.newEpisodes
383. res.tvmazeSeasons = tvm.newSeasons
384. res.tvmazeFilled = tvm.filledEpisodes
385. res.tvmazeSkipped = tvm.skipped
386. if (tvm.errors > 0) { res.errors = res.errors + tvm.errors res.error = tvm.error }
387. showSeasons = tvm.showSeasons
388. tvmazeSummary = tvm.summary
389. tvmazeStatus = tvm.status
390. }
392. // the show itself: status, counts, TMDB's overview, the poster, when it was synced
393. poster = syncPoster(show, details.poster_path, details.backdrop_path)
394. res.requests = res.requests + poster.requests
395. res.posters = poster.saved
396. if (poster.failed != null) { res.errors = res.errors + 1 res.error = show.title + ': ' + poster.failed }
397. show.seasons = showSeasons
398. if (textOr(details.status) != null) { show.status = details.status }
399. if (details.number_of_seasons != null) { show.seasonsCount = details.number_of_seasons }
400. if (details.number_of_episodes != null) { show.episodesCount = details.number_of_episodes }
401. // tracker#18: TMDB's text → tmdbSummary, TVmaze's → tvmazeSummary; `summary` is the creator's own text, never written here
402. if (textOr(details.overview) != null) { show.tmdbSummary = details.overview }
403. if (tvmazeSummary != null) { show.tvmazeSummary = tvmazeSummary }
404. // tracker#35: TVmaze's status beside TMDB's (`status`) — the page's pill shows TVmaze's when there is one (fresher)
405. if (tvmazeStatus != null) { show.tvmazeStatus = tvmazeStatus }
406. show.image = poster.image
407. show.tmdbPoster = poster.tmdbPoster
408. show.posterFromBackdrop = poster.fromBackdrop
409. show.imdbId = ids.imdbId
410. show.tvdbId = ids.tvdbId
411. show.tvmzId = ids.tvmzId
412. if (adultOf(details) != null) { show.adult = adultOf(details) }
413. if (textOr(details.type) != null) { show.tmdbType = details.type show.kind = kindOfTitle(details.type, show.genres) }
414. show.tmdbSync = now()
415. if (showsTable.update(show.id, show) == null) { res.errors = res.errors + 1 res.error = show.title + ': show not updated: ' + showsTable.lastError() }
416. return res
417. }
419. // ---- the LIGHT step of the daily delta run (tracker#18) ---------------------------------------------------------------
420. // A changed title NOBODY follows (dailysync.hl): its details (+ ids + credits: the record, applySynced) and only the seasons
421. // that can have changed — the ones we don't have, the ones where TMDB counts MORE episodes than we have (fewer: TVmaze's
422. // extras, nothing to fetch), and the newest one (new or renamed episodes land there). No TVmaze (its merge only matters for the followed shows' lists; their full step still does
423. // it). Real data (2026-10-01): Today (67 seasons / 15,716 episodes) and EastEnders (43 / 7,349) change every day; their full
424. // sync blocked the server 20.8 s each and grew the process by ~5 GB each.
425. static changedSeasonNumbers = (&details, &show) => {
426. ours = {}
427. for (sid of show.seasons) {
428. let s = seasonsTable.fetch(sid)
429. if (s != null) { ours['' + s.seasonNumber] = s.episodes.length }
430. }
431. let latest = -1
432. for (x of (details.seasons != null ? details.seasons : [])) {
433. if (x != null && x.season_number != null && x.season_number > latest && (x.episode_count == null || x.episode_count > 0)) { latest = x.season_number }
434. }
435. out = []
436. for (x of (details.seasons != null ? details.seasons : [])) {
437. if (x != null && x.season_number != null) {
438. let n = x.season_number
439. if (n == latest || ours['' + n] == null || (x.episode_count != null && x.episode_count > ours['' + n])) { out.push(n) }
440. }
441. }
442. return out
443. }
444. // tracker#35: `withStatus` — TVmaze's change list named this series too: its TVmaze status as well (one more TVmaze request)
445. static syncShowDelta = (&showId, &withStatus) => {
446. show = showsTable.fetch(showId)
447. if (show == null || show.tmdbId == null || show.type == 'movie') { return syncShow(showId) }
448. details = tmdbGet('/tv/' + show.tmdbId + '?append_to_response=external_ids,aggregate_credits')
449. if (details.failed != null) {
450. let res = emptyResult()
451. res.requests = 1
452. res.errors = 1
453. res.error = show.title + ': ' + details.failed
454. return res
455. }
456. r = syncShowPart(showId, details, { seasons = changedSeasonNumbers(details, show) finish = true tvmaze = false })
457. r.requests = r.requests + 1
458. r.details = details
459. if (withStatus) {
460. st = syncTvmazeStatus(showId)
461. r.tvmazeRequests = r.tvmazeRequests + st.tvmazeRequests
462. if (st.error != '') { r.errors = r.errors + 1 r.error = st.error }
463. }
464. return r
465. }
467. // tracker#35: TVmaze's status of ONE series (`GET /shows/<tvmzId>`, one TVmaze request) → `tvmazeStatus` when it changed — the
468. // daily delta run for a series nobody follows that TVmaze's change list names (a followed one gets TVmaze's merge, which
469. // brings it). Answers the sync's counts (emptyResult: tvmazeRequests, errors, error; no `details`).
470. static syncTvmazeStatus = (&showId) => {
471. let res = emptyResult()
472. show = showsTable.fetch(showId)
473. if (show == null || show.tvmzId == null || ('' + show.tvmzId).trim() == '') { return res }
474. res.tvmazeRequests = 1
475. got = tvmazeShow(show.tvmzId)
476. if (got.failed != null) { res.errors = 1 res.error = show.title + ': ' + got.failed return res }
477. if (got.status != null && got.status != show.tvmazeStatus) {
478. show.tvmazeStatus = got.status
479. if (showsTable.update(show.id, show) == null) { res.errors = 1 res.error = show.title + ': show not updated: ' + showsTable.lastError() }
480. }
481. return res
482. }
484. // flush the three tables' index/meta state to disk (after a run, and every few shows)
485. static persistSync = () => {
486. showsTable.persist()
487. seasonsTable.persist()
488. episodesTable.persist()
489. return true
490. }