No OneTemporary
Actions

Authored By

Unknown

Size

37 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/components/chat/chat.js b/src/components/chat/chat.js
	index 2062643def..151238853c 100644
	--- a/src/components/chat/chat.js
	+++ b/src/components/chat/chat.js
	@@ -1,334 +1,334 @@
	import _ from 'lodash'
	import { WSConnectionStatus } from '../../services/api/api.service.js'
	import { mapGetters, mapState } from 'vuex'
	import ChatMessage from '../chat_message/chat_message.vue'
	import PostStatusForm from '../post_status_form/post_status_form.vue'
	import ChatTitle from '../chat_title/chat_title.vue'
	import chatService from '../../services/chat_service/chat_service.js'
	-import { makeFetcher } from '../../services/fetcher/fetcher.js'
	+import { promiseInterval } from '../../services/promise_interval/promise_interval.js'
	import { getScrollPosition, getNewTopPosition, isBottomedOut, scrollableContainerHeight } from './chat_layout_utils.js'

	const BOTTOMED_OUT_OFFSET = 10
	const JUMP_TO_BOTTOM_BUTTON_VISIBILITY_OFFSET = 150
	const SAFE_RESIZE_TIME_OFFSET = 100

	const Chat = {
	components: {
	ChatMessage,
	ChatTitle,
	PostStatusForm
	},
	data () {
	return {
	jumpToBottomButtonVisible: false,
	hoveredMessageChainId: undefined,
	lastScrollPosition: {},
	scrollableContainerHeight: '100%',
	errorLoadingChat: false
	}
	},
	created () {
	this.startFetching()
	window.addEventListener('resize', this.handleLayoutChange)
	},
	mounted () {
	window.addEventListener('scroll', this.handleScroll)
	if (typeof document.hidden !== 'undefined') {
	document.addEventListener('visibilitychange', this.handleVisibilityChange, false)
	}

	this.$nextTick(() => {
	this.updateScrollableContainerHeight()
	this.handleResize()
	})
	this.setChatLayout()
	},
	destroyed () {
	window.removeEventListener('scroll', this.handleScroll)
	window.removeEventListener('resize', this.handleLayoutChange)
	this.unsetChatLayout()
	if (typeof document.hidden !== 'undefined') document.removeEventListener('visibilitychange', this.handleVisibilityChange, false)
	this.$store.dispatch('clearCurrentChat')
	},
	computed: {
	recipient () {
	return this.currentChat && this.currentChat.account
	},
	recipientId () {
	return this.$route.params.recipient_id
	},
	formPlaceholder () {
	if (this.recipient) {
	return this.$t('chats.message_user', { nickname: this.recipient.screen_name })
	} else {
	return ''
	}
	},
	chatViewItems () {
	return chatService.getView(this.currentChatMessageService)
	},
	newMessageCount () {
	return this.currentChatMessageService && this.currentChatMessageService.newMessageCount
	},
	streamingEnabled () {
	return this.mergedConfig.useStreamingApi && this.mastoUserSocketStatus === WSConnectionStatus.JOINED
	},
	...mapGetters([
	'currentChat',
	'currentChatMessageService',
	'findOpenedChatByRecipientId',
	'mergedConfig'
	]),
	...mapState({
	backendInteractor: state => state.api.backendInteractor,
	mastoUserSocketStatus: state => state.api.mastoUserSocketStatus,
	mobileLayout: state => state.interface.mobileLayout,
	layoutHeight: state => state.interface.layoutHeight,
	currentUser: state => state.users.currentUser
	})
	},
	watch: {
	chatViewItems () {
	// We don't want to scroll to the bottom on a new message when the user is viewing older messages.
	// Therefore we need to know whether the scroll position was at the bottom before the DOM update.
	const bottomedOutBeforeUpdate = this.bottomedOut(BOTTOMED_OUT_OFFSET)
	this.$nextTick(() => {
	if (bottomedOutBeforeUpdate) {
	this.scrollDown({ forceRead: !document.hidden })
	}
	})
	},
	'$route': function () {
	this.startFetching()
	},
	layoutHeight () {
	this.handleResize({ expand: true })
	},
	mastoUserSocketStatus (newValue) {
	if (newValue === WSConnectionStatus.JOINED) {
	this.fetchChat({ isFirstFetch: true })
	}
	}
	},
	methods: {
	// Used to animate the avatar near the first message of the message chain when any message belonging to the chain is hovered
	onMessageHover ({ isHovered, messageChainId }) {
	this.hoveredMessageChainId = isHovered ? messageChainId : undefined
	},
	onFilesDropped () {
	this.$nextTick(() => {
	this.handleResize()
	this.updateScrollableContainerHeight()
	})
	},
	handleVisibilityChange () {
	this.$nextTick(() => {
	if (!document.hidden && this.bottomedOut(BOTTOMED_OUT_OFFSET)) {
	this.scrollDown({ forceRead: true })
	}
	})
	},
	setChatLayout () {
	// This is a hacky way to adjust the global layout to the mobile chat (without modifying the rest of the app).
	// This layout prevents empty spaces from being visible at the bottom
	// of the chat on iOS Safari (`safe-area-inset`) when
	// - the on-screen keyboard appears and the user starts typing
	// - the user selects the text inside the input area
	// - the user selects and deletes the text that is multiple lines long
	// TODO: unify the chat layout with the global layout.
	let html = document.querySelector('html')
	if (html) {
	html.classList.add('chat-layout')
	}

	this.$nextTick(() => {
	this.updateScrollableContainerHeight()
	})
	},
	unsetChatLayout () {
	let html = document.querySelector('html')
	if (html) {
	html.classList.remove('chat-layout')
	}
	},
	handleLayoutChange () {
	this.$nextTick(() => {
	this.updateScrollableContainerHeight()
	this.scrollDown()
	})
	},
	// Ensures the proper position of the posting form in the mobile layout (the mobile browser panel does not overlap or hide it)
	updateScrollableContainerHeight () {
	const header = this.$refs.header
	const footer = this.$refs.footer
	const inner = this.mobileLayout ? window.document.body : this.$refs.inner
	this.scrollableContainerHeight = scrollableContainerHeight(inner, header, footer) + 'px'
	},
	// Preserves the scroll position when OSK appears or the posting form changes its height.
	handleResize (opts = {}) {
	const { expand = false, delayed = false } = opts

	if (delayed) {
	setTimeout(() => {
	this.handleResize({ ...opts, delayed: false })
	}, SAFE_RESIZE_TIME_OFFSET)
	return
	}

	this.$nextTick(() => {
	this.updateScrollableContainerHeight()

	const { offsetHeight = undefined } = this.lastScrollPosition
	this.lastScrollPosition = getScrollPosition(this.$refs.scrollable)

	const diff = this.lastScrollPosition.offsetHeight - offsetHeight
	if (diff < 0 \|\| (!this.bottomedOut() && expand)) {
	this.$nextTick(() => {
	this.updateScrollableContainerHeight()
	this.$refs.scrollable.scrollTo({
	top: this.$refs.scrollable.scrollTop - diff,
	left: 0
	})
	})
	}
	})
	},
	scrollDown (options = {}) {
	const { behavior = 'auto', forceRead = false } = options
	const scrollable = this.$refs.scrollable
	if (!scrollable) { return }
	this.$nextTick(() => {
	scrollable.scrollTo({ top: scrollable.scrollHeight, left: 0, behavior })
	})
	if (forceRead \|\| this.newMessageCount > 0) {
	this.readChat()
	}
	},
	readChat () {
	if (!(this.currentChatMessageService && this.currentChatMessageService.lastMessage)) { return }
	if (document.hidden) { return }
	const lastReadId = this.currentChatMessageService.lastMessage.id
	this.$store.dispatch('readChat', { id: this.currentChat.id, lastReadId })
	},
	bottomedOut (offset) {
	return isBottomedOut(this.$refs.scrollable, offset)
	},
	reachedTop () {
	const scrollable = this.$refs.scrollable
	return scrollable && scrollable.scrollTop <= 0
	},
	handleScroll: _.throttle(function () {
	if (!this.currentChat) { return }

	if (this.reachedTop()) {
	this.fetchChat({ maxId: this.currentChatMessageService.minId })
	} else if (this.bottomedOut(JUMP_TO_BOTTOM_BUTTON_VISIBILITY_OFFSET)) {
	this.jumpToBottomButtonVisible = false
	if (this.newMessageCount > 0) {
	this.readChat()
	}
	} else {
	this.jumpToBottomButtonVisible = true
	}
	}, 100),
	handleScrollUp (positionBeforeLoading) {
	const positionAfterLoading = getScrollPosition(this.$refs.scrollable)
	this.$refs.scrollable.scrollTo({
	top: getNewTopPosition(positionBeforeLoading, positionAfterLoading),
	left: 0
	})
	},
	fetchChat ({ isFirstFetch = false, fetchLatest = false, maxId }) {
	const chatMessageService = this.currentChatMessageService
	if (!chatMessageService) { return }
	if (fetchLatest && this.streamingEnabled) { return }

	const chatId = chatMessageService.chatId
	const fetchOlderMessages = !!maxId
	const sinceId = fetchLatest && chatMessageService.lastMessage && chatMessageService.lastMessage.id

	return this.backendInteractor.chatMessages({ id: chatId, maxId, sinceId })
	.then((messages) => {
	// Clear the current chat in case we're recovering from a ws connection loss.
	if (isFirstFetch) {
	chatService.clear(chatMessageService)
	}

	const positionBeforeUpdate = getScrollPosition(this.$refs.scrollable)
	this.$store.dispatch('addChatMessages', { chatId, messages }).then(() => {
	this.$nextTick(() => {
	if (fetchOlderMessages) {
	this.handleScrollUp(positionBeforeUpdate)
	}

	if (isFirstFetch) {
	this.updateScrollableContainerHeight()
	}
	})
	})
	})
	},
	async startFetching () {
	let chat = this.findOpenedChatByRecipientId(this.recipientId)
	if (!chat) {
	try {
	chat = await this.backendInteractor.getOrCreateChat({ accountId: this.recipientId })
	} catch (e) {
	console.error('Error creating or getting a chat', e)
	this.errorLoadingChat = true
	}
	}
	if (chat) {
	this.$nextTick(() => {
	this.scrollDown({ forceRead: true })
	})
	this.$store.dispatch('addOpenedChat', { chat })
	this.doStartFetching()
	}
	},
	doStartFetching () {
	this.$store.dispatch('startFetchingCurrentChat', {
	- fetcher: () => makeFetcher(() => this.fetchChat({ fetchLatest: true }), 5000)
	+ fetcher: () => promiseInterval(() => this.fetchChat({ fetchLatest: true }), 5000)
	})
	this.fetchChat({ isFirstFetch: true })
	},
	sendMessage ({ status, media }) {
	const params = {
	id: this.currentChat.id,
	content: status
	}

	if (media[0]) {
	params.mediaId = media[0].id
	}

	return this.backendInteractor.sendChatMessage(params)
	.then(data => {
	this.$store.dispatch('addChatMessages', { chatId: this.currentChat.id, messages: [data] }).then(() => {
	this.$nextTick(() => {
	this.handleResize()
	// When the posting form size changes because of a media attachment, we need an extra resize
	// to account for the potential delay in the DOM update.
	setTimeout(() => {
	this.updateScrollableContainerHeight()
	}, SAFE_RESIZE_TIME_OFFSET)
	this.scrollDown({ forceRead: true })
	})
	})

	return data
	})
	.catch(error => {
	console.error('Error sending message', error)
	return {
	error: this.$t('chats.error_sending_message')
	}
	})
	},
	goBack () {
	this.$router.push({ name: 'chats', params: { username: this.currentUser.screen_name } })
	}
	}
	}

	export default Chat
	diff --git a/src/modules/api.js b/src/modules/api.js
	index 7ddd8dde26..73511442d7 100644
	--- a/src/modules/api.js
	+++ b/src/modules/api.js
	@@ -1,203 +1,203 @@
	import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js'
	import { WSConnectionStatus } from '../services/api/api.service.js'
	import { maybeShowChatNotification } from '../services/chat_utils/chat_utils.js'
	import { Socket } from 'phoenix'

	const api = {
	state: {
	backendInteractor: backendInteractorService(),
	fetchers: {},
	socket: null,
	mastoUserSocket: null,
	mastoUserSocketStatus: null,
	followRequests: []
	},
	mutations: {
	setBackendInteractor (state, backendInteractor) {
	state.backendInteractor = backendInteractor
	},
	addFetcher (state, { fetcherName, fetcher }) {
	state.fetchers[fetcherName] = fetcher
	},
	removeFetcher (state, { fetcherName, fetcher }) {
	- state.fetchers[fetcherName]()
	+ state.fetchers[fetcherName].stop()
	delete state.fetchers[fetcherName]
	},
	setWsToken (state, token) {
	state.wsToken = token
	},
	setSocket (state, socket) {
	state.socket = socket
	},
	setFollowRequests (state, value) {
	state.followRequests = value
	},
	setMastoUserSocketStatus (state, value) {
	state.mastoUserSocketStatus = value
	}
	},
	actions: {
	// Global MastoAPI socket control, in future should disable ALL sockets/(re)start relevant sockets
	enableMastoSockets (store) {
	const { state, dispatch } = store
	if (state.mastoUserSocket) return
	return dispatch('startMastoUserSocket')
	},
	disableMastoSockets (store) {
	const { state, dispatch } = store
	if (!state.mastoUserSocket) return
	return dispatch('stopMastoUserSocket')
	},

	// MastoAPI 'User' sockets
	startMastoUserSocket (store) {
	return new Promise((resolve, reject) => {
	try {
	const { state, commit, dispatch, rootState } = store
	const timelineData = rootState.statuses.timelines.friends
	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: timelineData.visibleStatuses.length === 0,
	timeline: 'friends'
	})
	} else if (message.event === 'pleroma:chat_update') {
	dispatch('addChatMessages', {
	chatId: message.chatUpdate.id,
	messages: [message.chatUpdate.lastMessage]
	})
	dispatch('updateChat', { chat: message.chatUpdate })
	maybeShowChatNotification(store, message.chatUpdate)
	}
	}
	)
	state.mastoUserSocket.addEventListener('open', () => {
	commit('setMastoUserSocketStatus', WSConnectionStatus.JOINED)
	})
	state.mastoUserSocket.addEventListener('error', ({ detail: error }) => {
	console.error('Error in MastoAPI websocket:', error)
	commit('setMastoUserSocketStatus', WSConnectionStatus.ERROR)
	dispatch('clearOpenedChats')
	})
	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('startFetchingChats')
	dispatch('restartMastoUserSocket')
	}
	commit('setMastoUserSocketStatus', WSConnectionStatus.CLOSED)
	dispatch('clearOpenedChats')
	})
	resolve()
	} catch (e) {
	reject(e)
	}
	})
	},
	restartMastoUserSocket ({ dispatch }) {
	// This basically starts MastoAPI user socket and stops conventional
	// fetchers when connection reestablished
	return dispatch('startMastoUserSocket').then(() => {
	dispatch('stopFetchingTimeline', { timeline: 'friends' })
	dispatch('stopFetchingNotifications')
	dispatch('stopFetchingChats')
	})
	},
	stopMastoUserSocket ({ state, dispatch }) {
	dispatch('startFetchingTimeline', { timeline: 'friends' })
	dispatch('startFetchingNotifications')
	dispatch('startFetchingChats')
	state.mastoUserSocket.close()
	},

	// Timelines
	startFetchingTimeline (store, {
	timeline = 'friends',
	tag = false,
	userId = false
	}) {
	if (store.state.fetchers[timeline]) return

	const fetcher = store.state.backendInteractor.startFetchingTimeline({
	timeline, store, userId, tag
	})
	store.commit('addFetcher', { fetcherName: timeline, fetcher })
	},
	stopFetchingTimeline (store, timeline) {
	const fetcher = store.state.fetchers[timeline]
	if (!fetcher) return
	store.commit('removeFetcher', { fetcherName: timeline, fetcher })
	},

	// Notifications
	startFetchingNotifications (store) {
	if (store.state.fetchers.notifications) return
	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 })
	},

	// 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)
	},

	// Pleroma websocket
	setWsToken (store, token) {
	store.commit('setWsToken', token)
	},
	initializeSocket ({ dispatch, commit, state, rootState }) {
	// Set up websocket connection
	const token = state.wsToken
	if (rootState.instance.chatAvailable && typeof token !== 'undefined' && state.socket === null) {
	const socket = new Socket('/socket', { params: { token } })
	socket.connect()

	commit('setSocket', socket)
	dispatch('initializeChat', socket)
	}
	},
	disconnectFromSocket ({ commit, state }) {
	state.socket && state.socket.disconnect()
	commit('setSocket', null)
	}
	}
	}

	export default api
	diff --git a/src/modules/chats.js b/src/modules/chats.js
	index 45e4bdccb6..60273a44dc 100644
	--- a/src/modules/chats.js
	+++ b/src/modules/chats.js
	@@ -1,233 +1,233 @@
	import Vue from 'vue'
	import { find, omitBy, orderBy, sumBy } from 'lodash'
	import chatService from '../services/chat_service/chat_service.js'
	import { parseChat, parseChatMessage } from '../services/entity_normalizer/entity_normalizer.service.js'
	import { maybeShowChatNotification } from '../services/chat_utils/chat_utils.js'
	-import { makeFetcher } from '../services/fetcher/fetcher.js'
	+import { promiseInterval } from '../services/promise_interval/promise_interval.js'

	const emptyChatList = () => ({
	data: [],
	idStore: {}
	})

	const defaultState = {
	chatList: emptyChatList(),
	chatListFetcher: null,
	openedChats: {},
	openedChatMessageServices: {},
	fetcher: undefined,
	currentChatId: null
	}

	const getChatById = (state, id) => {
	return find(state.chatList.data, { id })
	}

	const sortedChatList = (state) => {
	return orderBy(state.chatList.data, ['updated_at'], ['desc'])
	}

	const unreadChatCount = (state) => {
	return sumBy(state.chatList.data, 'unread')
	}

	const chats = {
	state: { ...defaultState },
	getters: {
	currentChat: state => state.openedChats[state.currentChatId],
	currentChatMessageService: state => state.openedChatMessageServices[state.currentChatId],
	findOpenedChatByRecipientId: state => recipientId => find(state.openedChats, c => c.account.id === recipientId),
	sortedChatList,
	unreadChatCount
	},
	actions: {
	// Chat list
	startFetchingChats ({ dispatch, commit }) {
	const fetcher = () => dispatch('fetchChats', { latest: true })
	fetcher()
	commit('setChatListFetcher', {
	- fetcher: () => makeFetcher(fetcher, 5000)
	+ fetcher: () => promiseInterval(fetcher, 5000)
	})
	},
	stopFetchingChats ({ commit }) {
	commit('setChatListFetcher', { fetcher: undefined })
	},
	fetchChats ({ dispatch, rootState, commit }, params = {}) {
	return rootState.api.backendInteractor.chats()
	.then(({ chats }) => {
	dispatch('addNewChats', { chats })
	return chats
	})
	},
	addNewChats (store, { chats }) {
	const { commit, dispatch, rootGetters } = store
	const newChatMessageSideEffects = (chat) => {
	maybeShowChatNotification(store, chat)
	}
	commit('addNewChats', { dispatch, chats, rootGetters, newChatMessageSideEffects })
	},
	updateChat ({ commit }, { chat }) {
	commit('updateChat', { chat })
	},

	// Opened Chats
	startFetchingCurrentChat ({ commit, dispatch }, { fetcher }) {
	dispatch('setCurrentChatFetcher', { fetcher })
	},
	setCurrentChatFetcher ({ rootState, commit }, { fetcher }) {
	commit('setCurrentChatFetcher', { fetcher })
	},
	addOpenedChat ({ rootState, commit, dispatch }, { chat }) {
	commit('addOpenedChat', { dispatch, chat: parseChat(chat) })
	dispatch('addNewUsers', [chat.account])
	},
	addChatMessages ({ commit }, value) {
	commit('addChatMessages', { commit, ...value })
	},
	resetChatNewMessageCount ({ commit }, value) {
	commit('resetChatNewMessageCount', value)
	},
	clearCurrentChat ({ rootState, commit, dispatch }, value) {
	commit('setCurrentChatId', { chatId: undefined })
	commit('setCurrentChatFetcher', { fetcher: undefined })
	},
	readChat ({ rootState, commit, dispatch }, { id, lastReadId }) {
	dispatch('resetChatNewMessageCount')
	commit('readChat', { id })
	rootState.api.backendInteractor.readChat({ id, lastReadId })
	},
	deleteChatMessage ({ rootState, commit }, value) {
	rootState.api.backendInteractor.deleteChatMessage(value)
	commit('deleteChatMessage', { commit, ...value })
	},
	resetChats ({ commit, dispatch }) {
	dispatch('clearCurrentChat')
	commit('resetChats', { commit })
	},
	clearOpenedChats ({ rootState, commit, dispatch, rootGetters }) {
	commit('clearOpenedChats', { commit })
	}
	},
	mutations: {
	setChatListFetcher (state, { commit, fetcher }) {
	const prevFetcher = state.chatListFetcher
	if (prevFetcher) {
	prevFetcher()
	}
	state.chatListFetcher = fetcher && fetcher()
	},
	setCurrentChatFetcher (state, { fetcher }) {
	const prevFetcher = state.fetcher
	if (prevFetcher) {
	prevFetcher()
	}
	state.fetcher = fetcher && fetcher()
	},
	addOpenedChat (state, { _dispatch, chat }) {
	state.currentChatId = chat.id
	Vue.set(state.openedChats, chat.id, chat)

	if (!state.openedChatMessageServices[chat.id]) {
	Vue.set(state.openedChatMessageServices, chat.id, chatService.empty(chat.id))
	}
	},
	setCurrentChatId (state, { chatId }) {
	state.currentChatId = chatId
	},
	addNewChats (state, { chats, newChatMessageSideEffects }) {
	chats.forEach((updatedChat) => {
	const chat = getChatById(state, updatedChat.id)

	if (chat) {
	const isNewMessage = (chat.lastMessage && chat.lastMessage.id) !== (updatedChat.lastMessage && updatedChat.lastMessage.id)
	chat.lastMessage = updatedChat.lastMessage
	chat.unread = updatedChat.unread
	if (isNewMessage && chat.unread) {
	newChatMessageSideEffects(updatedChat)
	}
	} else {
	state.chatList.data.push(updatedChat)
	Vue.set(state.chatList.idStore, updatedChat.id, updatedChat)
	}
	})
	},
	updateChat (state, { _dispatch, chat: updatedChat, _rootGetters }) {
	const chat = getChatById(state, updatedChat.id)
	if (chat) {
	chat.lastMessage = updatedChat.lastMessage
	chat.unread = updatedChat.unread
	chat.updated_at = updatedChat.updated_at
	}
	if (!chat) { state.chatList.data.unshift(updatedChat) }
	Vue.set(state.chatList.idStore, updatedChat.id, updatedChat)
	},
	deleteChat (state, { _dispatch, id, _rootGetters }) {
	state.chats.data = state.chats.data.filter(conversation =>
	conversation.last_status.id !== id
	)
	state.chats.idStore = omitBy(state.chats.idStore, conversation => conversation.last_status.id === id)
	},
	resetChats (state, { commit }) {
	state.chatList = emptyChatList()
	state.currentChatId = null
	commit('setChatListFetcher', { fetcher: undefined })
	for (const chatId in state.openedChats) {
	chatService.clear(state.openedChatMessageServices[chatId])
	Vue.delete(state.openedChats, chatId)
	Vue.delete(state.openedChatMessageServices, chatId)
	}
	},
	setChatsLoading (state, { value }) {
	state.chats.loading = value
	},
	addChatMessages (state, { commit, chatId, messages }) {
	const chatMessageService = state.openedChatMessageServices[chatId]
	if (chatMessageService) {
	chatService.add(chatMessageService, { messages: messages.map(parseChatMessage) })
	commit('refreshLastMessage', { chatId })
	}
	},
	refreshLastMessage (state, { chatId }) {
	const chatMessageService = state.openedChatMessageServices[chatId]
	if (chatMessageService) {
	const chat = getChatById(state, chatId)
	if (chat) {
	chat.lastMessage = chatMessageService.lastMessage
	if (chatMessageService.lastMessage) {
	chat.updated_at = chatMessageService.lastMessage.created_at
	}
	}
	}
	},
	deleteChatMessage (state, { commit, chatId, messageId }) {
	const chatMessageService = state.openedChatMessageServices[chatId]
	if (chatMessageService) {
	chatService.deleteMessage(chatMessageService, messageId)
	commit('refreshLastMessage', { chatId })
	}
	},
	resetChatNewMessageCount (state, _value) {
	const chatMessageService = state.openedChatMessageServices[state.currentChatId]
	chatService.resetNewMessageCount(chatMessageService)
	},
	// Used when a connection loss occurs
	clearOpenedChats (state) {
	const currentChatId = state.currentChatId
	for (const chatId in state.openedChats) {
	if (currentChatId !== chatId) {
	chatService.clear(state.openedChatMessageServices[chatId])
	Vue.delete(state.openedChats, chatId)
	Vue.delete(state.openedChatMessageServices, chatId)
	}
	}
	},
	readChat (state, { id }) {
	const chat = getChatById(state, id)
	if (chat) {
	chat.unread = 0
	}
	}
	}
	}

	export default chats
	diff --git a/src/services/follow_request_fetcher/follow_request_fetcher.service.js b/src/services/follow_request_fetcher/follow_request_fetcher.service.js
	index bec434aaa1..74af40815e 100644
	--- a/src/services/follow_request_fetcher/follow_request_fetcher.service.js
	+++ b/src/services/follow_request_fetcher/follow_request_fetcher.service.js
	@@ -1,23 +1,23 @@
	import apiService from '../api/api.service.js'
	-import { makeFetcher } from '../fetcher/fetcher.js'
	+import { promiseInterval } from '../promise_interval/promise_interval.js'

	const fetchAndUpdate = ({ store, credentials }) => {
	return apiService.fetchFollowRequests({ credentials })
	.then((requests) => {
	store.commit('setFollowRequests', requests)
	store.commit('addNewUsers', requests)
	}, () => {})
	.catch(() => {})
	}

	const startFetching = ({ credentials, store }) => {
	const boundFetchAndUpdate = () => fetchAndUpdate({ credentials, store })
	boundFetchAndUpdate()
	- return makeFetcher(boundFetchAndUpdate, 10000)
	+ return promiseInterval(boundFetchAndUpdate, 10000)
	}

	const followRequestFetcher = {
	startFetching
	}

	export default followRequestFetcher
	diff --git a/src/services/notifications_fetcher/notifications_fetcher.service.js b/src/services/notifications_fetcher/notifications_fetcher.service.js
	index 90988fc459..c908b6443b 100644
	--- a/src/services/notifications_fetcher/notifications_fetcher.service.js
	+++ b/src/services/notifications_fetcher/notifications_fetcher.service.js
	@@ -1,72 +1,72 @@
	import apiService from '../api/api.service.js'
	-import { makeFetcher } from '../fetcher/fetcher.js'
	+import { promiseInterval } from '../promise_interval/promise_interval.js'

	const update = ({ store, notifications, older }) => {
	store.dispatch('setNotificationsError', { value: false })
	store.dispatch('addNewNotifications', { notifications, older })
	}

	const fetchAndUpdate = ({ store, credentials, older = false }) => {
	const args = { credentials }
	const { getters } = store
	const rootState = store.rootState \|\| store.state
	const timelineData = rootState.statuses.notifications
	const hideMutedPosts = getters.mergedConfig.hideMutedPosts

	args['withMuted'] = !hideMutedPosts

	args['timeline'] = 'notifications'
	if (older) {
	if (timelineData.minId !== Number.POSITIVE_INFINITY) {
	args['until'] = timelineData.minId
	}
	return fetchNotifications({ store, args, older })
	} else {
	// fetch new notifications
	if (timelineData.maxId !== Number.POSITIVE_INFINITY) {
	args['since'] = timelineData.maxId
	}
	const result = fetchNotifications({ store, args, older })

	// If there's any unread notifications, try fetch notifications since
	// the newest read notification to check if any of the unread notifs
	// have changed their 'seen' state (marked as read in another session), so
	// we can update the state in this session to mark them as read as well.
	// The normal maxId-check does not tell if older notifications have changed
	const notifications = timelineData.data
	const readNotifsIds = notifications.filter(n => n.seen).map(n => n.id)
	const numUnseenNotifs = notifications.length - readNotifsIds.length
	if (numUnseenNotifs > 0 && readNotifsIds.length > 0) {
	args['since'] = Math.max(...readNotifsIds)
	fetchNotifications({ store, args, older })
	}

	return result
	}
	}

	const fetchNotifications = ({ store, args, older }) => {
	return apiService.fetchTimeline(args)
	.then(({ data: notifications }) => {
	update({ store, notifications, older })
	return notifications
	}, () => store.dispatch('setNotificationsError', { value: true }))
	.catch(() => store.dispatch('setNotificationsError', { value: true }))
	}

	const startFetching = ({ credentials, store }) => {
	// Initially there's set flag to silence all desktop notifications so
	// that there won't spam of them when user just opened up the FE we
	// reset that flag after a while to show new notifications once again.
	setTimeout(() => store.dispatch('setNotificationsSilence', false), 10000)
	const boundFetchAndUpdate = () => fetchAndUpdate({ credentials, store })
	boundFetchAndUpdate()
	- return makeFetcher(boundFetchAndUpdate, 10000)
	+ return promiseInterval(boundFetchAndUpdate, 10000)
	}

	const notificationsFetcher = {
	fetchAndUpdate,
	startFetching
	}

	export default notificationsFetcher
	diff --git a/src/services/fetcher/fetcher.js b/src/services/promise_interval/promise_interval.js
	similarity index 68%
	rename from src/services/fetcher/fetcher.js
	rename to src/services/promise_interval/promise_interval.js
	index aae1c2cc19..ee46a236f0 100644
	--- a/src/services/fetcher/fetcher.js
	+++ b/src/services/promise_interval/promise_interval.js
	@@ -1,28 +1,28 @@

	-// makeFetcher - replacement for setInterval for fetching, starts counting
	-// the interval only after a request is done instead of immediately.
	+// promiseInterval - replacement for setInterval for promises, starts counting
	+// the interval only after a promise is done instead of immediately.
	// - promiseCall is a function that returns a promise, it's called the first
	// time after the first interval.
	// - interval is the interval delay in ms.

	-export const makeFetcher = (promiseCall, interval) => {
	+export const promiseInterval = (promiseCall, interval) => {
	let stopped = false
	let timeout = null
	let func = () => {}

	func = () => {
	promiseCall().finally(() => {
	if (stopped) return
	timeout = window.setTimeout(func, interval)
	})
	}

	const stopFetcher = () => {
	stopped = true
	window.clearTimeout(timeout)
	}

	timeout = window.setTimeout(func, interval)

	- return stopFetcher
	+ return { stop: stopFetcher }
	}
	diff --git a/src/services/timeline_fetcher/timeline_fetcher.service.js b/src/services/timeline_fetcher/timeline_fetcher.service.js
	index 9f585f68c1..72ea4890ae 100644
	--- a/src/services/timeline_fetcher/timeline_fetcher.service.js
	+++ b/src/services/timeline_fetcher/timeline_fetcher.service.js
	@@ -1,84 +1,84 @@
	import { camelCase } from 'lodash'

	import apiService from '../api/api.service.js'
	-import { makeFetcher } from '../fetcher/fetcher.js'
	+import { promiseInterval } from '../promise_interval/promise_interval.js'

	const update = ({ store, statuses, timeline, showImmediately, userId, pagination }) => {
	const ccTimeline = camelCase(timeline)

	store.dispatch('setError', { value: false })
	store.dispatch('setErrorData', { value: null })

	store.dispatch('addNewStatuses', {
	timeline: ccTimeline,
	userId,
	statuses,
	showImmediately,
	pagination
	})
	}

	const fetchAndUpdate = ({
	store,
	credentials,
	timeline = 'friends',
	older = false,
	showImmediately = false,
	userId = false,
	tag = false,
	until
	}) => {
	const args = { timeline, credentials }
	const rootState = store.rootState \|\| store.state
	const { getters } = store
	const timelineData = rootState.statuses.timelines[camelCase(timeline)]
	const { hideMutedPosts, replyVisibility } = getters.mergedConfig
	const loggedIn = !!rootState.users.currentUser

	if (older) {
	args['until'] = until \|\| timelineData.minId
	} else {
	args['since'] = timelineData.maxId
	}

	args['userId'] = userId
	args['tag'] = tag
	args['withMuted'] = !hideMutedPosts
	if (loggedIn && ['friends', 'public', 'publicAndExternal'].includes(timeline)) {
	args['replyVisibility'] = replyVisibility
	}

	const numStatusesBeforeFetch = timelineData.statuses.length

	return apiService.fetchTimeline(args)
	.then(response => {
	if (response.error) {
	store.dispatch('setErrorData', { value: response })
	return
	}

	const { data: statuses, pagination } = response
	if (!older && statuses.length >= 20 && !timelineData.loading && numStatusesBeforeFetch > 0) {
	store.dispatch('queueFlush', { timeline: timeline, id: timelineData.maxId })
	}
	update({ store, statuses, timeline, showImmediately, userId, pagination })
	return { statuses, pagination }
	}, () => store.dispatch('setError', { value: true }))
	}

	const startFetching = ({ timeline = 'friends', credentials, store, userId = false, tag = false }) => {
	const rootState = store.rootState \|\| store.state
	const timelineData = rootState.statuses.timelines[camelCase(timeline)]
	const showImmediately = timelineData.visibleStatuses.length === 0
	timelineData.userId = userId
	fetchAndUpdate({ timeline, credentials, store, showImmediately, userId, tag })
	const boundFetchAndUpdate = () =>
	fetchAndUpdate({ timeline, credentials, store, userId, tag })
	- return makeFetcher(boundFetchAndUpdate, 10000)
	+ return promiseInterval(boundFetchAndUpdate, 10000)
	}
	const timelineFetcher = {
	fetchAndUpdate,
	startFetching
	}

	export default timelineFetcher

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 31, 10:30 PM (19 h, 39 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1801870
Default Alt Text: (37 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions