tracker

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