akkoma-fe/src/modules/api.js

176 lines
6 KiB
JavaScript
Raw Normal View History

import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js'
2017-12-05 10:47:10 +00:00
import { Socket } from 'phoenix'
const api = {
state: {
backendInteractor: backendInteractorService(),
2017-12-05 10:47:10 +00:00
fetchers: {},
2017-12-07 16:20:44 +00:00
socket: null,
mastoUserSocket: 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 }) {
window.clearInterval(fetcher)
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
}
},
actions: {
2019-12-10 19:30:27 +00:00
// Global MastoAPI socket control, in future should disable ALL sockets/(re)start relevant sockets
enableMastoSockets (store) {
const { state, dispatch } = store
if (state.mastoUserSocket) return
dispatch('startMastoUserSocket')
},
disableMastoSockets (store) {
const { state, dispatch } = store
if (!state.mastoUserSocket) return
dispatch('stopMastoUserSocket')
},
// MastoAPI 'User' sockets
startMastoUserSocket (store) {
const { state, dispatch } = store
2019-12-08 17:18:38 +00:00
state.mastoUserSocket = state.backendInteractor.startUserSocket({ store })
state.mastoUserSocket.addEventListener(
'message',
({ detail: message }) => {
if (!message) return // pings
if (message.event === 'notification') {
dispatch('addNewNotifications', {
notifications: [message.notification],
older: false
})
} else if (message.event === 'update') {
dispatch('addNewStatuses', {
statuses: [message.status],
userId: false,
showImmediately: false,
timeline: 'friends'
})
2019-11-24 16:50:28 +00:00
}
2019-12-08 17:18:38 +00:00
}
)
state.mastoUserSocket.addEventListener('error', ({ detail: error }) => {
console.error('Error in MastoAPI websocket:', error)
})
2019-12-08 17:18:38 +00:00
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`)
} else {
console.warn(`MastoAPI websocket disconnected, restarting. CloseEvent code: ${code}`)
dispatch('startFetchingTimeline', { timeline: 'friends' })
dispatch('startFetchingNotifications')
dispatch('restartMastoUserSocket')
}
})
2019-11-24 16:50:28 +00:00
},
restartMastoUserSocket ({ dispatch }) {
// This basically starts MastoAPI user socket and stops conventional
// fetchers when connection reestablished
dispatch('startMastoUserSocket').then(() => {
dispatch('stopFetchingTimeline', { timeline: 'friends' })
dispatch('stopFetchingNotifications')
})
},
2019-12-10 19:30:27 +00:00
stopMastoUserSocket ({ state, dispatch }) {
dispatch('startFetchingTimeline', { timeline: 'friends' })
dispatch('startFetchingNotifications')
console.log(state.mastoUserSocket)
state.mastoUserSocket.close()
},
// Timelines
startFetchingTimeline (store, {
timeline = 'friends',
tag = false,
userId = false
}) {
2019-02-07 23:23:18 +00:00
if (store.state.fetchers[timeline]) return
const fetcher = store.state.backendInteractor.startFetchingTimeline({
timeline, store, userId, 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 })
},
2019-04-04 16:03:56 +00:00
// 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 })
},
fetchAndUpdateNotifications (store) {
store.state.backendInteractor.fetchAndUpdateNotifications({ store })
},
// Follow requests
startFetchingFollowRequests (store) {
if (store.state.fetchers['followRequests']) return
const fetcher = store.state.backendInteractor.startFetchingFollowRequests({ store })
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
},
// Pleroma websocket
setWsToken (store, token) {
store.commit('setWsToken', token)
},
initializeSocket ({ dispatch, commit, state, rootState }) {
2017-12-05 10:47:10 +00:00
// Set up websocket connection
const token = state.wsToken
if (rootState.instance.chatAvailable && typeof token !== 'undefined' && state.socket === null) {
2019-06-18 20:28:31 +00:00
const socket = new Socket('/socket', { params: { token } })
2017-12-07 16:20:44 +00:00
socket.connect()
commit('setSocket', socket)
dispatch('initializeChat', socket)
2017-12-07 16:20:44 +00:00
}
},
disconnectFromSocket ({ commit, state }) {
state.socket && state.socket.disconnect()
commit('setSocket', null)
}
}
}
export default api