Pinafore-Web-Client-Frontend/routes/_actions/timeline.js

134 lines
4.7 KiB
JavaScript
Raw Normal View History

2018-01-28 22:09:39 +01:00
import { store } from '../_store/store'
2018-02-08 17:22:14 +01:00
import { getTimeline } from '../_api/timelines'
2018-01-28 02:34:08 +01:00
import { toast } from '../_utils/toast'
import { mark, stop } from '../_utils/marks'
2018-01-29 00:02:02 +01:00
import { mergeArrays } from '../_utils/arrays'
2018-03-10 19:54:16 +01:00
import { byItemIds } from '../_utils/sorting'
import isEqual from 'lodash-es/isEqual'
import {
insertTimelineItems as insertTimelineItemsInDatabase
} from '../_database/timelines/insertion'
import {
getTimeline as getTimelineFromDatabase
} from '../_database/timelines/pagination'
2018-01-28 02:34:08 +01:00
const FETCH_LIMIT = 20
2018-02-09 07:29:29 +01:00
async function fetchTimelineItems (instanceName, accessToken, timelineName, lastTimelineItemId, online) {
mark('fetchTimelineItems')
let items
2018-03-11 20:11:06 +01:00
let stale = false
2018-01-28 02:34:08 +01:00
if (!online) {
items = await getTimelineFromDatabase(instanceName, timelineName, lastTimelineItemId, FETCH_LIMIT)
2018-03-11 20:11:06 +01:00
stale = true
2018-01-28 02:34:08 +01:00
} else {
try {
items = await getTimeline(instanceName, accessToken, timelineName, lastTimelineItemId, FETCH_LIMIT)
/* no await */ insertTimelineItemsInDatabase(instanceName, timelineName, items)
2018-01-28 02:34:08 +01:00
} catch (e) {
console.error(e)
toast.say('Internet request failed. Showing offline content.')
items = await getTimelineFromDatabase(instanceName, timelineName, lastTimelineItemId, FETCH_LIMIT)
2018-03-11 20:11:06 +01:00
stale = true
2018-01-28 02:34:08 +01:00
}
}
stop('fetchTimelineItems')
2018-03-11 20:11:06 +01:00
return { items, stale }
2018-01-28 02:34:08 +01:00
}
2018-03-11 20:11:06 +01:00
async function addTimelineItems (instanceName, timelineName, items, stale) {
console.log('addTimelineItems, length:', items.length)
mark('addTimelineItems')
2018-03-11 20:11:06 +01:00
let newIds = items.map(item => item.id)
addTimelineItemIds(instanceName, timelineName, newIds, stale)
2018-02-11 22:46:57 +01:00
stop('addTimelineItems')
}
2018-03-11 20:11:06 +01:00
export async function addTimelineItemIds (instanceName, timelineName, newIds, newStale) {
2018-03-15 06:14:06 +01:00
let oldIds = store.getForTimeline(instanceName, timelineName, 'timelineItemIds')
2018-03-11 20:11:06 +01:00
let oldStale = store.getForTimeline(instanceName, timelineName, 'timelineItemIdsAreStale')
2018-03-15 06:14:06 +01:00
let mergedIds = mergeArrays(oldIds || [], newIds)
2018-03-11 20:11:06 +01:00
if (!isEqual(oldIds, mergedIds)) {
store.setForTimeline(instanceName, timelineName, {timelineItemIds: mergedIds})
}
if (oldStale !== newStale) {
store.setForTimeline(instanceName, timelineName, {timelineItemIdsAreStale: newStale})
}
2018-01-28 02:34:08 +01:00
}
2018-02-09 07:29:29 +01:00
async function fetchTimelineItemsAndPossiblyFallBack () {
mark('fetchTimelineItemsAndPossiblyFallBack')
let {
currentTimeline,
currentInstance,
accessToken,
lastTimelineItemId,
online
} = store.get()
2018-01-28 02:34:08 +01:00
let { items, stale } = await fetchTimelineItems(currentInstance, accessToken, currentTimeline, lastTimelineItemId, online)
addTimelineItems(currentInstance, currentTimeline, items, stale)
stop('fetchTimelineItemsAndPossiblyFallBack')
2018-01-28 02:34:08 +01:00
}
2018-02-09 07:29:29 +01:00
export async function setupTimeline () {
mark('setupTimeline')
2018-03-11 20:11:06 +01:00
// If we don't have any item ids, or if the current item ids are stale
// (i.e. via offline mode), then we need to re-fetch
// Also do this if it's a thread, because threads change pretty frequently and
// we don't have a good way to update them.
let {
timelineItemIds,
timelineItemIdsAreStale,
currentTimeline
} = store.get()
2018-03-11 20:11:06 +01:00
if (!timelineItemIds ||
timelineItemIdsAreStale ||
currentTimeline.startsWith('status/')) {
await fetchTimelineItemsAndPossiblyFallBack()
2018-01-28 02:34:08 +01:00
}
stop('setupTimeline')
2018-01-28 02:34:08 +01:00
}
2018-03-10 19:54:16 +01:00
export async function fetchTimelineItemsOnScrollToBottom (instanceName, timelineName) {
2018-01-28 02:34:08 +01:00
store.setForTimeline(instanceName, timelineName, { runningUpdate: true })
await fetchTimelineItemsAndPossiblyFallBack()
2018-01-28 02:34:08 +01:00
store.setForTimeline(instanceName, timelineName, { runningUpdate: false })
2018-02-09 07:29:29 +01:00
}
2018-02-12 04:15:21 +01:00
2018-03-10 19:54:16 +01:00
export async function showMoreItemsForTimeline (instanceName, timelineName) {
mark('showMoreItemsForTimeline')
let itemIdsToAdd = store.getForTimeline(instanceName, timelineName, 'itemIdsToAdd')
itemIdsToAdd = itemIdsToAdd.sort(byItemIds).reverse()
2018-03-11 20:11:06 +01:00
addTimelineItemIds(instanceName, timelineName, itemIdsToAdd, false)
2018-02-12 04:15:21 +01:00
store.setForTimeline(instanceName, timelineName, {
itemIdsToAdd: [],
shouldShowHeader: false,
showHeader: false
})
2018-03-10 19:54:16 +01:00
stop('showMoreItemsForTimeline')
2018-02-14 04:35:46 +01:00
}
2018-03-10 07:31:26 +01:00
2018-03-10 19:54:16 +01:00
export async function showMoreItemsForCurrentTimeline () {
let { currentInstance, currentTimeline } = store.get()
2018-03-10 19:54:16 +01:00
return showMoreItemsForTimeline(
currentInstance,
currentTimeline
2018-03-10 19:54:16 +01:00
)
}
export async function showMoreItemsForThread (instanceName, timelineName) {
mark('showMoreItemsForThread')
let itemIdsToAdd = store.getForTimeline(instanceName, timelineName, 'itemIdsToAdd')
2018-03-10 07:31:26 +01:00
let timelineItemIds = store.getForTimeline(instanceName, timelineName, 'timelineItemIds')
2018-03-10 19:54:16 +01:00
// TODO: update database and do the thread merge correctly
2018-03-10 07:31:26 +01:00
timelineItemIds = timelineItemIds.concat(itemIdsToAdd)
store.setForTimeline(instanceName, timelineName, {
itemIdsToAdd: [],
timelineItemIds: timelineItemIds
})
2018-03-10 19:54:16 +01:00
stop('showMoreItemsForThread')
2018-03-10 07:31:26 +01:00
}