pleroma-fe/src/modules/api.js

321 lines
12 KiB
JavaScript
Raw Normal View History

import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js'
2020-05-07 13:10:53 +00:00
import { WSConnectionStatus } from '../services/api/api.service.js'
const retryTimeout = (multiplier) => 1000 * multiplier
const isVisible = (store, message, visibility) => {
if (visibility === 'all') {
return true
} else if (visibility === 'following') {
return store.getters.relationship(message.in_reply_to_user_id).following
} else if (visibility === 'self') {
return message.in_reply_to_user_id === store.rootState.users.currentUser.id
}
return false
}
const api = {
state: {
retryMultiplier: 1,
backendInteractor: backendInteractorService(),
2017-12-05 10:47:10 +00:00
fetchers: {},
2017-12-07 16:20:44 +00:00
socket: null,
mastoUserSocket: null,
2020-05-07 13:10:53 +00:00
mastoUserSocketStatus: null,
followRequests: []
},
mutations: {
setBackendInteractor (state, backendInteractor) {
state.backendInteractor = backendInteractor
},
2019-04-04 16:06:53 +00:00
addFetcher (state, { fetcherName, fetcher }) {
2019-04-04 16:03:56 +00:00
state.fetchers[fetcherName] = fetcher
},
removeFetcher (state, { fetcherName, fetcher }) {
2020-09-04 08:19:53 +00:00
state.fetchers[fetcherName].stop()
2019-04-04 16:03:56 +00:00
delete state.fetchers[fetcherName]
2017-12-05 10:47:10 +00:00
},
setWsToken (state, token) {
state.wsToken = token
},
2017-12-05 10:47:10 +00:00
setSocket (state, socket) {
state.socket = socket
2017-12-07 16:20:44 +00:00
},
setFollowRequests (state, value) {
state.followRequests = value
2020-05-07 13:10:53 +00:00
},
setMastoUserSocketStatus (state, value) {
state.mastoUserSocketStatus = value
},
incrementRetryMultiplier (state) {
state.retryMultiplier = Math.max(++state.retryMultiplier, 3)
},
resetRetryMultiplier (state) {
state.retryMultiplier = 1
}
},
actions: {
/**
* Global MastoAPI socket control, in future should disable ALL sockets/(re)start relevant sockets
*
* @param {Boolean} [initial] - whether this enabling happened at boot time or not
*/
enableMastoSockets (store, initial) {
const { state, dispatch, commit } = store
// Do not initialize unless nonexistent or closed
if (
state.mastoUserSocket &&
![
WebSocket.CLOSED,
WebSocket.CLOSING
].includes(state.mastoUserSocket.getState())
) {
return
}
if (initial) {
commit('setMastoUserSocketStatus', WSConnectionStatus.STARTING_INITIAL)
} else {
commit('setMastoUserSocketStatus', WSConnectionStatus.STARTING)
}
2019-12-26 12:12:35 +00:00
return dispatch('startMastoUserSocket')
2019-12-10 19:30:27 +00:00
},
disableMastoSockets (store) {
const { state, dispatch, commit } = store
2019-12-10 19:30:27 +00:00
if (!state.mastoUserSocket) return
commit('setMastoUserSocketStatus', WSConnectionStatus.DISABLED)
2019-12-26 12:12:35 +00:00
return dispatch('stopMastoUserSocket')
2019-12-10 19:30:27 +00:00
},
// MastoAPI 'User' sockets
startMastoUserSocket (store) {
2019-12-26 12:12:35 +00:00
return new Promise((resolve, reject) => {
try {
2020-05-07 13:10:53 +00:00
const { state, commit, dispatch, rootState } = store
2019-12-26 12:35:46 +00:00
const timelineData = rootState.statuses.timelines.friends
2019-12-26 12:12:35 +00:00
state.mastoUserSocket = state.backendInteractor.startUserSocket({ store })
state.mastoUserSocket.addEventListener(
'message',
({ detail: message }) => {
const replyVisibility = rootState.config.replyVisibility
2019-12-26 12:12:35 +00:00
if (!message) return // pings
if (message.event === 'notification') {
dispatch('addNewNotifications', {
notifications: [message.notification],
older: false
})
} else if (message.event === 'update' && isVisible(store, message.status, replyVisibility)) {
2019-12-26 12:12:35 +00:00
dispatch('addNewStatuses', {
statuses: [message.status],
userId: false,
2019-12-26 12:35:46 +00:00
showImmediately: timelineData.visibleStatuses.length === 0,
2019-12-26 12:12:35 +00:00
timeline: 'friends'
})
} else if (message.event === 'status.update' && isVisible(store, message.status, replyVisibility)) {
dispatch('addNewStatuses', {
statuses: [message.status],
userId: false,
showImmediately: message.status.id in timelineData.visibleStatusesObject,
timeline: 'friends'
})
} else if (message.event === 'delete') {
dispatch('deleteStatusById', message.id)
2019-12-26 12:12:35 +00:00
}
}
)
2020-05-07 13:10:53 +00:00
state.mastoUserSocket.addEventListener('open', () => {
2021-01-13 19:31:57 +00:00
// Do not show notification when we just opened up the page
if (state.mastoUserSocketStatus !== WSConnectionStatus.STARTING_INITIAL) {
2021-01-13 19:31:57 +00:00
dispatch('pushGlobalNotice', {
level: 'success',
messageKey: 'timeline.socket_reconnected',
timeout: 5000
})
}
// Stop polling if we were errored or disabled
if (new Set([
WSConnectionStatus.ERROR,
WSConnectionStatus.DISABLED
]).has(state.mastoUserSocketStatus)) {
dispatch('stopFetchingTimeline', { timeline: 'friends' })
dispatch('stopFetchingNotifications')
}
commit('resetRetryMultiplier')
2020-05-07 13:10:53 +00:00
commit('setMastoUserSocketStatus', WSConnectionStatus.JOINED)
})
2019-12-26 12:12:35 +00:00
state.mastoUserSocket.addEventListener('error', ({ detail: error }) => {
console.error('Error in MastoAPI websocket:', error)
})
state.mastoUserSocket.addEventListener('close', ({ detail: closeEvent }) => {
const ignoreCodes = new Set([
1000, // Normal (intended) closure
1001 // Going away
])
const { code } = closeEvent
if (ignoreCodes.has(code)) {
console.debug(`Not restarting socket becasue of closure code ${code} is in ignore list`)
commit('setMastoUserSocketStatus', WSConnectionStatus.CLOSED)
2019-12-26 12:12:35 +00:00
} else {
console.warn(`MastoAPI websocket disconnected, restarting. CloseEvent code: ${code}`)
setTimeout(() => {
dispatch('startMastoUserSocket')
}, retryTimeout(state.retryMultiplier))
commit('incrementRetryMultiplier')
if (state.mastoUserSocketStatus !== WSConnectionStatus.ERROR) {
dispatch('startFetchingTimeline', { timeline: 'friends' })
dispatch('startFetchingNotifications')
dispatch('startFetchingAnnouncements')
dispatch('startFetchingReports')
dispatch('pushGlobalNotice', {
level: 'error',
messageKey: 'timeline.socket_broke',
messageArgs: [code],
timeout: 5000
})
}
commit('setMastoUserSocketStatus', WSConnectionStatus.ERROR)
2019-12-26 12:12:35 +00:00
}
})
resolve()
} catch (e) {
reject(e)
}
})
2019-11-24 16:50:28 +00:00
},
2019-12-10 19:30:27 +00:00
stopMastoUserSocket ({ state, dispatch }) {
dispatch('startFetchingTimeline', { timeline: 'friends' })
dispatch('startFetchingNotifications')
state.mastoUserSocket.close()
},
// Timelines
startFetchingTimeline (store, {
timeline = 'friends',
tag = false,
userId = false,
listId = false
}) {
2019-02-07 23:23:18 +00:00
if (store.state.fetchers[timeline]) return
const fetcher = store.state.backendInteractor.startFetchingTimeline({
timeline, store, userId, listId, tag
})
2019-04-04 16:03:56 +00:00
store.commit('addFetcher', { fetcherName: timeline, fetcher })
},
stopFetchingTimeline (store, timeline) {
const fetcher = store.state.fetchers[timeline]
if (!fetcher) return
store.commit('removeFetcher', { fetcherName: timeline, fetcher })
},
fetchTimeline (store, timeline, { ...rest }) {
store.state.backendInteractor.fetchTimeline({
store,
timeline,
...rest
})
},
startFetchingConfig (store) {
if (store.state.fetchers.config) return
2019-04-04 16:03:56 +00:00
const fetcher = store.state.backendInteractor.startFetchingConfig({ store })
store.commit('addFetcher', { fetcherName: 'config', fetcher })
},
stopFetchingConfig (store) {
const fetcher = store.state.fetchers.config
if (!fetcher) return
store.commit('removeFetcher', { fetcherName: 'config', fetcher })
},
// Notifications
startFetchingNotifications (store) {
if (store.state.fetchers.notifications) return
2019-04-04 16:03:56 +00:00
const fetcher = store.state.backendInteractor.startFetchingNotifications({ store })
store.commit('addFetcher', { fetcherName: 'notifications', fetcher })
},
stopFetchingNotifications (store) {
const fetcher = store.state.fetchers.notifications
if (!fetcher) return
store.commit('removeFetcher', { fetcherName: 'notifications', fetcher })
},
fetchNotifications (store, { ...rest }) {
store.state.backendInteractor.fetchNotifications({
store,
...rest
})
},
// Follow requests
startFetchingFollowRequests (store) {
if (store.state.fetchers['followRequests']) return
const fetcher = store.state.backendInteractor.startFetchingFollowRequests({ store })
2020-01-21 15:51:49 +00:00
store.commit('addFetcher', { fetcherName: 'followRequests', fetcher })
},
stopFetchingFollowRequests (store) {
const fetcher = store.state.fetchers.followRequests
if (!fetcher) return
store.commit('removeFetcher', { fetcherName: 'followRequests', fetcher })
},
removeFollowRequest (store, request) {
let requests = store.state.followRequests.filter((it) => it !== request)
store.commit('setFollowRequests', requests)
2017-12-05 10:47:10 +00:00
},
2022-06-15 15:34:11 +00:00
// Lists
startFetchingLists (store) {
if (store.state.fetchers['lists']) return
const fetcher = store.state.backendInteractor.startFetchingLists({ store })
store.commit('addFetcher', { fetcherName: 'lists', fetcher })
},
stopFetchingLists (store) {
const fetcher = store.state.fetchers.lists
if (!fetcher) return
store.commit('removeFetcher', { fetcherName: 'lists', fetcher })
},
// Lists
startFetchingAnnouncements (store) {
if (store.state.fetchers['announcements']) return
const fetcher = store.state.backendInteractor.startFetchingAnnouncements({ store })
store.commit('addFetcher', { fetcherName: 'announcements', fetcher })
},
stopFetchingAnnouncements (store) {
const fetcher = store.state.fetchers.announcements
if (!fetcher) return
store.commit('removeFetcher', { fetcherName: 'announcements', fetcher })
},
// Reports
startFetchingReports (store) {
if (store.state.fetchers['reports']) return
const fetcher = store.state.backendInteractor.startFetchingReports({ store })
store.commit('addFetcher', { fetcherName: 'reports', fetcher })
},
stopFetchingReports (store) {
const fetcher = store.state.fetchers.reports
if (!fetcher) return
store.commit('removeFetcher', { fetcherName: 'reports', fetcher })
},
2022-08-30 13:37:36 +00:00
getSupportedTranslationlanguages (store) {
store.state.backendInteractor.getSupportedTranslationlanguages({ store })
.then((data) => {
store.dispatch('setInstanceOption', { name: 'supportedTranslationLanguages', value: data })
})
},
listSettingsProfiles (store) {
store.state.backendInteractor.listSettingsProfiles({ store })
.then((data) => {
store.commit('setInstanceOption', { name: 'settingsProfiles', value: data })
2022-08-30 13:37:36 +00:00
})
},
// Pleroma websocket
setWsToken (store, token) {
store.commit('setWsToken', token)
},
disconnectFromSocket ({ commit, state }) {
state.socket && state.socket.disconnect()
commit('setSocket', null)
}
}
}
export default api