tracker

25.0 KB

1. // franchises.hl — FRANCHISES AND TIMELINES (tracker.worldapi.org#19, mission 066). The creator: "we have franchises, and
2. // timelines, and some franchises have multiple timelines ... make them sortable by timeline or release date at shows the
3. // release date of the last episode counts. in a show or movie page we show a franchise widget with < Prequel | TimelineName
4. // | Sequel > and if the timeline is part of a franchise that franchise is above it and when you click on it you get the
5. // franchise index."
6. //
7. // franchisesTable pk @id index !slug { name, slug, shortId (null: not given out yet), summary, created }
8. // timelinesTable pk @id index !slug { name, slug, franchise (@id | null), order [show @id …], source ('tmdb' |
9. // 'editor'), tmdbCollection (TMDB collection id | null), created }
10. // collectionChecksTable pk = the movie's show @id { collection (TMDB id | null), why, at } — the seed's progress
11. // storage/mpackdb/{franchises,timelines,collectionchecks}.db (new tables; nothing in shows.db changes)
12. //
13. // A TITLE MAY BE IN SEVERAL TIMELINES (Star Trek Prime and Kelvin, or a TMDB collection and a hand-made one): `byShow` (show
14. // @id → [timeline @id]) is built once at start (`ensureFranchises`, one scan of the timelines) and kept up to date by every
15. // edit — the show page's widget reads only its own timelines, never all of them.
16. //
17. // THE ORDER of a timeline is its in-world order (`order`, editable). The pages can sort it by RELEASE instead: a movie by its
18. // `release`, a SERIES by the release date of its LAST episode (the newest one already out; none out yet → the newest
19. // announced one; no episode dates at all → the series' own `release`). Titles without any date go last.
20. //
21. // PUBLIC LIKE THE OTHER LISTS (mission 054): the pages and the widget's prequel/sequel links show only titles with
22. // `adult == false` (shows.hl isPublicTitle); the order keeps them, they are just skipped.
23. //
24. // THE SEED (TMDB movie collections): every movie with a tmdbId (adult ones skipped) is asked once
25. // GET <TMDB>/movie/<tmdbId> → belongs_to_collection { id, name } (or null)
26. // GET <TMDB>/collection/<id> → parts [{ id, title, release_date, adult }] — once per collection
27. // A collection with at least TWO of our (non-adult) movies becomes one timeline (no franchise), its parts in release order;
28. // every part we have is marked checked at once (no own details request). A collection with fewer is remembered (checks) and
29. // gives no timeline (a widget with both ends disabled says nothing). Run in the app like the adult backfill (project.hl
30. // `collectionTick`, one movie per step, ≤ 40 TMDB requests / 10 s, waits while the daily sync or the adult backfill runs),
31. // RESUMES after a restart (the queue = the movies without a check row). A hand-edited timeline is never touched by it.
32. //
33. // ONE PROCESS PER STORAGE (hybriel#21): the tables are opened here, in the app's process only.
34. import { MPackDB } from 'hl:mpackdb'
35. import { env } from 'hl:proc'
36. import { now, timestamp } from 'hl:time'
37. import { randomBytes } from 'hl:crypto'
38. import { showsTable, storageDir, showById, seasonsOfShow, episodesOfSeason, titleWithYear, posterUrlOf, isPublicTitle, titlePath } from './shows.hl'
39. import { userOfSession } from './users.hl'
40. import { tmdbGet } from './tmdbsync.hl'
41. import { normalizeSlugText, dbSearch } from './search.hl'
43. static franchisesTable = new MPackDB(file = storageDir + '/franchises.db', primaryKey = '@id', indexes = ['!slug'])
44. static timelinesTable = new MPackDB(file = storageDir + '/timelines.db', primaryKey = '@id', indexes = ['!slug'])
45. static collectionChecksTable = new MPackDB(file = storageDir + '/collectionchecks.db', primaryKey = '@id', indexes = [])
47. static newId = () => { return randomBytes(8, 'hex') }
48. static todayStr = () => { return timestamp(now()).slice(0, 10) }
49. static dateOr = (&v) => { return v != null && hlTypeName(v) == 'String' && v.length >= 4 ? v : '' }
50. static textOr = (&v) => { return v != null && hlTypeName(v) == 'String' && v.trim() != '' ? v.trim() : null }
52. // ---- who may edit: the creator (ident short id az5b2); TRACKER_EDITORS = a comma list of ident ids (the gate sets its own) ----
53. static editorIds = () => {
54. let v = env('TRACKER_EDITORS')
55. let raw = v != null && v.trim() != '' ? v : 'az5b2'
56. let out = []
57. for (p of raw.split(',')) { if (p.trim() != '') { out.push(p.trim()) } }
58. return out
59. }
60. static editors = editorIds()
61. static isEditorSession = (&session) => {
62. if (session == null || hlTypeName(session) != 'Instance') { return false }
63. let u = userOfSession(session)
64. return u != null && u.identity != null && editors.includes(u.identity)
65. }
67. // ---- slugs: "Star Trek" → "Star-Trek" (the shows' urlSegment form: letters and digits, everything else one '-') ----------
68. static slugChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
69. static slugBase = (&name) => {
70. let t = normalizeSlugText(name)
71. let out = ''
72. let dash = false
73. let i = 0
74. while (i < t.length) {
75. let c = t[i]
76. if (slugChars.includes(c)) {
77. if (dash && out != '') { out = out + '-' }
78. out = out + c
79. dash = false
80. } else { dash = true }
81. i = i + 1
82. }
83. if (out.length > 80) { out = out.slice(0, 80) }
84. return out == '' ? 'timeline' : out
85. }
86. static firstOf = (&list) => { return list != null && list.length > 0 ? list[0] : null }
87. // a list's index of x, -1 when it is not in it (hand-written: list helpers beyond includes/push are not trusted, hybriel#1)
88. static posOf = (&list, &x) => {
89. let i = 0
90. while (i < list.length) {
91. if (list[i] == x) { return i }
92. i = i + 1
93. }
94. return -1
95. }
96. static freeSlug = (&table, &name) => {
97. let base = slugBase(name)
98. // 'edit' is the editor's own address (/franchises/edit)
99. if (firstOf(table.find('slug', base)) == null && base != 'edit') { return base }
100. let n = 2
101. while (firstOf(table.find('slug', base + '-' + n)) != null) { n = n + 1 }
102. return base + '-' + n
103. }
105. static franchiseBySlug = (&slug) => {
106. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
107. return firstOf(franchisesTable.find('slug', slug))
108. }
109. static timelineBySlug = (&slug) => {
110. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
111. return firstOf(timelinesTable.find('slug', slug))
112. }
113. static franchiseById = (&id) => { return id == null || hlTypeName(id) != 'String' || id == '' ? null : franchisesTable.fetch(id) }
114. static timelineById = (&id) => { return id == null || hlTypeName(id) != 'String' || id == '' ? null : timelinesTable.fetch(id) }
116. // ---- byShow: show @id → [timeline @id] ------------------------------------------------------------------------------------
117. static byShow = {}
118. static state = { built = false timelines = 0 ms = 0 }
119. static indexAdd = (&showId, &timelineId) => {
120. let l = byShow[showId]
121. if (l == null) { l = [] }
122. if (!l.includes(timelineId)) { l.push(timelineId) }
123. byShow[showId] = l
124. return true
125. }
126. static indexRemove = (&showId, &timelineId) => {
127. let l = byShow[showId]
128. if (l == null) { return true }
129. let out = []
130. for (x of l) { if (x != timelineId) { out.push(x) } }
131. byShow[showId] = out
132. return true
133. }
134. static ensureFranchises = () => {
135. if (state.built) { return true }
136. state.built = true
137. let t0 = now()
138. let n = 0
139. for (t of timelinesTable.find(null, null)) {
140. n = n + 1
141. if (t.order != null) { for (sid of t.order) { indexAdd(sid, t.id) } }
142. }
143. state.timelines = n
144. state.ms = now() - t0
145. console.log('franchises: ' + n + ' timelines, ' + franchisesTable.count() + ' franchises (' + state.ms + ' ms)')
146. return true
147. }
148. static timelineIdsOfShow = (&showId) => {
149. ensureFranchises()
150. let l = byShow[showId]
151. return l != null ? l : []
152. }
154. // ---- a title as the pages list it ------------------------------------------------------------------------------------------
155. // the date the release sort uses: a movie's release; a series' LAST episode (newest out ≤ today, else newest announced, else
156. // its own release)
157. static releaseKeyOf = (&show) => {
158. if (show.type != 'series') { return dateOr(show.release) }
159. let today = todayStr()
160. let lastOut = ''
161. let lastAny = ''
162. for (s of seasonsOfShow(show)) {
163. for (e of episodesOfSeason(s)) {
164. let d = dateOr(e.release)
165. if (d != '') {
166. if (d > lastAny) { lastAny = d }
167. if (d <= today && d > lastOut) { lastOut = d }
168. }
169. }
170. }
171. if (lastOut != '') { return lastOut }
172. if (lastAny != '') { return lastAny }
173. return dateOr(show.release)
174. }
175. static itemOf = (&show, pos) => {
176. let series = show.type == 'series'
177. let d = releaseKeyOf(show)
178. let label = d == '' ? 'no date' : (series ? 'last episode ' + d : d)
179. return { id = show.id pos = pos title = titleWithYear(show) href = titlePath(show) posterUrl = posterUrlOf(show)
180. kind = series ? 'Series' : 'Movie' date = d dateLabel = label }
181. }
182. // the public titles of a timeline, in its order (`pos` = the place in the in-world order, 1-based)
183. static itemsOf = (&t) => {
184. let out = []
185. let pos = 0
186. if (t.order == null) { return out }
187. for (sid of t.order) {
188. let s = showById(sid)
189. if (s != null && isPublicTitle(s)) {
190. pos = pos + 1
191. out.push(itemOf(s, pos))
192. }
193. }
194. return out
195. }
196. // release order: oldest first, no date last; equal dates keep the timeline order (a stable insertion)
197. static byReleaseOf = (&items) => {
198. let out = []
199. for (it of items) {
200. let next = []
201. let done = false
202. for (x of out) {
203. if (!done && it.date != '' && (x.date == '' || it.date < x.date)) { next.push(it) done = true }
204. next.push(x)
205. }
206. if (!done) { next.push(it) }
207. out = next
208. }
209. return out
210. }
211. static blockOf = (&t) => {
212. let items = itemsOf(t)
213. return { id = t.id name = t.name slug = t.slug href = '/timelines/' + t.slug items = items byRelease = byReleaseOf(items)
214. countText = items.length == 1 ? '1 title' : items.length + ' titles' first = items.length > 0 ? byReleaseOf(items)[0].date : '' }
215. }
217. // ---- the pages -------------------------------------------------------------------------------------------------------------
218. // /franchises: every franchise (name, how many timelines), then the timelines WITHOUT one (TMDB's collections, by name)
219. static byNameOf = (&rows) => {
220. let out = []
221. for (r of rows) {
222. let next = []
223. let done = false
224. let k = r.sortName
225. for (x of out) {
226. if (!done && k < x.sortName) { next.push(r) done = true }
227. next.push(x)
228. }
229. if (!done) { next.push(r) }
230. out = next
231. }
232. return out
233. }
234. static franchiseIndex = () => {
235. let counts = {}
236. let loose = []
237. for (t of timelinesTable.find(null, null)) {
238. let n = t.order != null ? t.order.length : 0
239. if (t.franchise != null && t.franchise != '') { counts[t.franchise] = (counts[t.franchise] != null ? counts[t.franchise] : 0) + 1 }
240. else if (n > 0) { loose.push({ id = t.id name = t.name href = '/timelines/' + t.slug countText = n == 1 ? '1 title' : n + ' titles' sortName = ('' + t.name).toLowerCase() }) }
241. }
242. let fr = []
243. for (f of franchisesTable.find(null, null)) {
244. let c = counts[f.id] != null ? counts[f.id] : 0
245. fr.push({ id = f.id name = f.name href = '/franchises/' + f.slug summary = f.summary != null ? f.summary : ''
246. countText = c == 1 ? '1 timeline' : c + ' timelines' sortName = ('' + f.name).toLowerCase() })
247. }
248. return { franchises = byNameOf(fr) timelines = byNameOf(loose) }
249. }
251. // /franchises/<slug>: the franchise and its timelines (oldest first by their first release) — or null
252. static franchisePage = (slug) => {
253. let f = franchiseBySlug(slug)
254. if (f == null) { return null }
255. let blocks = []
256. for (t of timelinesTable.find(null, null)) {
257. if (t.franchise == f.id) {
258. let b = blockOf(t)
259. let next = []
260. let done = false
261. for (x of blocks) {
262. if (!done && b.first != '' && (x.first == '' || b.first < x.first)) { next.push(b) done = true }
263. next.push(x)
264. }
265. if (!done) { next.push(b) }
266. blocks = next
267. }
268. }
269. return { kind = 'franchise' name = f.name slug = f.slug summary = f.summary != null ? f.summary : '' franchiseName = '' franchiseHref = '' blocks = blocks editHref = '' }
270. }
271. // /timelines/<slug>: one timeline, its franchise above it — or null
272. static timelinePage = (slug) => {
273. let t = timelineBySlug(slug)
274. if (t == null) { return null }
275. let f = franchiseById(t.franchise)
276. return { kind = 'timeline' name = t.name slug = t.slug summary = '' franchiseName = f != null ? f.name : '' franchiseHref = f != null ? '/franchises/' + f.slug : ''
277. blocks = [blockOf(t)] editHref = '/timelines/' + t.slug + '/edit' }
278. }
280. // ---- the widget on a show / movie page: one per timeline the title is in ----------------------------------------------------
281. // { id, name, href, hasFranchise, franchiseName, franchiseHref, hasPrev, noPrev, prevHref, prevTitle, hasNext, noNext, … }:
282. // prequel / sequel = the nearest PUBLIC title before / after this one in the timeline's order
283. static widgetsOf = (&showId) => {
284. let out = []
285. if (showId == null) { return out }
286. for (tid of timelineIdsOfShow(showId)) {
287. let t = timelinesTable.fetch(tid)
288. if (t != null && t.order != null && t.order.includes(showId)) {
289. let at = posOf(t.order, showId)
290. let prev = null
291. let i = at - 1
292. while (prev == null && i >= 0) {
293. let s = showById(t.order[i])
294. if (s != null && isPublicTitle(s)) { prev = s }
295. i = i - 1
296. }
297. let next = null
298. let j = at + 1
299. while (next == null && j < t.order.length) {
300. let s = showById(t.order[j])
301. if (s != null && isPublicTitle(s)) { next = s }
302. j = j + 1
303. }
304. let f = franchiseById(t.franchise)
305. out.push({ id = t.id name = t.name href = '/timelines/' + t.slug
306. hasFranchise = f != null franchiseName = f != null ? f.name : '' franchiseHref = f != null ? '/franchises/' + f.slug : ''
307. hasPrev = prev != null noPrev = prev == null prevHref = prev != null ? titlePath(prev) : '' prevTitle = prev != null ? titleWithYear(prev) : ''
308. hasNext = next != null noNext = next == null nextHref = next != null ? titlePath(next) : '' nextTitle = next != null ? titleWithYear(next) : '' })
309. }
310. }
311. return out
312. }
314. // ---- the editor (the creator only — every caller checks isEditorSession first) ----------------------------------------------
315. static createFranchise = (name, summary) => {
316. let n = textOr(name)
317. if (n == null || n.length > 120) { return { error = 'a franchise needs a name (at most 120 characters)' } }
318. let s = textOr(summary)
319. let rec = { id = newId() name = n slug = freeSlug(franchisesTable, n) shortId = null summary = s != null ? s : '' created = now() }
320. if (franchisesTable.put(rec) == null) { return { error = 'not stored: ' + franchisesTable.lastError() } }
321. franchisesTable.persist()
322. console.log('franchises: new franchise "' + n + '" /franchises/' + rec.slug)
323. return { ok = true slug = rec.slug id = rec.id }
324. }
326. // a new timeline (the editor's, or the seed's with its collection id)
327. static putTimeline = (name, &franchiseId, order, source, &collection) => {
328. let rec = { id = newId() name = name slug = freeSlug(timelinesTable, name) franchise = franchiseId order = order source = source
329. tmdbCollection = collection created = now() }
330. if (timelinesTable.put(rec) == null) { return null }
331. for (sid of order) { indexAdd(sid, rec.id) }
332. return rec
333. }
334. static createTimeline = (&name) => {
335. let n = textOr(name)
336. if (n == null || n.length > 120) { return { error = 'a timeline needs a name (at most 120 characters)' } }
337. let rec = putTimeline(n, null, [], 'editor', null)
338. if (rec == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
339. timelinesTable.persist()
340. console.log('franchises: new timeline "' + n + '" /timelines/' + rec.slug)
341. return { ok = true slug = rec.slug id = rec.id }
342. }
344. // the editor's view of one timeline: every title in its order (adult ones too — the creator sees what is there)
345. static editRowsOf = (&t) => {
346. let out = []
347. if (t == null || t.order == null) { return out }
348. let i = 0
349. let last = t.order.length - 1
350. for (sid of t.order) {
351. let s = showById(sid)
352. if (s != null) {
353. out.push({ id = s.id pos = i + 1 title = titleWithYear(s) posterUrl = posterUrlOf(s) typeLabel = s.type == 'series' ? 'Series' : 'Movie'
354. upClass = i == 0 ? 'quiet mv off' : 'quiet mv' downClass = i == last ? 'quiet mv off' : 'quiet mv' })
355. }
356. i = i + 1
357. }
358. return out
359. }
360. static chipsOf = (&t) => {
361. let out = [{ id = '' name = 'None' cls = t == null || t.franchise == null || t.franchise == '' ? 'chip on' : 'chip' }]
362. let list = []
363. for (f of franchisesTable.find(null, null)) { list.push({ id = f.id name = f.name cls = t != null && t.franchise == f.id ? 'chip on' : 'chip' sortName = ('' + f.name).toLowerCase() }) }
364. for (c of byNameOf(list)) { out.push(c) }
365. return out
366. }
367. static editPageOf = (slug) => {
368. let t = timelineBySlug(slug)
369. if (t == null) { return { found = false id = '' name = '' slug = '' viewHref = '' rows = [] chips = [] } }
370. return { found = true id = t.id name = t.name slug = t.slug viewHref = '/timelines/' + t.slug rows = editRowsOf(t) chips = chipsOf(t) }
371. }
373. static storeOrder = (t, order) => {
374. let old = t.order != null ? t.order : []
375. let rec = t
376. rec.order = order
377. if (timelinesTable.update(rec.id, rec) == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
378. timelinesTable.persist()
379. for (sid of old) { if (!order.includes(sid)) { indexRemove(sid, rec.id) } }
380. for (sid of order) { indexAdd(sid, rec.id) }
381. return { ok = true rows = editRowsOf(rec) }
382. }
383. static addToTimeline = (&timelineId, &showId) => {
384. let t = timelineById(timelineId)
385. if (t == null) { return { error = 'no such timeline' } }
386. if (showById(showId) == null) { return { error = 'no such title' } }
387. let order = []
388. for (sid of t.order) { order.push(sid) }
389. if (order.includes(showId)) { return { ok = true rows = editRowsOf(t) } }
390. order.push(showId)
391. return storeOrder(t, order)
392. }
393. static removeFromTimeline = (&timelineId, &showId) => {
394. let t = timelineById(timelineId)
395. if (t == null) { return { error = 'no such timeline' } }
396. let order = []
397. for (sid of t.order) { if (sid != showId) { order.push(sid) } }
398. return storeOrder(t, order)
399. }
400. // one place up (delta -1) or down (+1); at an end nothing changes
401. static moveInTimeline = (&timelineId, &showId, &delta) => {
402. let t = timelineById(timelineId)
403. if (t == null) { return { error = 'no such timeline' } }
404. let at = posOf(t.order, showId)
405. let to = at + (delta < 0 ? -1 : 1)
406. if (at < 0 || to < 0 || to >= t.order.length) { return { ok = true rows = editRowsOf(t) } }
407. let order = []
408. let i = 0
409. while (i < t.order.length) {
410. if (i == at) { order.push(t.order[to]) } else if (i == to) { order.push(t.order[at]) } else { order.push(t.order[i]) }
411. i = i + 1
412. }
413. return storeOrder(t, order)
414. }
415. static setTimelineFranchise = (&timelineId, franchiseId) => {
416. let t = timelineById(timelineId)
417. if (t == null) { return { error = 'no such timeline' } }
418. let fid = null
419. if (franchiseId != null && franchiseId != '') {
420. if (franchiseById(franchiseId) == null) { return { error = 'no such franchise' } }
421. fid = franchiseId
422. }
423. let rec = t
424. rec.franchise = fid
425. if (timelinesTable.update(rec.id, rec) == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
426. timelinesTable.persist()
427. return { ok = true chips = chipsOf(rec) }
428. }
429. // the editor's title search: our database (search.hl's index), the titles not in the timeline yet
430. static editSearch = (&timelineId, text) => {
431. let t = timelineById(timelineId)
432. let have = t != null && t.order != null ? t.order : []
433. let out = []
434. let r = dbSearch(text != null ? '' + text : '')
435. for (x of r.titles) {
436. let s = showById(x.id)
437. if (s != null && !have.includes(s.id)) { out.push({ id = s.id title = titleWithYear(s) posterUrl = posterUrlOf(s) typeLabel = s.type == 'series' ? 'Series' : 'Movie' }) }
438. }
439. return { text = text rows = out note = r.tooShort ? 'Type at least 2 letters.' : (out.length == 0 ? 'Nothing found.' : '') }
440. }
441. // the editor's timeline finder: by name, at most 30
442. static findTimelines = (&text) => {
443. let q = text != null ? ('' + text).trim().toLowerCase() : ''
444. let out = []
445. if (q.length < 2) { return out }
446. for (t of timelinesTable.find(null, null)) {
447. if (out.length < 30 && ('' + t.name).toLowerCase().includes(q)) {
448. let n = t.order != null ? t.order.length : 0
449. out.push({ id = t.id name = t.name href = '/timelines/' + t.slug + '/edit' countText = n == 1 ? '1 title' : n + ' titles' })
450. }
451. }
452. return out
453. }
455. // ---- THE SEED from TMDB's movie collections ----------------------------------------------------------------------------------
456. // the queue is a plain static list filled in place (a static cannot be reassigned; read through a field it was copied on every
457. // access — shortids.hl), worked off from `seed.pos`
458. static seedQueue = []
459. static checkedShows = {}
460. static collectionsDone = {}
461. static movieByTmdb = {}
462. static seedTries = {}
463. static seed = { built = false pos = 0 movies = 0 checked = 0 requests = 0 timelines = 0 titles = 0 small = 0 noCollection = 0 notFound = 0 errors = 0 retries = 0 }
465. static markChecked = (&showId, collection, why) => {
466. if (checkedShows[showId] == true) { return true }
467. checkedShows[showId] = true
468. seed.checked = seed.checked + 1
469. if (collectionChecksTable.put({ id = showId collection = collection why = why at = now() }) == null) {
470. console.log('collections: check of ' + showId + ' not stored: ' + collectionChecksTable.lastError())
471. }
472. return true
473. }
474. static seedPrepare = () => {
475. if (seed.built) { return seedQueue.length }
476. seed.built = true
477. ensureFranchises()
478. for (c of collectionChecksTable.find(null, null)) {
479. checkedShows[c.id] = true
480. if (c.collection != null) { collectionsDone['' + c.collection] = true }
481. }
482. for (t of timelinesTable.find(null, null)) { if (t.tmdbCollection != null) { collectionsDone['' + t.tmdbCollection] = true } }
483. for (s of showsTable.find(null, null)) {
484. if (s.type == 'movie' && s.tmdbId != null && s.adult != true) {
485. movieByTmdb['' + s.tmdbId] = s.id
486. if (checkedShows[s.id] != true) { seedQueue.push(s.id) }
487. }
488. }
489. seed.movies = seedQueue.length
490. return seedQueue.length
491. }
492. static seedLeft = () => { return seedQueue.length - seed.pos }
493. static seedStats = () => { return seed }
494. static seedPersist = () => {
495. collectionChecksTable.persist()
496. timelinesTable.persist()
497. return true
498. }
499. // a passing failure goes to the back of the queue, at most 2 more tries per start
500. static seedRetry = (&showId) => {
501. let n = seedTries[showId] != null ? seedTries[showId] : 0
502. if (n >= 2) { return false }
503. seedTries[showId] = n + 1
504. seedQueue.push(showId)
505. seed.retries = seed.retries + 1
506. return true
507. }
509. // ONE movie: → { requests (TMDB API requests made: what the pause counts), done, error }
510. static seedStep = () => {
511. let out = { requests = 0 done = false error = '' }
512. seedPrepare()
513. if (seed.pos >= seedQueue.length) { out.done = true return out }
514. let id = seedQueue[seed.pos]
515. seed.pos = seed.pos + 1
516. if (checkedShows[id] == true) { return out }
517. let show = showsTable.fetch(id)
518. if (show == null || show.adult == true || show.tmdbId == null) { return out }
519. out.requests = 1
520. seed.requests = seed.requests + 1
521. let d = tmdbGet('/movie/' + show.tmdbId)
522. if (d.failed != null) {
523. seed.errors = seed.errors + 1
524. out.error = show.title + ': ' + d.failed
525. if (d.status == 404) { seed.notFound = seed.notFound + 1 markChecked(id, null, 'TMDB 404') } else { seedRetry(id) }
526. return out
527. }
528. let c = d.belongs_to_collection
529. if (c == null || c.id == null) {
530. seed.noCollection = seed.noCollection + 1
531. markChecked(id, null, 'no collection')
532. return out
533. }
534. let cid = '' + c.id
535. if (collectionsDone[cid] == true) { markChecked(id, c.id, 'collection known') return out }
536. out.requests = 2
537. seed.requests = seed.requests + 1
538. let coll = tmdbGet('/collection/' + cid)
539. if (coll.failed != null || coll.parts == null) {
540. seed.errors = seed.errors + 1
541. out.error = show.title + ': collection ' + cid + ': ' + (coll.failed != null ? coll.failed : 'no parts')
542. if (coll.status == 404) { markChecked(id, c.id, 'collection 404') collectionsDone[cid] = true } else { seedRetry(id) }
543. return out
544. }
545. // the parts in release order (no date last), only the non-adult ones we have
546. let parts = []
547. for (p of coll.parts) {
548. let next = []
549. let done = false
550. let pd = dateOr(p.release_date)
551. for (x of parts) {
552. if (!done && pd != '' && (x.d == '' || pd < x.d)) { next.push({ p = p d = pd }) done = true }
553. next.push(x)
554. }
555. if (!done) { next.push({ p = p d = pd }) }
556. parts = next
557. }
558. let order = []
559. for (x of parts) {
560. let sid = x.p.adult == true ? null : movieByTmdb['' + x.p.id]
561. if (sid != null && !order.includes(sid)) { order.push(sid) }
562. }
563. collectionsDone[cid] = true
564. if (order.length >= 2) {
565. let name = textOr(coll.name) != null ? coll.name.trim() : (textOr(c.name) != null ? c.name.trim() : 'Collection ' + cid)
566. let rec = putTimeline(name, null, order, 'tmdb', c.id)
567. if (rec == null) {
568. seed.errors = seed.errors + 1
569. out.error = 'timeline "' + name + '" not stored: ' + timelinesTable.lastError()
570. } else {
571. seed.timelines = seed.timelines + 1
572. seed.titles = seed.titles + order.length
573. }
574. } else { seed.small = seed.small + 1 }
575. for (sid of order) { markChecked(sid, c.id, 'collection') }
576. markChecked(id, c.id, 'collection')
577. return out
578. }
579. static seedLine = () => {
580. return seed.pos + '/' + seedQueue.length + ' movies, checked=' + seed.checked + ' timelines=' + seed.timelines + ' titles=' + seed.titles + ' small=' + seed.small
581. + ' noCollection=' + seed.noCollection + ' notFound=' + seed.notFound + ' requests=' + seed.requests + ' errors=' + seed.errors + ' retries=' + seed.retries
582. }