akkoma-fe/src/modules/statuses.js

786 lines
27 KiB
JavaScript
Raw Normal View History

import {
remove,
slice,
each,
findIndex,
find,
maxBy,
minBy,
merge,
first,
last,
isArray,
omitBy
} from 'lodash'
2019-03-21 22:05:20 +00:00
import { set } from 'vue'
import { isStatusNotification } from '../services/notification_utils/notification_utils.js'
2016-10-30 15:12:35 +00:00
import apiService from '../services/api/api.service.js'
import { muteWordHits } from '../services/status_parser/status_parser.js'
2016-10-26 17:03:55 +00:00
const emptyTl = (userId = 0) => ({
statuses: [],
statusesObject: {},
faves: [],
visibleStatuses: [],
visibleStatusesObject: {},
newStatusCount: 0,
maxId: 0,
2019-02-28 01:45:08 +00:00
minId: 0,
minVisibleId: 0,
loading: false,
followers: [],
friends: [],
userId,
flushMarker: 0
})
2019-04-03 16:04:46 +00:00
const emptyNotifications = () => ({
desktopNotificationSilence: true,
maxId: 0,
minId: Number.POSITIVE_INFINITY,
data: [],
idStore: {},
loading: false,
2019-04-03 16:08:23 +00:00
error: false
2019-04-03 16:04:46 +00:00
})
export const defaultState = () => ({
2016-10-26 17:03:55 +00:00
allStatuses: [],
2017-03-08 20:04:48 +00:00
allStatusesObject: {},
2019-04-11 16:46:06 +00:00
conversationsObject: {},
2016-10-26 17:03:55 +00:00
maxId: 0,
2019-04-03 16:04:46 +00:00
notifications: emptyNotifications(),
2016-11-25 15:56:08 +00:00
favorites: new Set(),
error: false,
2019-12-09 01:31:57 +00:00
errorData: null,
2016-10-26 17:03:55 +00:00
timelines: {
mentions: emptyTl(),
public: emptyTl(),
user: emptyTl(),
favorites: emptyTl(),
2019-01-24 10:48:40 +00:00
media: emptyTl(),
publicAndExternal: emptyTl(),
friends: emptyTl(),
tag: emptyTl(),
dms: emptyTl()
2016-10-26 17:03:55 +00:00
}
})
2016-10-26 17:03:55 +00:00
2016-11-15 09:35:16 +00:00
export const prepareStatus = (status) => {
// Set deleted flag
status.deleted = false
2016-12-01 17:05:20 +00:00
// To make the array reactive
status.attachments = status.attachments || []
2016-11-15 09:35:16 +00:00
return status
}
const visibleNotificationTypes = (rootState) => {
return [
rootState.config.notificationVisibility.likes && 'like',
rootState.config.notificationVisibility.mentions && 'mention',
rootState.config.notificationVisibility.repeats && 'repeat',
2019-12-10 15:00:10 +00:00
rootState.config.notificationVisibility.follows && 'follow',
rootState.config.notificationVisibility.moves && 'move',
rootState.config.notificationVisibility.emojiReactions && 'pleroma:emoji_reactions'
].filter(_ => _)
}
2017-03-08 20:04:48 +00:00
const mergeOrAdd = (arr, obj, item) => {
const oldItem = obj[item.id]
if (oldItem) {
// We already have this, so only merge the new info.
// We ignore null values to avoid overwriting existing properties with missing data
// we also skip 'user' because that is handled by users module
merge(oldItem, omitBy(item, (v, k) => v === null || k === 'user'))
2016-12-01 17:05:20 +00:00
// Reactivity fix.
oldItem.attachments.splice(oldItem.attachments.length)
2019-07-05 07:02:14 +00:00
return { item: oldItem, new: false }
} else {
// This is a new item, prepare it
prepareStatus(item)
arr.push(item)
2019-03-21 22:05:20 +00:00
set(obj, item.id, item)
2019-07-05 07:02:14 +00:00
return { item, new: true }
}
}
const sortById = (a, b) => {
const seqA = Number(a.id)
const seqB = Number(b.id)
2019-01-24 22:39:19 +00:00
const isSeqA = !Number.isNaN(seqA)
const isSeqB = !Number.isNaN(seqB)
if (isSeqA && isSeqB) {
return seqA > seqB ? -1 : 1
} else if (isSeqA && !isSeqB) {
return 1
} else if (!isSeqA && isSeqB) {
return -1
} else {
return a.id > b.id ? -1 : 1
}
}
2016-12-03 11:43:21 +00:00
const sortTimeline = (timeline) => {
timeline.visibleStatuses = timeline.visibleStatuses.sort(sortById)
timeline.statuses = timeline.statuses.sort(sortById)
timeline.minVisibleId = (last(timeline.visibleStatuses) || {}).id
2016-12-03 11:43:21 +00:00
return timeline
}
2019-04-11 16:46:06 +00:00
// Add status to the global storages (arrays and objects maintaining statuses) except timelines
const addStatusToGlobalStorage = (state, data) => {
const result = mergeOrAdd(state.allStatuses, state.allStatusesObject, data)
if (result.new) {
// Add to conversation
const status = result.item
const conversationsObject = state.conversationsObject
const conversationId = status.statusnet_conversation_id
if (conversationsObject[conversationId]) {
conversationsObject[conversationId].push(status)
} else {
set(conversationsObject, conversationId, [status])
}
}
return result
}
// Remove status from the global storages (arrays and objects maintaining statuses) except timelines
const removeStatusFromGlobalStorage = (state, status) => {
remove(state.allStatuses, { id: status.id })
// TODO: Need to remove from allStatusesObject?
// Remove possible notification
2019-07-05 07:02:14 +00:00
remove(state.notifications.data, ({ action: { id } }) => id === status.id)
2019-04-11 16:46:06 +00:00
// Remove from conversation
const conversationId = status.statusnet_conversation_id
if (state.conversationsObject[conversationId]) {
remove(state.conversationsObject[conversationId], { id: status.id })
}
}
2019-06-21 01:31:00 +00:00
const addNewStatuses = (state, { statuses, showImmediately = false, timeline, user = {},
2019-06-24 03:01:13 +00:00
noIdUpdate = false, userId }) => {
// Sanity check
if (!isArray(statuses)) {
return false
}
2016-11-21 15:33:08 +00:00
const allStatuses = state.allStatuses
const timelineObject = state.timelines[timeline]
2016-11-15 09:35:16 +00:00
const maxNew = statuses.length > 0 ? maxBy(statuses, 'id').id : 0
2019-02-28 01:45:08 +00:00
const minNew = statuses.length > 0 ? minBy(statuses, 'id').id : 0
const newer = timeline && (maxNew > timelineObject.maxId || timelineObject.maxId === 0) && statuses.length > 0
2019-02-28 01:45:08 +00:00
const older = timeline && (minNew < timelineObject.minId || timelineObject.minId === 0) && statuses.length > 0
2019-02-28 01:45:08 +00:00
if (!noIdUpdate && newer) {
timelineObject.maxId = maxNew
2016-11-21 15:33:08 +00:00
}
2019-02-28 01:45:08 +00:00
if (!noIdUpdate && older) {
timelineObject.minId = minNew
}
// This makes sure that user timeline won't get data meant for other
// user. I.e. opening different user profiles makes request which could
// return data late after user already viewing different user profile
if ((timeline === 'user' || timeline === 'media') && timelineObject.userId !== userId) {
return
}
const addStatus = (data, showImmediately, addToTimeline = true) => {
2019-04-11 16:46:06 +00:00
const result = addStatusToGlobalStorage(state, data)
const status = result.item
2016-11-21 15:33:08 +00:00
if (result.new) {
2016-12-03 11:43:21 +00:00
// We are mentioned in a post
if (status.type === 'status' && find(status.attentions, { id: user.id })) {
2016-12-03 11:43:21 +00:00
const mentions = state.timelines.mentions
// Add the mention to the mentions timeline
if (timelineObject !== mentions) {
2017-03-08 20:04:48 +00:00
mergeOrAdd(mentions.statuses, mentions.statusesObject, status)
mentions.newStatusCount += 1
2016-12-03 11:43:21 +00:00
sortTimeline(mentions)
}
2016-11-27 18:11:05 +00:00
}
2018-11-25 16:11:57 +00:00
if (status.visibility === 'direct') {
const dms = state.timelines.dms
mergeOrAdd(dms.statuses, dms.statusesObject, status)
dms.newStatusCount += 1
sortTimeline(dms)
}
2016-11-21 15:33:08 +00:00
}
// Decide if we should treat the status as new for this timeline.
let resultForCurrentTimeline
2016-11-21 15:33:08 +00:00
// Some statuses should only be added to the global status repository.
if (timeline && addToTimeline) {
2017-03-08 20:04:48 +00:00
resultForCurrentTimeline = mergeOrAdd(timelineObject.statuses, timelineObject.statusesObject, status)
}
2016-11-18 15:05:04 +00:00
if (timeline && showImmediately) {
2016-11-21 15:33:08 +00:00
// Add it directly to the visibleStatuses, don't change
// newStatusCount
2017-03-08 20:04:48 +00:00
mergeOrAdd(timelineObject.visibleStatuses, timelineObject.visibleStatusesObject, status)
} else if (timeline && addToTimeline && resultForCurrentTimeline.new) {
2016-11-21 15:33:08 +00:00
// Just change newStatuscount
timelineObject.newStatusCount += 1
}
2016-11-21 15:33:08 +00:00
return status
}
2018-08-16 10:12:31 +00:00
const favoriteStatus = (favorite, counter) => {
const status = find(allStatuses, { id: favorite.in_reply_to_status_id })
2016-11-21 15:33:08 +00:00
if (status) {
2016-11-25 15:56:08 +00:00
// This is our favorite, so the relevant bit.
if (favorite.user.id === user.id) {
status.favorited = true
} else {
status.fave_num += 1
2016-11-25 15:56:08 +00:00
}
}
2016-11-21 15:33:08 +00:00
return status
}
2016-11-21 15:33:08 +00:00
const processors = {
'status': (status) => {
addStatus(status, showImmediately)
},
'retweet': (status) => {
// RetweetedStatuses are never shown immediately
const retweetedStatus = addStatus(status.retweeted_status, false, false)
let retweet
// If the retweeted status is already there, don't add the retweet
// to the timeline.
if (timeline && find(timelineObject.statuses, (s) => {
if (s.retweeted_status) {
return s.id === retweetedStatus.id || s.retweeted_status.id === retweetedStatus.id
} else {
return s.id === retweetedStatus.id
}
})) {
// Already have it visible (either as the original or another RT), don't add to timeline, don't show.
2016-11-21 15:33:08 +00:00
retweet = addStatus(status, false, false)
} else {
retweet = addStatus(status, showImmediately)
}
2016-11-21 15:33:08 +00:00
retweet.retweeted_status = retweetedStatus
},
'favorite': (favorite) => {
2016-11-25 15:56:08 +00:00
// Only update if this is a new favorite.
// Ignore our own favorites because we get info about likes as response to like request
if (!state.favorites.has(favorite.id)) {
2016-11-25 15:56:08 +00:00
state.favorites.add(favorite.id)
favoriteStatus(favorite)
}
2016-11-21 15:33:08 +00:00
},
'deletion': (deletion) => {
const uri = deletion.uri
2019-07-05 07:02:14 +00:00
const status = find(allStatuses, { uri })
if (!status) {
return
}
2019-04-11 16:46:06 +00:00
removeStatusFromGlobalStorage(state, status)
if (timeline) {
remove(timelineObject.statuses, { uri })
remove(timelineObject.visibleStatuses, { uri })
}
2016-11-21 15:33:08 +00:00
},
'follow': (follow) => {
// NOOP, it is known status but we don't do anything about it for now
},
2016-11-21 15:33:08 +00:00
'default': (unknown) => {
2016-11-27 17:54:51 +00:00
console.log('unknown status type')
2016-11-21 15:33:08 +00:00
console.log(unknown)
}
2016-11-21 15:33:08 +00:00
}
2016-11-21 15:33:08 +00:00
each(statuses, (status) => {
const type = status.type
2016-11-21 15:33:08 +00:00
const processor = processors[type] || processors['default']
processor(status)
})
2019-02-28 01:45:08 +00:00
// Keep the visible statuses sorted
2019-03-01 20:53:24 +00:00
if (timeline) {
sortTimeline(timelineObject)
}
2016-11-21 15:33:08 +00:00
}
2019-04-01 01:59:18 +00:00
const addNewNotifications = (state, { dispatch, notifications, older, visibleNotificationTypes, rootGetters }) => {
each(notifications, (notification) => {
if (isStatusNotification(notification.type)) {
2019-04-11 16:46:06 +00:00
notification.action = addStatusToGlobalStorage(state, notification.action).item
notification.status = notification.status && addStatusToGlobalStorage(state, notification.status).item
2019-04-01 01:59:18 +00:00
}
if (notification.type === 'pleroma:emoji_reaction') {
dispatch('fetchEmojiReactionsBy', notification.status.id)
}
// Only add a new notification if we don't have one for the same action
if (!state.notifications.idStore.hasOwnProperty(notification.id)) {
2019-01-16 14:30:47 +00:00
state.notifications.maxId = notification.id > state.notifications.maxId
? notification.id
: state.notifications.maxId
state.notifications.minId = notification.id < state.notifications.minId
? notification.id
: state.notifications.minId
state.notifications.data.push(notification)
state.notifications.idStore[notification.id] = notification
if ('Notification' in window && window.Notification.permission === 'granted') {
const notifObj = {}
2019-04-01 01:59:18 +00:00
const status = notification.status
const title = notification.from_profile.name
notifObj.icon = notification.from_profile.profile_image_url
let i18nString
switch (notification.type) {
case 'like':
i18nString = 'favorited_you'
break
case 'repeat':
i18nString = 'repeated_you'
break
case 'follow':
i18nString = 'followed_you'
break
2019-12-10 14:54:28 +00:00
case 'move':
2019-12-11 09:20:23 +00:00
i18nString = 'migrated_to'
2019-12-10 14:54:28 +00:00
break
case 'follow_request':
i18nString = 'follow_request'
break
2019-04-01 01:59:18 +00:00
}
if (notification.type === 'pleroma:emoji_reaction') {
notifObj.body = rootGetters.i18n.t('notifications.reacted_with', [notification.emoji])
} else if (i18nString) {
2019-04-01 01:59:18 +00:00
notifObj.body = rootGetters.i18n.t('notifications.' + i18nString)
} else if (isStatusNotification(notification.type)) {
notifObj.body = notification.status.text
2019-04-01 01:59:18 +00:00
}
// Shows first attached non-nsfw image, if any. Should add configuration for this somehow...
2019-04-01 01:59:18 +00:00
if (status && status.attachments && status.attachments.length > 0 && !status.nsfw &&
status.attachments[0].mimetype.startsWith('image/')) {
notifObj.image = status.attachments[0].url
}
2020-05-25 21:22:15 +00:00
const reasonsToMuteNotif = (
notification.seen ||
state.notifications.desktopNotificationSilence ||
!visibleNotificationTypes.includes(notification.type) ||
(
2020-05-25 22:01:25 +00:00
notification.type === 'mention' && status && (
2020-05-25 21:22:15 +00:00
status.muted ||
muteWordHits(status, rootGetters.mergedConfig.muteWords).length === 0
)
)
)
if (!reasonsToMuteNotif) {
let desktopNotification = new window.Notification(title, notifObj)
// Chrome is known for not closing notifications automatically
// according to MDN, anyway.
setTimeout(desktopNotification.close.bind(desktopNotification), 5000)
}
}
} else if (notification.seen) {
state.notifications.idStore[notification.id].seen = true
}
})
}
2019-04-25 01:49:44 +00:00
const removeStatus = (state, { timeline, userId }) => {
2019-02-18 19:39:35 +00:00
const timelineObject = state.timelines[timeline]
2019-04-25 01:49:44 +00:00
if (userId) {
remove(timelineObject.statuses, { user: { id: userId } })
remove(timelineObject.visibleStatuses, { user: { id: userId } })
timelineObject.minVisibleId = timelineObject.visibleStatuses.length > 0 ? last(timelineObject.visibleStatuses).id : 0
timelineObject.maxId = timelineObject.statuses.length > 0 ? first(timelineObject.statuses).id : 0
}
2019-02-18 19:39:35 +00:00
}
2016-11-21 15:33:08 +00:00
export const mutations = {
addNewStatuses,
addNewNotifications,
2019-02-18 19:39:35 +00:00
removeStatus,
showNewStatuses (state, { timeline }) {
const oldTimeline = (state.timelines[timeline])
oldTimeline.newStatusCount = 0
oldTimeline.visibleStatuses = slice(oldTimeline.statuses, 0, 50)
oldTimeline.minVisibleId = last(oldTimeline.visibleStatuses).id
oldTimeline.minId = oldTimeline.minVisibleId
2017-03-08 20:04:48 +00:00
oldTimeline.visibleStatusesObject = {}
each(oldTimeline.visibleStatuses, (status) => { oldTimeline.visibleStatusesObject[status.id] = status })
},
resetStatuses (state) {
const emptyState = defaultState()
2019-02-28 19:44:43 +00:00
Object.entries(emptyState).forEach(([key, value]) => {
state[key] = value
})
},
clearTimeline (state, { timeline, excludeUserId = false }) {
const userId = excludeUserId ? state.timelines[timeline].userId : undefined
state.timelines[timeline] = emptyTl(userId)
2017-06-12 14:30:56 +00:00
},
2019-04-03 16:04:46 +00:00
clearNotifications (state) {
state.notifications = emptyNotifications()
},
setFavorited (state, { status, value }) {
2017-03-08 20:04:48 +00:00
const newStatus = state.allStatusesObject[status.id]
2019-05-08 03:19:46 +00:00
if (newStatus.favorited !== value) {
if (value) {
newStatus.fave_num++
} else {
newStatus.fave_num--
}
}
newStatus.favorited = value
},
setFavoritedConfirm (state, { status, user }) {
const newStatus = state.allStatusesObject[status.id]
newStatus.favorited = status.favorited
newStatus.fave_num = status.fave_num
const index = findIndex(newStatus.favoritedBy, { id: user.id })
if (index !== -1 && !newStatus.favorited) {
newStatus.favoritedBy.splice(index, 1)
} else if (index === -1 && newStatus.favorited) {
newStatus.favoritedBy.push(user)
}
},
setMutedStatus (state, status) {
const newStatus = state.allStatusesObject[status.id]
newStatus.thread_muted = status.thread_muted
if (newStatus.thread_muted !== undefined) {
state.conversationsObject[newStatus.statusnet_conversation_id].forEach(status => { status.thread_muted = newStatus.thread_muted })
}
},
2016-11-13 16:09:16 +00:00
setRetweeted (state, { status, value }) {
2017-03-08 20:04:48 +00:00
const newStatus = state.allStatusesObject[status.id]
if (newStatus.repeated !== value) {
if (value) {
newStatus.repeat_num++
} else {
newStatus.repeat_num--
}
}
2016-11-13 16:09:16 +00:00
newStatus.repeated = value
},
setRetweetedConfirm (state, { status, user }) {
const newStatus = state.allStatusesObject[status.id]
newStatus.repeated = status.repeated
newStatus.repeat_num = status.repeat_num
const index = findIndex(newStatus.rebloggedBy, { id: user.id })
if (index !== -1 && !newStatus.repeated) {
newStatus.rebloggedBy.splice(index, 1)
} else if (index === -1 && newStatus.repeated) {
newStatus.rebloggedBy.push(user)
}
},
setDeleted (state, { status }) {
2017-03-08 20:04:48 +00:00
const newStatus = state.allStatusesObject[status.id]
newStatus.deleted = true
},
2019-02-18 14:49:32 +00:00
setManyDeleted (state, condition) {
Object.values(state.allStatusesObject).forEach(status => {
if (condition(status)) {
status.deleted = true
}
})
},
setLoading (state, { timeline, value }) {
state.timelines[timeline].loading = value
},
setNsfw (state, { id, nsfw }) {
2017-03-08 20:04:48 +00:00
const newStatus = state.allStatusesObject[id]
2016-11-07 17:47:38 +00:00
newStatus.nsfw = nsfw
},
setError (state, { value }) {
state.error = value
},
2019-12-09 00:02:34 +00:00
setErrorData (state, { value }) {
state.errorData = value
2019-12-05 02:48:37 +00:00
},
setNotificationsLoading (state, { value }) {
state.notifications.loading = value
},
setNotificationsError (state, { value }) {
2018-08-20 17:45:54 +00:00
state.notifications.error = value
},
setNotificationsSilence (state, { value }) {
state.notifications.desktopNotificationSilence = value
},
markNotificationsAsSeen (state) {
each(state.notifications.data, (notification) => {
notification.seen = true
})
},
markSingleNotificationAsSeen (state, { id }) {
const notification = find(state.notifications.data, n => n.id === id)
if (notification) notification.seen = true
},
dismissNotification (state, { id }) {
state.notifications.data = state.notifications.data.filter(n => n.id !== id)
},
updateNotification (state, { id, updater }) {
const notification = find(state.notifications.data, n => n.id === id)
notification && updater(notification)
},
queueFlush (state, { timeline, id }) {
state.timelines[timeline].flushMarker = id
2019-04-02 02:29:45 +00:00
},
2019-06-27 12:14:54 +00:00
addRepeats (state, { id, rebloggedByUsers, currentUser }) {
2019-05-07 20:20:24 +00:00
const newStatus = state.allStatusesObject[id]
2019-05-08 03:21:19 +00:00
newStatus.rebloggedBy = rebloggedByUsers.filter(_ => _)
2019-06-27 12:14:54 +00:00
// repeats stats can be incorrect based on polling condition, let's update them using the most recent data
newStatus.repeat_num = newStatus.rebloggedBy.length
newStatus.repeated = !!newStatus.rebloggedBy.find(({ id }) => currentUser.id === id)
2019-06-18 20:28:31 +00:00
},
2019-06-27 12:14:54 +00:00
addFavs (state, { id, favoritedByUsers, currentUser }) {
const newStatus = state.allStatusesObject[id]
newStatus.favoritedBy = favoritedByUsers.filter(_ => _)
// favorites stats can be incorrect based on polling condition, let's update them using the most recent data
newStatus.fave_num = newStatus.favoritedBy.length
newStatus.favorited = !!newStatus.favoritedBy.find(({ id }) => currentUser.id === id)
2019-06-18 20:28:31 +00:00
},
addEmojiReactionsBy (state, { id, emojiReactions, currentUser }) {
const status = state.allStatusesObject[id]
set(status, 'emoji_reactions', emojiReactions)
},
addOwnReaction (state, { id, emoji, currentUser }) {
const status = state.allStatusesObject[id]
const reactionIndex = findIndex(status.emoji_reactions, { name: emoji })
const reaction = status.emoji_reactions[reactionIndex] || { name: emoji, count: 0, accounts: [] }
const newReaction = {
...reaction,
count: reaction.count + 1,
me: true,
accounts: [
...reaction.accounts,
currentUser
]
}
// Update count of existing reaction if it exists, otherwise append at the end
if (reactionIndex >= 0) {
set(status.emoji_reactions, reactionIndex, newReaction)
} else {
set(status, 'emoji_reactions', [...status.emoji_reactions, newReaction])
}
},
removeOwnReaction (state, { id, emoji, currentUser }) {
const status = state.allStatusesObject[id]
const reactionIndex = findIndex(status.emoji_reactions, { name: emoji })
if (reactionIndex < 0) return
const reaction = status.emoji_reactions[reactionIndex]
const accounts = reaction.accounts || []
const newReaction = {
...reaction,
count: reaction.count - 1,
me: false,
accounts: accounts.filter(acc => acc.id !== currentUser.id)
}
if (newReaction.count > 0) {
set(status.emoji_reactions, reactionIndex, newReaction)
} else {
set(status, 'emoji_reactions', status.emoji_reactions.filter(r => r.name !== emoji))
}
},
2019-06-18 20:28:31 +00:00
updateStatusWithPoll (state, { id, poll }) {
const status = state.allStatusesObject[id]
status.poll = poll
}
}
2016-10-26 17:03:55 +00:00
const statuses = {
state: defaultState(),
2016-10-30 15:12:35 +00:00
actions: {
addNewStatuses ({ rootState, commit }, { statuses, showImmediately = false, timeline = false, noIdUpdate = false, userId }) {
commit('addNewStatuses', { statuses, showImmediately, timeline, noIdUpdate, user: rootState.users.currentUser, userId })
},
2019-04-01 01:59:18 +00:00
addNewNotifications ({ rootState, commit, dispatch, rootGetters }, { notifications, older }) {
commit('addNewNotifications', { visibleNotificationTypes: visibleNotificationTypes(rootState), dispatch, notifications, older, rootGetters })
},
setError ({ rootState, commit }, { value }) {
commit('setError', { value })
},
2019-12-09 00:02:34 +00:00
setErrorData ({ rootState, commit }, { value }) {
commit('setErrorData', { value })
2019-12-05 02:48:37 +00:00
},
setNotificationsLoading ({ rootState, commit }, { value }) {
commit('setNotificationsLoading', { value })
},
setNotificationsError ({ rootState, commit }, { value }) {
commit('setNotificationsError', { value })
},
setNotificationsSilence ({ rootState, commit }, { value }) {
commit('setNotificationsSilence', { value })
},
2019-10-25 02:21:33 +00:00
fetchStatus ({ rootState, dispatch }, id) {
return rootState.api.backendInteractor.fetchStatus({ id })
2019-10-25 02:21:33 +00:00
.then((status) => dispatch('addNewStatuses', { statuses: [status] }))
},
deleteStatus ({ rootState, commit }, status) {
commit('setDeleted', { status })
apiService.deleteStatus({ id: status.id, credentials: rootState.users.currentUser.credentials })
},
2019-02-18 14:49:32 +00:00
markStatusesAsDeleted ({ commit }, condition) {
commit('setManyDeleted', condition)
},
2016-10-30 15:12:35 +00:00
favorite ({ rootState, commit }, status) {
// Optimistic favoriting...
commit('setFavorited', { status, value: true })
rootState.api.backendInteractor.favorite({ id: status.id })
2019-05-08 03:21:19 +00:00
.then(status => commit('setFavoritedConfirm', { status, user: rootState.users.currentUser }))
2016-10-30 15:12:35 +00:00
},
unfavorite ({ rootState, commit }, status) {
2019-05-08 03:36:35 +00:00
// Optimistic unfavoriting...
2016-10-30 15:12:35 +00:00
commit('setFavorited', { status, value: false })
rootState.api.backendInteractor.unfavorite({ id: status.id })
2019-05-08 03:21:19 +00:00
.then(status => commit('setFavoritedConfirm', { status, user: rootState.users.currentUser }))
2016-11-13 16:09:16 +00:00
},
fetchPinnedStatuses ({ rootState, dispatch }, userId) {
rootState.api.backendInteractor.fetchPinnedStatuses({ id: userId })
2019-06-24 03:01:13 +00:00
.then(statuses => dispatch('addNewStatuses', { statuses, timeline: 'user', userId, showImmediately: true, noIdUpdate: true }))
},
2019-08-30 19:57:24 +00:00
pinStatus ({ rootState, dispatch }, statusId) {
return rootState.api.backendInteractor.pinOwnStatus({ id: statusId })
2019-08-30 19:57:24 +00:00
.then((status) => dispatch('addNewStatuses', { statuses: [status] }))
2019-04-24 19:34:30 +00:00
},
2019-08-30 19:57:24 +00:00
unpinStatus ({ rootState, dispatch }, statusId) {
rootState.api.backendInteractor.unpinOwnStatus({ id: statusId })
2019-08-30 19:57:24 +00:00
.then((status) => dispatch('addNewStatuses', { statuses: [status] }))
2019-04-04 16:47:25 +00:00
},
muteConversation ({ rootState, commit }, statusId) {
return rootState.api.backendInteractor.muteConversation({ id: statusId })
.then((status) => commit('setMutedStatus', status))
},
unmuteConversation ({ rootState, commit }, statusId) {
return rootState.api.backendInteractor.unmuteConversation({ id: statusId })
.then((status) => commit('setMutedStatus', status))
},
2016-11-13 16:09:16 +00:00
retweet ({ rootState, commit }, status) {
// Optimistic retweeting...
commit('setRetweeted', { status, value: true })
rootState.api.backendInteractor.retweet({ id: status.id })
2019-05-08 03:21:19 +00:00
.then(status => commit('setRetweetedConfirm', { status: status.retweeted_status, user: rootState.users.currentUser }))
},
2018-06-14 21:17:36 +00:00
unretweet ({ rootState, commit }, status) {
2019-05-08 03:36:35 +00:00
// Optimistic unretweeting...
2018-06-14 21:17:36 +00:00
commit('setRetweeted', { status, value: false })
rootState.api.backendInteractor.unretweet({ id: status.id })
2019-05-08 03:21:19 +00:00
.then(status => commit('setRetweetedConfirm', { status, user: rootState.users.currentUser }))
2018-06-14 21:17:36 +00:00
},
queueFlush ({ rootState, commit }, { timeline, id }) {
commit('queueFlush', { timeline, id })
},
markNotificationsAsSeen ({ rootState, commit }) {
commit('markNotificationsAsSeen')
apiService.markNotificationsAsSeen({
id: rootState.statuses.notifications.maxId,
credentials: rootState.users.currentUser.credentials
})
2019-04-02 02:29:45 +00:00
},
markSingleNotificationAsSeen ({ rootState, commit }, { id }) {
commit('markSingleNotificationAsSeen', { id })
apiService.markNotificationsAsSeen({
single: true,
id,
credentials: rootState.users.currentUser.credentials
})
},
dismissNotificationLocal ({ rootState, commit }, { id }) {
commit('dismissNotification', { id })
},
dismissNotification ({ rootState, commit }, { id }) {
commit('dismissNotification', { id })
rootState.api.backendInteractor.dismissNotification({ id })
},
updateNotification ({ rootState, commit }, { id, updater }) {
commit('updateNotification', { id, updater })
},
fetchFavsAndRepeats ({ rootState, commit }, id) {
2019-04-29 19:36:39 +00:00
Promise.all([
rootState.api.backendInteractor.fetchFavoritedByUsers({ id }),
rootState.api.backendInteractor.fetchRebloggedByUsers({ id })
2019-06-27 12:14:54 +00:00
]).then(([favoritedByUsers, rebloggedByUsers]) => {
commit('addFavs', { id, favoritedByUsers, currentUser: rootState.users.currentUser })
commit('addRepeats', { id, rebloggedByUsers, currentUser: rootState.users.currentUser })
})
},
reactWithEmoji ({ rootState, dispatch, commit }, { id, emoji }) {
const currentUser = rootState.users.currentUser
if (!currentUser) return
commit('addOwnReaction', { id, emoji, currentUser })
2020-01-13 21:47:32 +00:00
rootState.api.backendInteractor.reactWithEmoji({ id, emoji }).then(
ok => {
dispatch('fetchEmojiReactionsBy', id)
}
)
},
unreactWithEmoji ({ rootState, dispatch, commit }, { id, emoji }) {
const currentUser = rootState.users.currentUser
if (!currentUser) return
commit('removeOwnReaction', { id, emoji, currentUser })
2020-01-13 21:47:32 +00:00
rootState.api.backendInteractor.unreactWithEmoji({ id, emoji }).then(
ok => {
dispatch('fetchEmojiReactionsBy', id)
}
)
},
fetchEmojiReactionsBy ({ rootState, commit }, id) {
2020-01-13 21:47:32 +00:00
rootState.api.backendInteractor.fetchEmojiReactions({ id }).then(
emojiReactions => {
commit('addEmojiReactionsBy', { id, emojiReactions, currentUser: rootState.users.currentUser })
}
)
},
2019-06-27 12:14:54 +00:00
fetchFavs ({ rootState, commit }, id) {
rootState.api.backendInteractor.fetchFavoritedByUsers({ id })
2019-06-27 12:14:54 +00:00
.then(favoritedByUsers => commit('addFavs', { id, favoritedByUsers, currentUser: rootState.users.currentUser }))
},
fetchRepeats ({ rootState, commit }, id) {
rootState.api.backendInteractor.fetchRebloggedByUsers({ id })
2019-06-27 12:14:54 +00:00
.then(rebloggedByUsers => commit('addRepeats', { id, rebloggedByUsers, currentUser: rootState.users.currentUser }))
2019-07-15 16:42:27 +00:00
},
search (store, { q, resolve, limit, offset, following }) {
return store.rootState.api.backendInteractor.search2({ q, resolve, limit, offset, following })
.then((data) => {
store.commit('addNewUsers', data.accounts)
store.commit('addNewStatuses', { statuses: data.statuses })
return data
})
2016-10-30 15:12:35 +00:00
}
},
mutations
2016-10-26 17:03:55 +00:00
}
export default statuses