tracker

24.0 KB

1. // lib/merge.hl — DUPLICATE TITLES MERGED (tracker.worldapi.org#31, mission 026). The architect: "Every TMDB title exists once in our
2. // data; watches, follows and seasons all hang on that one record."
3. //
4. // WHERE THEY CAME FROM: the old tracker. On the live copy (2026-10-03) 68 type+tmdbId pairs were held by 157 records — every one
5. // of them a migrated row (Mongo `oldId`, created 2022–2023 in runs of consecutive ids: Archive 81 ×6, Peripheral ×4, Ally
6. // McBeal ×2 …); not one was made by this app. The app's two creating paths look the title up first (search.hl importTitle,
7. // people.hl fillStep → search.hl titleIdByTmdb) and their records carry `oldId = tmdb-<tv|movie>-<id>`, which the table's
8. // `!oldId` UNIQUE index refuses twice. Seasons the same way: 449 migrated seasons name a title that does not list them (the old
9. // tracker showed a title's seasons by query); the daily sync goes by the list, so it made a SECOND season where TMDB has that
10. // number (Reacher: the creator's S3 watches sat on the unlisted migrated S3, the page showed the sync's empty S3).
11. //
12. // THE REPAIR (in the app, on its own clock like the short-id backfill — no TMDB, one item per tick; jobs.hl `mergeTick`):
13. // 1. per duplicate group: the KEEPER = the record with follows/watches (most first), else the one with its old short id
14. // (shortids.hl), else the oldest (the Mongo id's time, else `imported`). Into it, from every other record:
15. // follows + watches (a user who already has the keeper's: the moved row gets `target`/`show` null + `mergedInto` = the
16. // row it repeats — no row is deleted), seasons the keeper lacks (moved: `show` = keeper), seasons it has (merged
17. // episode by episode, below), cast + crew entries it lacks, the persons' credits, the timelines (franchises.hl
18. // titleMerged), empty text/id fields, the poster file if the keeper has none. The keeper takes the plain slug of its
19. // title when a duplicate held it (Archive 81: "Archive-82" → "Archive-81"; its former slug in `oldSlugs`).
20. // The other record becomes a TOMBSTONE (shows.hl): `mergedInto`, `mergedAt`, `mergedTmdbId` (tmdbId null), `mergedSeasons`
21. // (seasons []). Its slug and short id lead to the keeper (shows.hl movedSlugs → project.hl 301, shortids.hl shortIdPath).
22. // 2. per title with seasons that name it but are not in its list (STRAY seasons): such a season with a listed TWIN (same
23. // number) is merged into the twin; one without is LINKED into the list only when someone watched it or one of its episodes
24. // (recorded in the title's `linkedSeasons`). The other strays stay as they are: linking all 393 with episodes on the live
25. // copy put 1,091 never-watched old talk-show episodes on the creator's /my/unwatched (1,273 → 2,364 rows). When the sync
26. // later makes a season of that number, the next start merges the stray into it.
27. // MERGING A SEASON INTO ITS TWIN: the season's watches → the twin; each episode: the twin's episode of that number gets its
28. // watches (the episode becomes `mergedInto` = that one), an episode the twin lacks MOVES into the twin. The season gets
29. // `mergedInto` = the twin, `mergedEpisodes` (episodes []).
30. // RESUMES: the queue is built at start from what is still duplicated / stray — a restart in the middle goes on (a half-moved
31. // group picks the same keeper again: it already has the moved follows/watches). A third start: "merge: nothing to do".
32. // Persisted every 10 items and at the end. Log: start, one line per tombstone and per repaired title, done.
33. //
34. // ONE PROCESS PER STORAGE (hybriel#21): the tables are the app's own. Ids are unique (count-duplicate-ids), so update() is safe
35. // (hybriel#113, sync.hl).
36. import { now } from 'hl:time'
37. import { readBytes, writeFile, exists } from 'hl:fs'
38. import { postersDir, hexDigits, listOr } from './util.hl'
39. import { showsTable, seasonsTable, episodesTable, personsTable, noteSlugsOf, forgetEpisodeKey, posterName } from './shows.hl'
40. import { followsTable } from './follows.hl'
41. import { watchesTable, forgetUserWatches } from './watches.hl'
42. import { searchTitleMerged } from './search.hl'
43. import { slugBaseOf } from './search-helpers.hl'
44. import { refreshCatalogShow } from './catalog.hl'
45. import { hasOldShortId } from './shortids.hl'
46. import { titleMerged } from './franchises.hl'
48. // the empty fields of a keeper a duplicate may fill (never ids, slugs, flags or the job markers)
49. static fillFields = ['summary', 'tmdbSummary', 'tvmazeSummary', 'imdbId', 'tvdbId', 'tvmzId', 'homepage', 'tagline', 'release', 'year', 'language',
50. 'migratedSummary', 'migratedTitle', 'migratedGenres', 'migratedHomepage', 'migratedTagline']
52. // the work, [{ kind ('title' | 'seasons'), ids (a group's record ids) | id (a title) }], worked off from `run.pos`; filled in place
53. // (a static list is never reassigned)
54. static queue = []
55. // watch id lists by target, follow id lists by show, person ids by the duplicates' ids they credit, seasons naming a title that
56. // does not list them — built once by mergePrepare, kept up to date by the moves (flat maps, written key by key)
57. static watchIds = {}
58. static followIds = {}
59. static creditedBy = {}
60. static strays = {}
61. static seasonsByDup = {}
62. static run = { built = false pos = 0 groups = 0 records = 0 strayTitles = 0 ms = 0 }
63. static totals = { groups = 0 tombstones = 0 follows = 0 followRepeats = 0 watches = 0 watchRepeats = 0 seasonsMoved = 0 seasonsMerged = 0
64. seasonsLinked = 0 episodesMoved = 0 episodesMerged = 0 cast = 0 people = 0 timelines = 0 slugs = 0 posters = 0 fields = 0 titles = 0 }
66. static isEmpty = (&v) => { return v == null || (hlTypeName(v) == 'String' && v.trim() == '') }
68. // ---- the queue ------------------------------------------------------------------------------------------------------------
69. // one scan of shows, seasons, follows, watches and persons: the duplicate groups, the titles with stray seasons, the indexes
70. static mergePrepare = () => {
71. if (run.built) { return queue.length }
72. run.built = true
73. t0 = now()
74. byKey = {}
75. order = []
76. listedBy = {}
77. for (s of showsTable.find(null, null)) {
78. if (s.mergedInto == null) {
79. for (x of listOr(s.seasons)) { listedBy[x] = s.id }
80. if (s.tmdbId != null) {
81. let k = s.type + ':' + s.tmdbId
82. if (byKey[k] == null) {
83. byKey[k] = [s.id]
84. order.push(k)
85. } else { byKey[k].push(s.id) }
86. }
87. }
88. }
89. dup = {}
90. for (k of order) {
91. let ids = byKey[k]
92. if (ids.length > 1) {
93. queue.push({ kind = 'title' key = k ids = ids })
94. run.groups = run.groups + 1
95. run.records = run.records + ids.length
96. for (id of ids) { dup[id] = true }
97. }
98. }
99. for (w of watchesTable.find(null, null)) {
100. if (w.target != null) { if (watchIds[w.target] == null) { watchIds[w.target] = [w.id] } else { watchIds[w.target].push(w.id) } }
101. }
102. // seasons: a duplicate's (all of them, listed or not) and the stray ones (naming a live title that does not list them)
103. listedNum = {}
104. strayList = []
105. for (x of seasonsTable.find(null, null)) {
106. if (x.show != null && x.mergedInto == null) {
107. if (dup[x.show] == true) {
108. if (seasonsByDup[x.show] == null) { seasonsByDup[x.show] = [x.id] } else { seasonsByDup[x.show].push(x.id) }
109. }
110. if (listedBy[x.id] != null) { listedNum[listedBy[x.id] + '#' + x.seasonNumber] = true }
111. else { strayList.push({ id = x.id show = x.show n = x.seasonNumber watched = hasWatches(x) }) }
112. }
113. }
114. // a stray season is work when it has a listed twin or watches; its title must be live and no duplicate (a duplicate's seasons
115. // go with its group)
116. strayShows = []
117. for (st of strayList) {
118. if (dup[st.show] != true && (st.watched || listedNum[st.show + '#' + st.n] == true)) {
119. if (strays[st.show] == null) {
120. strays[st.show] = [st.id]
121. strayShows.push(st.show)
122. } else { strays[st.show].push(st.id) }
123. }
124. }
125. for (id of strayShows) {
126. let s = showsTable.fetch(id)
127. if (s != null && s.mergedInto == null) {
128. queue.push({ kind = 'seasons' id = id })
129. run.strayTitles = run.strayTitles + 1
130. }
131. }
132. if (queue.length > 0) {
133. for (f of followsTable.find(null, null)) {
134. if (f.show != null) { if (followIds[f.show] == null) { followIds[f.show] = [f.id] } else { followIds[f.show].push(f.id) } }
135. }
136. if (run.groups > 0) {
137. for (p of personsTable.find(null, null)) {
138. if (p.shows != null) {
139. for (c of p.shows) {
140. if (c != null && c.show != null && dup[c.show] == true) {
141. if (creditedBy[c.show] == null) { creditedBy[c.show] = [p.id] } else if (!creditedBy[c.show].includes(p.id)) { creditedBy[c.show].push(p.id) }
142. }
143. }
144. }
145. }
146. }
147. }
148. run.ms = now() - t0
149. return queue.length
150. }
151. // anyone's watch on the season or one of its episodes (watchIds is built)
152. static hasWatches = (&season) => {
153. if (watchIds[season.id] != null && watchIds[season.id].length > 0) { return true }
154. for (eid of listOr(season.episodes)) { if (watchIds[eid] != null && watchIds[eid].length > 0) { return true } }
155. return false
156. }
157. static mergeLeft = () => { return queue.length - run.pos }
158. static mergeStats = () => { return run }
159. static mergeTotals = () => { return totals }
160. static mergeLine = () => {
161. t = totals
162. return 'groups=' + t.groups + ' tombstones=' + t.tombstones + ' follows=' + t.follows + ' followRepeats=' + t.followRepeats + ' watches=' + t.watches
163. + ' watchRepeats=' + t.watchRepeats + ' seasonsMoved=' + t.seasonsMoved + ' seasonsMerged=' + t.seasonsMerged + ' seasonsLinked=' + t.seasonsLinked
164. + ' episodesMoved=' + t.episodesMoved + ' episodesMerged=' + t.episodesMerged + ' cast=' + t.cast + ' people=' + t.people + ' timelines=' + t.timelines
165. + ' slugs=' + t.slugs + ' posters=' + t.posters + ' fields=' + t.fields + ' strayTitles=' + t.titles
166. }
167. static persistMerge = () => {
168. showsTable.persist()
169. seasonsTable.persist()
170. episodesTable.persist()
171. followsTable.persist()
172. watchesTable.persist()
173. personsTable.persist()
174. return true
175. }
177. // ---- moving user data ------------------------------------------------------------------------------------------------------
178. // every watch of `fromId` → `toId` (an episode, season or movie id); a user who already has a watch on `toId` keeps that one and
179. // the moved row is parked (target null, `mergedInto` = the row it repeats). Every moved row keeps where it was (`mergedTarget`).
180. static moveWatches = (&fromId, &toId) => {
181. if (watchIds[fromId] == null) { return 0 }
182. ids = []
183. for (x of watchIds[fromId]) { ids.push(x) }
184. mine = {}
185. if (watchIds[toId] != null) {
186. for (x of watchIds[toId]) {
187. let w = watchesTable.fetch(x)
188. if (w != null && w.target == toId) { mine[w.user] = w.id }
189. }
190. }
191. moved = []
192. let n = 0
193. for (wid of ids) {
194. let w = watchesTable.fetch(wid)
195. if (w != null && w.target == fromId) {
196. let x = w
197. x.mergedTarget = fromId
198. if (mine[x.user] != null) {
199. x.target = null
200. x.mergedInto = mine[x.user]
201. totals.watchRepeats = totals.watchRepeats + 1
202. } else {
203. x.target = toId
204. mine[x.user] = x.id
205. moved.push(x.id)
206. totals.watches = totals.watches + 1
207. }
208. if (watchesTable.update(x.id, x) == null) { console.log('merge: watch ' + x.id + ' not stored: ' + watchesTable.lastError()) } else { n = n + 1 }
209. forgetUserWatches(x.user)
210. }
211. }
212. watchIds[fromId] = []
213. if (moved.length > 0) {
214. if (watchIds[toId] == null) { watchIds[toId] = moved } else { for (x of moved) { watchIds[toId].push(x) } }
215. }
216. return n
217. }
218. // every follow of title `fromId` → `toId`, the same way (`mergedShow` = where it was)
219. static moveFollows = (&fromId, &toId) => {
220. if (followIds[fromId] == null) { return 0 }
221. ids = []
222. for (x of followIds[fromId]) { ids.push(x) }
223. mine = {}
224. if (followIds[toId] != null) {
225. for (x of followIds[toId]) {
226. let f = followsTable.fetch(x)
227. if (f != null && f.show == toId) { mine[f.user] = f.id }
228. }
229. }
230. moved = []
231. for (fid of ids) {
232. let f = followsTable.fetch(fid)
233. if (f != null && f.show == fromId) {
234. let x = f
235. x.mergedShow = fromId
236. if (mine[x.user] != null) {
237. x.show = null
238. x.mergedInto = mine[x.user]
239. totals.followRepeats = totals.followRepeats + 1
240. } else {
241. x.show = toId
242. mine[x.user] = x.id
243. moved.push(x.id)
244. totals.follows = totals.follows + 1
245. }
246. if (followsTable.update(x.id, x) == null) { console.log('merge: follow ' + x.id + ' not stored: ' + followsTable.lastError()) }
247. }
248. }
249. followIds[fromId] = []
250. if (moved.length > 0) {
251. if (followIds[toId] == null) { followIds[toId] = moved } else { for (x of moved) { followIds[toId].push(x) } }
252. }
253. return moved.length
254. }
256. // ---- seasons -------------------------------------------------------------------------------------------------------------------
257. // season `x` into its twin `twinId` of title `titleId` (see the top) → the episode ids the twin gained
258. static mergeSeasonInto = (&seasonId, &twinId, &titleId) => {
259. x = seasonsTable.fetch(seasonId)
260. twin = seasonsTable.fetch(twinId)
261. if (x == null || twin == null || x.mergedInto != null) { return [] }
262. moveWatches(x.id, twin.id)
263. byNum = {}
264. for (eid of listOr(twin.episodes)) {
265. let e = episodesTable.fetch(eid)
266. if (e != null) { byNum['' + e.episodeNumber] = e.id }
267. }
268. gained = []
269. tid = twin.id
270. for (eid of listOr(x.episodes)) {
271. let e = episodesTable.fetch(eid)
272. if (e != null && e.mergedInto == null) {
273. let other = byNum['' + e.episodeNumber]
274. let y = e
275. if (other != null && other != e.id) {
276. moveWatches(e.id, other)
277. y.mergedInto = other
278. totals.episodesMerged = totals.episodesMerged + 1
279. } else if (other == null) {
280. y.movedFrom = { show = e.show season = e.season }
281. y.show = titleId
282. y.season = tid
283. byNum['' + e.episodeNumber] = e.id
284. gained.push(e.id)
285. totals.episodesMoved = totals.episodesMoved + 1
286. }
287. if (episodesTable.update(y.id, y) == null) { console.log('merge: episode ' + y.id + ' not stored: ' + episodesTable.lastError()) }
288. forgetEpisodeKey(y.id)
289. }
290. }
291. if (gained.length > 0) {
292. tw = seasonsTable.fetch(tid)
293. eps = listOr(tw.episodes)
294. for (g of gained) { eps.push(g) }
295. tw.episodes = eps
296. if (seasonsTable.update(tw.id, tw) == null) { console.log('merge: season ' + tw.id + ' not stored: ' + seasonsTable.lastError()) }
297. }
298. done = seasonsTable.fetch(seasonId)
299. done.mergedInto = tid
300. done.mergedAt = now()
301. done.mergedEpisodes = listOr(done.episodes)
302. done.episodes = []
303. if (seasonsTable.update(done.id, done) == null) { console.log('merge: season ' + done.id + ' not stored: ' + seasonsTable.lastError()) }
304. totals.seasonsMerged = totals.seasonsMerged + 1
305. return gained
306. }
307. // a season (and its episodes) moved to title `titleId` — it was a duplicate's and the keeper has no season of its number
308. static moveSeason = (&seasonId, &titleId) => {
309. x = seasonsTable.fetch(seasonId)
310. if (x == null) { return false }
311. y = x
312. y.movedFrom = { show = x.show }
313. y.show = titleId
314. if (seasonsTable.update(y.id, y) == null) {
315. console.log('merge: season ' + y.id + ' not stored: ' + seasonsTable.lastError())
316. return false
317. }
318. for (eid of listOr(y.episodes)) {
319. let e = episodesTable.fetch(eid)
320. if (e != null) {
321. let z = e
322. z.movedFrom = { show = e.show season = e.season }
323. z.show = titleId
324. if (episodesTable.update(z.id, z) == null) { console.log('merge: episode ' + z.id + ' not stored: ' + episodesTable.lastError()) }
325. forgetEpisodeKey(z.id)
326. }
327. }
328. totals.seasonsMoved = totals.seasonsMoved + 1
329. return true
330. }
331. // a title's listed seasons by number → season id
332. static seasonsByNumber = (&show) => {
333. out = {}
334. for (sid of listOr(show.seasons)) {
335. let s = seasonsTable.fetch(sid)
336. if (s != null) { out['' + s.seasonNumber] = s.id }
337. }
338. return out
339. }
341. // ---- the keeper ---------------------------------------------------------------------------------------------------------------
342. // follows + watches on the record, its seasons and their episodes
343. static userDataOf = (&r) => {
344. let n = listOr(followIds[r.id]).length + listOr(watchIds[r.id]).length
345. sids = []
346. for (x of listOr(r.seasons)) { sids.push(x) }
347. for (x of listOr(seasonsByDup[r.id])) { if (!sids.includes(x)) { sids.push(x) } }
348. for (sid of sids) {
349. n = n + listOr(watchIds[sid]).length
350. let s = seasonsTable.fetch(sid)
351. if (s != null) { for (eid of listOr(s.episodes)) { n = n + listOr(watchIds[eid]).length } }
352. }
353. return n
354. }
355. // when the record was made (ms): a Mongo id's first 8 hex digits are its seconds; else `imported`; else last
356. static ageOf = (&r) => {
357. o = r.oldId != null ? '' + r.oldId : ''
358. if (o.length == 24) {
359. let v = 0
360. let i = 0
361. let ok = true
362. while (ok && i < 8) {
363. let d = hexDigits.indexOf(o.slice(i, i + 1))
364. if (d < 0) { ok = false } else { v = v * 16 + d }
365. i = i + 1
366. }
367. if (ok) { return v * 1000 }
368. }
369. if (r.imported != null && hlTypeName(r.imported) == 'Number') { return r.imported }
370. return 9000000000000000
371. }
372. // → the keeper's id: most user data, then the old short id, then the oldest; equal → the first
373. static pickKeeper = (&recs) => {
374. let best = null
375. let bestData = -1
376. let bestOld = false
377. let bestAge = 0
378. for (r of recs) {
379. let d = userDataOf(r)
380. let o = hasOldShortId(r)
381. let a = ageOf(r)
382. let better = best == null || d > bestData || (d == bestData && o && !bestOld) || (d == bestData && o == bestOld && a < bestAge)
383. if (better) {
384. best = r.id
385. bestData = d
386. bestOld = o
387. bestAge = a
388. }
389. }
390. return best
391. }
393. // ---- one duplicate into its keeper ---------------------------------------------------------------------------------------------
394. static creditKey = (&c) => { return c.person != null ? 'p' + c.person : 't' + c.tmdbId }
395. static mergeTitleInto = (&dupId, &keeperId) => {
396. t = showsTable.fetch(dupId)
397. k0 = showsTable.fetch(keeperId)
398. if (t == null || k0 == null || t.mergedInto != null) { return null }
399. line = { follows = moveFollows(t.id, keeperId) watches = moveWatches(t.id, keeperId) seasons = 0 merged = 0 people = 0 }
400. // seasons: the listed ones first, then the ones naming it
401. sids = []
402. for (x of listOr(t.seasons)) { sids.push(x) }
403. for (x of listOr(seasonsByDup[t.id])) { if (!sids.includes(x)) { sids.push(x) } }
404. have = seasonsByNumber(k0)
405. added = []
406. for (sid of sids) {
407. let s = seasonsTable.fetch(sid)
408. if (s != null && s.mergedInto == null) {
409. let twin = have['' + s.seasonNumber]
410. if (twin != null && twin != s.id) {
411. mergeSeasonInto(s.id, twin, keeperId)
412. line.merged = line.merged + 1
413. } else if (twin == null && moveSeason(s.id, keeperId)) {
414. have['' + s.seasonNumber] = s.id
415. added.push(s.id)
416. line.seasons = line.seasons + 1
417. }
418. }
419. }
420. // the persons' credits
421. for (pid of listOr(creditedBy[t.id])) {
422. let p = personsTable.fetch(pid)
423. if (p != null) {
424. let shows = []
425. let changed = false
426. for (c of listOr(p.shows)) {
427. let x = c
428. if (x != null && x.show == t.id) {
429. x.show = keeperId
430. changed = true
431. }
432. shows.push(x)
433. }
434. if (changed) {
435. let q = p
436. q.shows = shows
437. if (personsTable.update(q.id, q) == null) { console.log('merge: person ' + q.id + ' not stored: ' + personsTable.lastError()) } else { line.people = line.people + 1 }
438. }
439. }
440. }
441. totals.people = totals.people + line.people
442. totals.timelines = totals.timelines + titleMerged(t.id, keeperId)
444. // the keeper: its new seasons, the cast/crew it lacks, empty fields, the poster, the plain slug
445. k = showsTable.fetch(keeperId)
446. seasons = listOr(k.seasons)
447. for (a of added) { seasons.push(a) }
448. k.seasons = seasons
449. castKeys = {}
450. cast = listOr(k.cast)
451. for (c of cast) { if (c != null) { castKeys[creditKey(c)] = true } }
452. for (c of listOr(t.cast)) {
453. if (c != null && castKeys[creditKey(c)] != true) {
454. castKeys[creditKey(c)] = true
455. cast.push(c)
456. totals.cast = totals.cast + 1
457. }
458. }
459. k.cast = cast
460. crewKeys = {}
461. crew = listOr(k.crew)
462. for (c of crew) { if (c != null) { crewKeys[c.person + '|' + c.name + '|' + c.job] = true } }
463. for (c of listOr(t.crew)) {
464. if (c != null && crewKeys[c.person + '|' + c.name + '|' + c.job] != true) {
465. crewKeys[c.person + '|' + c.name + '|' + c.job] = true
466. crew.push(c)
467. totals.cast = totals.cast + 1
468. }
469. }
470. if (crew.length > 0) { k.crew = crew }
471. for (f of fillFields) {
472. if (isEmpty(k[f]) && !isEmpty(t[f])) {
473. k[f] = t[f]
474. totals.fields = totals.fields + 1
475. }
476. }
477. kp = posterName(k)
478. tp = posterName(t)
479. if ((kp == null || !exists(postersDir + '/' + kp)) && tp != null && exists(postersDir + '/' + tp) && k.oldId != null) {
480. writeFile(postersDir + '/' + k.oldId + '.' + t.image, readBytes(postersDir + '/' + tp), 420)
481. k.image = t.image
482. totals.posters = totals.posters + 1
483. }
484. plain = slugBaseOf(k.title, '')
485. if (plain != '' && t.urlSegment == plain && k.urlSegment != plain) {
486. olds = listOr(k.oldSlugs)
487. if (k.urlSegment != null && !olds.includes(k.urlSegment)) { olds.push(k.urlSegment) }
488. k.oldSlugs = olds
489. k.urlSegment = plain
490. totals.slugs = totals.slugs + 1
491. }
492. if (showsTable.update(k.id, k) == null) { console.log('merge: keeper ' + k.id + ' not stored: ' + showsTable.lastError()) }
494. // the duplicate becomes a tombstone (last: a stop before this leaves a group the next start finishes)
495. d = showsTable.fetch(dupId)
496. tmdbId = d.tmdbId
497. type = d.type
498. d.mergedInto = keeperId
499. d.mergedAt = now()
500. d.mergedTmdbId = tmdbId
501. d.tmdbId = null
502. d.mergedSeasons = listOr(d.seasons)
503. d.seasons = []
504. if (showsTable.update(d.id, d) == null) {
505. console.log('merge: tombstone ' + d.id + ' not stored: ' + showsTable.lastError())
506. return null
507. }
508. totals.tombstones = totals.tombstones + 1
509. noteSlugsOf(d)
510. noteSlugsOf(showsTable.fetch(keeperId))
511. searchTitleMerged(d.id, keeperId, type, tmdbId)
512. refreshCatalogShow(d.id)
513. refreshCatalogShow(keeperId)
514. console.log('merge: "' + d.title + '" ' + d.id + ' [' + d.urlSegment + ' ' + d.shortId + '] → ' + keeperId + ' [' + showsTable.fetch(keeperId).urlSegment + ']'
515. + ' follows=' + line.follows + ' watches=' + line.watches + ' seasonsMoved=' + line.seasons + ' seasonsMerged=' + line.merged + ' people=' + line.people)
516. return line
517. }
519. // ---- one title's stray seasons ----------------------------------------------------------------------------------------------
520. static straySeasonsStep = (&showId) => {
521. show = showsTable.fetch(showId)
522. if (show == null || show.mergedInto != null) { return null }
523. listed = listOr(show.seasons)
524. have = seasonsByNumber(show)
525. // the ones with more episodes first: of two watched strays of one number the fuller one is linked, the other merged into it
526. let rows = []
527. for (sid of listOr(strays[showId])) {
528. let s = seasonsTable.fetch(sid)
529. if (s != null && s.mergedInto == null && s.show == showId && !listed.includes(s.id)) {
530. let row = { id = s.id n = s.seasonNumber eps = listOr(s.episodes).length watched = hasWatches(s) }
531. let out = []
532. let put = false
533. for (r of rows) {
534. if (!put && row.eps > r.eps) { out.push(row) put = true }
535. out.push(r)
536. }
537. if (!put) { out.push(row) }
538. rows = out
539. }
540. }
541. linked = []
542. let merged = 0
543. for (r of rows) {
544. let twin = have['' + r.n]
545. if (twin != null) {
546. mergeSeasonInto(r.id, twin, showId)
547. merged = merged + 1
548. } else if (r.watched) {
549. linked.push(r.id)
550. have['' + r.n] = r.id
551. totals.seasonsLinked = totals.seasonsLinked + 1
552. }
553. }
554. if (linked.length > 0) {
555. x = showsTable.fetch(showId)
556. seasons = listOr(x.seasons)
557. marks = listOr(x.linkedSeasons)
558. for (l of linked) {
559. seasons.push(l)
560. marks.push(l)
561. }
562. x.seasons = seasons
563. // which ones the repair linked (they were in the data, not in the list)
564. x.linkedSeasons = marks
565. if (showsTable.update(x.id, x) == null) { console.log('merge: title ' + x.id + ' not stored: ' + showsTable.lastError()) }
566. }
567. if (linked.length > 0 || merged > 0) {
568. totals.titles = totals.titles + 1
569. refreshCatalogShow(showId)
570. console.log('merge: seasons of "' + show.title + '" ' + showId + ': linked=' + linked.length + ' merged=' + merged)
571. }
572. return null
573. }
575. // ONE item of the queue → { done, left }
576. static mergeStep = () => {
577. mergePrepare()
578. if (run.pos >= queue.length) { return { done = true left = 0 } }
579. item = queue[run.pos]
580. run.pos = run.pos + 1
581. if (item.kind == 'title') {
582. recs = []
583. for (id of item.ids) {
584. let r = showsTable.fetch(id)
585. if (r != null && r.mergedInto == null) { recs.push(r) }
586. }
587. if (recs.length > 1) {
588. keeper = pickKeeper(recs)
589. for (r of recs) { if (r.id != keeper) { mergeTitleInto(r.id, keeper) } }
590. totals.groups = totals.groups + 1
591. // the keeper's own stray seasons (naming it, not listed — Reacher's kind) the same way as any title's
592. strays[keeper] = listOr(seasonsByDup[keeper])
593. straySeasonsStep(keeper)
594. }
595. } else {
596. straySeasonsStep(item.id)
597. }
598. return { done = run.pos >= queue.length left = queue.length - run.pos }
599. }