tracker

21.1 KB

1. // lib/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' | 'seed'), tmdbCollection (TMDB collection id | null), orderKind
10. // ('in-universe' | 'release' | null: not said, tracker#40), created }
11. // storage/mpackdb/{franchises,timelines}.db (new tables; nothing in shows.db changes; the seed's collectionchecks.db is
12. // collections.hl's, the curated seed's franchiseseed.db franchiseseed.hl's)
13. //
14. // A TITLE MAY BE IN SEVERAL TIMELINES (Star Trek Prime and Kelvin, or a TMDB collection and a hand-made one): `byShow` (show
15. // @id → [timeline @id]) is built once at start (`ensureFranchises`, one scan of the timelines) and kept up to date by every
16. // edit — the show page's widget reads only its own timelines, never all of them.
17. //
18. // THE ORDER of a timeline is its in-world order (`order`, editable). The pages can sort it by RELEASE instead: a movie by its
19. // `release`, a SERIES by the release date of its LAST episode (the newest one already out; none out yet → the newest
20. // announced one; no episode dates at all → the series' own `release`). Titles without any date go last.
21. //
22. // PUBLIC LIKE THE OTHER LISTS (mission 054): the pages and the widget's prequel/sequel links show only titles with
23. // `adult == false` (shows.hl isPublicTitle); the order keeps them, they are just skipped.
24. //
25. // THE SEEDS: TMDB movie collections → timelines (collections.hl); the curated franchises of data/franchises.json, movies AND
26. // series (franchiseseed.hl, tracker#40) — both write through the functions here.
27. //
28. // ONE PROCESS PER STORAGE (hybriel#21): the tables are opened here, in the app's process only.
29. import { MPackDB } from 'hl:mpackdb'
30. import { env } from 'hl:proc'
31. import { now } from 'hl:time'
32. import { storageDir, newId, todayStr, dateOr, firstOf } from './util.hl'
33. import { showById, seasonsOfShow, episodesOfSeason, titleWithYear, posterUrlOf, isPublicTitle, titlePath } from './shows.hl'
34. import { userOfSession } from './users.hl'
35. import { dbSearch } from './search.hl'
36. import { slugBaseOf } from './search-helpers.hl'
38. static franchisesTable = new MPackDB(file = storageDir + '/franchises.db', primaryKey = '@id', indexes = ['!slug'])
39. static timelinesTable = new MPackDB(file = storageDir + '/timelines.db', primaryKey = '@id', indexes = ['!slug'])
41. // a name as typed: trimmed, null when there is none (the editor's names and summaries)
42. static trimmedOr = (&v) => { return v != null && hlTypeName(v) == 'String' && v.trim() != '' ? v.trim() : null }
44. // ---- who may edit: the creator (ident short id az5b2); TRACKER_EDITORS = a comma list of ident ids (the gate sets its own) ----
45. static editorIds = () => {
46. v = env('TRACKER_EDITORS')
47. raw = v != null && v.trim() != '' ? v : 'az5b2'
48. out = []
49. for (p of raw.split(',')) { if (p.trim() != '') { out.push(p.trim()) } }
50. return out
51. }
52. static editors = editorIds()
53. static isEditorSession = (&session) => {
54. if (session == null || hlTypeName(session) != 'Instance') { return false }
55. u = userOfSession(session)
56. return u != null && u.identity != null && editors.includes(u.identity)
57. }
59. // 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)
60. static posOf = (&list, &x) => {
61. let i = 0
62. while (i < list.length) {
63. if (list[i] == x) { return i }
64. i = i + 1
65. }
66. return -1
67. }
69. // ---- slugs: "Star Trek" → "Star-Trek" (the shows' urlSegment form, search-helpers.hl slugBaseOf; none → 'timeline') -------
70. static freeSlug = (&table, &name) => {
71. base = slugBaseOf(name, 'timeline')
72. // 'edit' is the editor's own address (/franchises/edit)
73. if (firstOf(table.find('slug', base)) == null && base != 'edit') { return base }
74. let n = 2
75. while (firstOf(table.find('slug', base + '-' + n)) != null) { n = n + 1 }
76. return base + '-' + n
77. }
79. static franchiseBySlug = (&slug) => {
80. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
81. return firstOf(franchisesTable.find('slug', slug))
82. }
83. static timelineBySlug = (&slug) => {
84. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
85. return firstOf(timelinesTable.find('slug', slug))
86. }
87. static franchiseById = (&id) => { return id == null || hlTypeName(id) != 'String' || id == '' ? null : franchisesTable.fetch(id) }
88. static timelineById = (&id) => { return id == null || hlTypeName(id) != 'String' || id == '' ? null : timelinesTable.fetch(id) }
90. // ---- byShow: show @id → [timeline @id] ------------------------------------------------------------------------------------
91. static byShow = {}
92. static state = { built = false timelines = 0 ms = 0 }
93. static indexAdd = (&showId, &timelineId) => {
94. let l = byShow[showId]
95. if (l == null) { l = [] }
96. if (!l.includes(timelineId)) { l.push(timelineId) }
97. byShow[showId] = l
98. return true
99. }
100. static indexRemove = (&showId, &timelineId) => {
101. l = byShow[showId]
102. if (l == null) { return true }
103. out = []
104. for (x of l) { if (x != timelineId) { out.push(x) } }
105. byShow[showId] = out
106. return true
107. }
108. static ensureFranchises = () => {
109. if (state.built) { return true }
110. state.built = true
111. t0 = now()
112. let n = 0
113. for (t of timelinesTable.find(null, null)) {
114. n = n + 1
115. if (t.order != null) { for (sid of t.order) { indexAdd(sid, t.id) } }
116. }
117. state.timelines = n
118. state.ms = now() - t0
119. console.log('franchises: ' + n + ' timelines, ' + franchisesTable.count() + ' franchises (' + state.ms + ' ms)')
120. return true
121. }
122. static timelineIdsOfShow = (&showId) => {
123. ensureFranchises()
124. l = byShow[showId]
125. return l != null ? l : []
126. }
128. // ---- a title as the pages list it ------------------------------------------------------------------------------------------
129. // the date the release sort uses: a movie's release; a series' LAST episode (newest out ≤ today, else newest announced, else
130. // its own release)
131. static releaseKeyOf = (&show) => {
132. if (show.type != 'series') { return dateOr(show.release) }
133. today = todayStr()
134. let lastOut = ''
135. let lastAny = ''
136. for (s of seasonsOfShow(show)) {
137. for (e of episodesOfSeason(s)) {
138. let d = dateOr(e.release)
139. if (d != '') {
140. if (d > lastAny) { lastAny = d }
141. if (d <= today && d > lastOut) { lastOut = d }
142. }
143. }
144. }
145. if (lastOut != '') { return lastOut }
146. if (lastAny != '') { return lastAny }
147. return dateOr(show.release)
148. }
149. static itemOf = (&show, pos) => {
150. series = show.type == 'series'
151. d = releaseKeyOf(show)
152. label = d == '' ? 'no date' : (series ? 'last episode ' + d : d)
153. return { id = show.id pos = pos title = titleWithYear(show) href = titlePath(show) posterUrl = posterUrlOf(show)
154. kind = series ? 'Series' : 'Movie' date = d dateLabel = label }
155. }
156. // the public titles of a timeline, in its order (`pos` = the place in the in-world order, 1-based)
157. static itemsOf = (&t) => {
158. out = []
159. let pos = 0
160. if (t.order == null) { return out }
161. for (sid of t.order) {
162. let s = showById(sid)
163. if (s != null && isPublicTitle(s)) {
164. pos = pos + 1
165. out.push(itemOf(s, pos))
166. }
167. }
168. return out
169. }
170. // release order: oldest first, no date last; equal dates keep the timeline order (a stable insertion)
171. static byReleaseOf = (&items) => {
172. let out = []
173. for (it of items) {
174. let next = []
175. let done = false
176. for (x of out) {
177. if (!done && it.date != '' && (x.date == '' || it.date < x.date)) { next.push(it) done = true }
178. next.push(x)
179. }
180. if (!done) { next.push(it) }
181. out = next
182. }
183. return out
184. }
185. // tracker#40: what the timeline's own order is, said beside its count ("23 titles · in-universe order"); none when not known
186. static orderNoteOf = (&t) => {
187. if (t.orderKind == 'in-universe') { return ' · in-universe order' }
188. if (t.orderKind == 'release') { return ' · release order' }
189. return ''
190. }
191. static blockOf = (&t) => {
192. items = itemsOf(t)
193. return { id = t.id name = t.name slug = t.slug href = '/timelines/' + t.slug items = items byRelease = byReleaseOf(items)
194. countText = (items.length == 1 ? '1 title' : items.length + ' titles') + orderNoteOf(t) first = items.length > 0 ? byReleaseOf(items)[0].date : '' }
195. }
197. // ---- the pages -------------------------------------------------------------------------------------------------------------
198. // /franchises: every franchise (name, how many timelines), then the timelines WITHOUT one (TMDB's collections, by name)
199. static byNameOf = (&rows) => {
200. let out = []
201. for (r of rows) {
202. let next = []
203. let done = false
204. let k = r.sortName
205. for (x of out) {
206. if (!done && k < x.sortName) { next.push(r) done = true }
207. next.push(x)
208. }
209. if (!done) { next.push(r) }
210. out = next
211. }
212. return out
213. }
214. static franchiseIndex = () => {
215. counts = {}
216. loose = []
217. for (t of timelinesTable.find(null, null)) {
218. let n = t.order != null ? t.order.length : 0
219. if (t.franchise != null && t.franchise != '') { counts[t.franchise] = (counts[t.franchise] != null ? counts[t.franchise] : 0) + 1 }
220. 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() }) }
221. }
222. fr = []
223. for (f of franchisesTable.find(null, null)) {
224. let c = counts[f.id] != null ? counts[f.id] : 0
225. fr.push({ id = f.id name = f.name href = '/franchises/' + f.slug summary = f.summary != null ? f.summary : ''
226. countText = c == 1 ? '1 timeline' : c + ' timelines' sortName = ('' + f.name).toLowerCase() })
227. }
228. return { franchises = byNameOf(fr) timelines = byNameOf(loose) }
229. }
231. // /franchises/<slug>: the franchise and its timelines (oldest first by their first release) — or null
232. static franchisePage = (slug) => {
233. f = franchiseBySlug(slug)
234. if (f == null) { return null }
235. let blocks = []
236. for (t of timelinesTable.find(null, null)) {
237. if (t.franchise == f.id) {
238. let b = blockOf(t)
239. let next = []
240. let done = false
241. for (x of blocks) {
242. if (!done && b.first != '' && (x.first == '' || b.first < x.first)) { next.push(b) done = true }
243. next.push(x)
244. }
245. if (!done) { next.push(b) }
246. blocks = next
247. }
248. }
249. return { kind = 'franchise' name = f.name slug = f.slug summary = f.summary != null ? f.summary : '' franchiseName = '' franchiseHref = '' blocks = blocks editHref = '' }
250. }
251. // /timelines/<slug>: one timeline, its franchise above it — or null
252. static timelinePage = (slug) => {
253. t = timelineBySlug(slug)
254. if (t == null) { return null }
255. f = franchiseById(t.franchise)
256. return { kind = 'timeline' name = t.name slug = t.slug summary = '' franchiseName = f != null ? f.name : '' franchiseHref = f != null ? '/franchises/' + f.slug : ''
257. blocks = [blockOf(t)] editHref = '/timelines/' + t.slug + '/edit' }
258. }
260. // ---- the widget on a show / movie page: one per timeline the title is in ----------------------------------------------------
261. // { id, name, href, hasFranchise, franchiseName, franchiseHref, hasPrev, noPrev, prevHref, prevTitle, hasNext, noNext, … }:
262. // prequel / sequel = the nearest PUBLIC title before / after this one in the timeline's order
263. static widgetsOf = (&showId) => {
264. out = []
265. if (showId == null) { return out }
266. for (tid of timelineIdsOfShow(showId)) {
267. let t = timelinesTable.fetch(tid)
268. if (t != null && t.order != null && t.order.includes(showId)) {
269. let at = posOf(t.order, showId)
270. let prev = null
271. let i = at - 1
272. while (prev == null && i >= 0) {
273. let s = showById(t.order[i])
274. if (s != null && isPublicTitle(s)) { prev = s }
275. i = i - 1
276. }
277. let next = null
278. let j = at + 1
279. while (next == null && j < t.order.length) {
280. let s = showById(t.order[j])
281. if (s != null && isPublicTitle(s)) { next = s }
282. j = j + 1
283. }
284. let f = franchiseById(t.franchise)
285. out.push({ id = t.id name = t.name href = '/timelines/' + t.slug
286. hasFranchise = f != null franchiseName = f != null ? f.name : '' franchiseHref = f != null ? '/franchises/' + f.slug : ''
287. hasPrev = prev != null noPrev = prev == null prevHref = prev != null ? titlePath(prev) : '' prevTitle = prev != null ? titleWithYear(prev) : ''
288. hasNext = next != null noNext = next == null nextHref = next != null ? titlePath(next) : '' nextTitle = next != null ? titleWithYear(next) : '' })
289. }
290. }
291. return out
292. }
294. // ---- the editor (the creator only — every caller checks isEditorSession first) ----------------------------------------------
295. static createFranchise = (name, summary) => {
296. n = trimmedOr(name)
297. if (n == null || n.length > 120) { return { error = 'a franchise needs a name (at most 120 characters)' } }
298. s = trimmedOr(summary)
299. rec = { id = newId() name = n slug = freeSlug(franchisesTable, n) shortId = null summary = s != null ? s : '' created = now() }
300. if (franchisesTable.put(rec) == null) { return { error = 'not stored: ' + franchisesTable.lastError() } }
301. franchisesTable.persist()
302. console.log('franchises: new franchise "' + n + '" /franchises/' + rec.slug)
303. return { ok = true slug = rec.slug id = rec.id }
304. }
306. // a new timeline (the editor's, the collection seed's with its collection id, the curated seed's with its order kind)
307. static putTimeline = (name, &franchiseId, order, source, &collection, &orderKind) => {
308. rec = { id = newId() name = name slug = freeSlug(timelinesTable, name) franchise = franchiseId order = order source = source
309. tmdbCollection = collection orderKind = orderKind created = now() }
310. if (timelinesTable.put(rec) == null) { return null }
311. for (sid of order) { indexAdd(sid, rec.id) }
312. return rec
313. }
314. static createTimeline = (&name) => {
315. n = trimmedOr(name)
316. if (n == null || n.length > 120) { return { error = 'a timeline needs a name (at most 120 characters)' } }
317. rec = putTimeline(n, null, [], 'editor', null, null)
318. if (rec == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
319. timelinesTable.persist()
320. console.log('franchises: new timeline "' + n + '" /timelines/' + rec.slug)
321. return { ok = true slug = rec.slug id = rec.id }
322. }
324. // the editor's view of one timeline: every title in its order (adult ones too — the creator sees what is there)
325. static editRowsOf = (&t) => {
326. out = []
327. if (t == null || t.order == null) { return out }
328. let i = 0
329. last = t.order.length - 1
330. for (sid of t.order) {
331. let s = showById(sid)
332. if (s != null) {
333. out.push({ id = s.id pos = i + 1 title = titleWithYear(s) posterUrl = posterUrlOf(s) typeLabel = s.type == 'series' ? 'Series' : 'Movie'
334. upClass = i == 0 ? 'quiet mv off' : 'quiet mv' downClass = i == last ? 'quiet mv off' : 'quiet mv' })
335. }
336. i = i + 1
337. }
338. return out
339. }
340. static chipsOf = (&t) => {
341. out = [{ id = '' name = 'None' cls = t == null || t.franchise == null || t.franchise == '' ? 'chip on' : 'chip' }]
342. list = []
343. 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() }) }
344. for (c of byNameOf(list)) { out.push(c) }
345. return out
346. }
347. static editPageOf = (slug) => {
348. t = timelineBySlug(slug)
349. if (t == null) { return { found = false id = '' name = '' slug = '' viewHref = '' rows = [] chips = [] } }
350. return { found = true id = t.id name = t.name slug = t.slug viewHref = '/timelines/' + t.slug rows = editRowsOf(t) chips = chipsOf(t) }
351. }
353. static storeOrder = (t, order) => {
354. old = t.order != null ? t.order : []
355. rec = t
356. rec.order = order
357. if (timelinesTable.update(rec.id, rec) == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
358. timelinesTable.persist()
359. for (sid of old) { if (!order.includes(sid)) { indexRemove(sid, rec.id) } }
360. for (sid of order) { indexAdd(sid, rec.id) }
361. return { ok = true rows = editRowsOf(rec) }
362. }
363. // tracker#31 (merge.hl): a duplicate title merged into its keeper — in every timeline that lists it, the keeper takes its place
364. // (once: a timeline that already lists the keeper just drops it) → the number of timelines changed
365. static titleMerged = (&fromId, &toId) => {
366. ensureFranchises()
367. let n = 0
368. tids = []
369. if (byShow[fromId] != null) { for (x of byShow[fromId]) { tids.push(x) } }
370. for (tid of tids) {
371. let t = timelinesTable.fetch(tid)
372. if (t != null && t.order != null) {
373. let order = []
374. for (sid of t.order) {
375. let want = sid == fromId ? toId : sid
376. if (!order.includes(want)) { order.push(want) }
377. }
378. let r = storeOrder(t, order)
379. if (r.error != null) { console.log('merge: timeline ' + tid + ': ' + r.error) } else { n = n + 1 }
380. }
381. }
382. return n
383. }
384. static addToTimeline = (&timelineId, &showId) => {
385. t = timelineById(timelineId)
386. if (t == null) { return { error = 'no such timeline' } }
387. if (showById(showId) == null) { return { error = 'no such title' } }
388. order = []
389. for (sid of t.order) { order.push(sid) }
390. if (order.includes(showId)) { return { ok = true rows = editRowsOf(t) } }
391. order.push(showId)
392. return storeOrder(t, order)
393. }
394. static removeFromTimeline = (&timelineId, &showId) => {
395. t = timelineById(timelineId)
396. if (t == null) { return { error = 'no such timeline' } }
397. order = []
398. for (sid of t.order) { if (sid != showId) { order.push(sid) } }
399. return storeOrder(t, order)
400. }
401. // one place up (delta -1) or down (+1); at an end nothing changes
402. static moveInTimeline = (&timelineId, &showId, &delta) => {
403. t = timelineById(timelineId)
404. if (t == null) { return { error = 'no such timeline' } }
405. at = posOf(t.order, showId)
406. to = at + (delta < 0 ? -1 : 1)
407. if (at < 0 || to < 0 || to >= t.order.length) { return { ok = true rows = editRowsOf(t) } }
408. order = []
409. let i = 0
410. while (i < t.order.length) {
411. if (i == at) { order.push(t.order[to]) } else if (i == to) { order.push(t.order[at]) } else { order.push(t.order[i]) }
412. i = i + 1
413. }
414. return storeOrder(t, order)
415. }
416. static setTimelineFranchise = (&timelineId, franchiseId) => {
417. t = timelineById(timelineId)
418. if (t == null) { return { error = 'no such timeline' } }
419. let fid = null
420. if (franchiseId != null && franchiseId != '') {
421. if (franchiseById(franchiseId) == null) { return { error = 'no such franchise' } }
422. fid = franchiseId
423. }
424. rec = t
425. rec.franchise = fid
426. if (timelinesTable.update(rec.id, rec) == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
427. timelinesTable.persist()
428. return { ok = true chips = chipsOf(rec) }
429. }
430. // the editor's title search: our database (search.hl's index), the titles not in the timeline yet
431. static editSearch = (&timelineId, text) => {
432. t = timelineById(timelineId)
433. have = t != null && t.order != null ? t.order : []
434. out = []
435. r = dbSearch(text != null ? '' + text : '')
436. for (x of r.titles) {
437. let s = showById(x.id)
438. if (s != null && !have.includes(s.id)) { out.push({ id = s.id title = titleWithYear(s) posterUrl = posterUrlOf(s) typeLabel = s.type == 'series' ? 'Series' : 'Movie' }) }
439. }
440. return { text = text rows = out note = r.tooShort ? 'Type at least 2 letters.' : (out.length == 0 ? 'Nothing found.' : '') }
441. }
442. // the editor's timeline finder: by name, at most 30
443. static findTimelines = (&text) => {
444. q = text != null ? ('' + text).trim().toLowerCase() : ''
445. out = []
446. if (q.length < 2) { return out }
447. for (t of timelinesTable.find(null, null)) {
448. if (out.length < 30 && ('' + t.name).toLowerCase().includes(q)) {
449. let n = t.order != null ? t.order.length : 0
450. out.push({ id = t.id name = t.name href = '/timelines/' + t.slug + '/edit' countText = n == 1 ? '1 title' : n + ' titles' })
451. }
452. }
453. return out
454. }
456. // ---- the curated seed's reads and writes (franchiseseed.hl, tracker#40) ----------------------------------------------------
457. // a franchise / timeline by its name, any case — or null (the creator's own of that name is adopted by the seed, never doubled)
458. static franchiseByName = (&name) => {
459. q = ('' + name).toLowerCase()
460. let hit = null
461. for (f of franchisesTable.find(null, null)) { if (hit == null && ('' + f.name).toLowerCase() == q) { hit = f } }
462. return hit
463. }
464. static timelineByName = (&name) => {
465. q = ('' + name).toLowerCase()
466. let hit = null
467. for (t of timelinesTable.find(null, null)) { if (hit == null && ('' + t.name).toLowerCase() == q) { hit = t } }
468. return hit
469. }
470. // the timeline the collection seed made from TMDB collection `collection`, or null
471. static timelineOfCollection = (&collection) => {
472. let hit = null
473. for (t of timelinesTable.find(null, null)) { if (hit == null && t.tmdbCollection != null && '' + t.tmdbCollection == '' + collection) { hit = t } }
474. return hit
475. }
476. // a seeded timeline rewritten (the data file changed, or titles were imported since): its order and franchise in one update
477. static storeSeeded = (t, order, &franchiseId) => {
478. old = t.order != null ? t.order : []
479. rec = t
480. rec.order = order
481. rec.franchise = franchiseId
482. if (timelinesTable.update(rec.id, rec) == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
483. for (sid of old) { if (!order.includes(sid)) { indexRemove(sid, rec.id) } }
484. for (sid of order) { indexAdd(sid, rec.id) }
485. return { ok = true }
486. }
487. static persistFranchises = () => {
488. franchisesTable.persist()
489. timelinesTable.persist()
490. return true
491. }