tracker

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