pleroma-fe/src/modules/users.js

427 lines
14 KiB
JavaScript
Raw Normal View History

import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js'
2019-03-27 20:02:46 +00:00
import { compact, map, each, merge, find, last } from 'lodash'
2017-02-13 22:22:32 +00:00
import { set } from 'vue'
import { registerPushNotifications, unregisterPushNotifications } from '../services/push/push.js'
import oauthApi from '../services/new_api/oauth'
import { humanizeErrors } from './errors'
2016-10-27 16:03:14 +00:00
2016-11-30 17:29:44 +00:00
// TODO: Unify with mergeOrAdd in statuses.js
2017-03-08 16:59:12 +00:00
export const mergeOrAdd = (arr, obj, item) => {
2016-11-30 22:32:22 +00:00
if (!item) { return false }
2017-03-08 16:59:12 +00:00
const oldItem = obj[item.id]
2016-11-30 17:29:44 +00:00
if (oldItem) {
// We already have this, so only merge the new info.
merge(oldItem, item)
return { item: oldItem, new: false }
2016-11-30 17:29:44 +00:00
} else {
// This is a new item, prepare it
arr.push(item)
2019-03-21 22:05:20 +00:00
set(obj, item.id, item)
if (item.screen_name && !item.screen_name.includes('@')) {
2019-03-21 22:05:20 +00:00
set(obj, item.screen_name.toLowerCase(), item)
}
return { item, new: true }
2016-11-30 17:29:44 +00:00
}
}
2018-12-13 11:04:09 +00:00
const getNotificationPermission = () => {
const Notification = window.Notification
if (!Notification) return Promise.resolve(null)
if (Notification.permission === 'default') return Notification.requestPermission()
return Promise.resolve(Notification.permission)
}
2016-11-30 17:29:44 +00:00
export const mutations = {
setMuted (state, { user: { id }, muted }) {
2017-03-08 17:04:21 +00:00
const user = state.usersObject[id]
2017-02-13 22:22:32 +00:00
set(user, 'muted', muted)
},
2019-02-18 14:49:32 +00:00
tagUser (state, { user: { id }, tag }) {
const user = state.usersObject[id]
const tags = user.tags || []
const newTags = tags.concat([tag])
set(user, 'tags', newTags)
},
untagUser (state, { user: { id }, tag }) {
const user = state.usersObject[id]
const tags = user.tags || []
const newTags = tags.filter(t => t !== tag)
set(user, 'tags', newTags)
},
updateRight (state, { user: { id }, right, value }) {
const user = state.usersObject[id]
let newRights = user.rights
newRights[right] = value
set(user, 'rights', newRights)
},
updateActivationStatus (state, { user: { id }, status }) {
const user = state.usersObject[id]
set(user, 'deactivated', !status)
},
2016-11-30 17:29:44 +00:00
setCurrentUser (state, user) {
state.lastLoginName = user.screen_name
state.currentUser = merge(state.currentUser || {}, user)
2016-10-27 16:03:14 +00:00
},
2017-07-02 10:25:34 +00:00
clearCurrentUser (state) {
state.currentUser = false
state.lastLoginName = false
2017-07-02 10:25:34 +00:00
},
2016-11-30 17:29:44 +00:00
beginLogin (state) {
state.loggingIn = true
},
endLogin (state) {
state.loggingIn = false
2016-10-27 16:03:14 +00:00
},
// TODO Clean after ourselves?
2019-03-25 19:04:52 +00:00
addFriends (state, { id, friends }) {
const user = state.usersObject[id]
each(friends, friend => {
if (!find(user.friends, { id: friend.id })) {
user.friends.push(friend)
}
})
user.lastFriendId = friends.length ? last(friends).id : last(user.friends).id
},
2019-03-25 19:04:52 +00:00
addFollowers (state, { id, followers }) {
const user = state.usersObject[id]
each(followers, follower => {
if (!find(user.followers, { id: follower.id })) {
user.followers.push(follower)
}
})
2019-03-27 20:02:46 +00:00
user.lastFollowerId = last(followers).id
},
// Because frontend doesn't have a reason to keep these stuff in memory
// outside of viewing someones user profile.
2019-02-25 09:51:23 +00:00
clearFriends (state, userId) {
const user = state.usersObject[userId]
if (!user) {
return
}
user.friends = []
2019-03-25 19:04:52 +00:00
user.lastFriendId = null
2019-02-25 09:51:23 +00:00
},
clearFollowers (state, userId) {
const user = state.usersObject[userId]
if (!user) {
return
}
user.followers = []
2019-03-25 19:04:52 +00:00
user.lastFollowerId = null
},
2016-11-30 17:29:44 +00:00
addNewUsers (state, users) {
2017-03-08 16:59:12 +00:00
each(users, (user) => mergeOrAdd(state.users, state.usersObject, user))
},
updateUserRelationship (state, relationships) {
relationships.forEach((relationship) => {
const user = state.usersObject[relationship.id]
2019-03-14 16:50:51 +00:00
if (user) {
user.follows_you = relationship.followed_by
user.following = relationship.following
user.muted = relationship.muting
user.statusnet_blocking = relationship.blocking
}
})
},
updateBlocks (state, blockedUsers) {
// Reset statusnet_blocking of all fetched users
each(state.users, (user) => { user.statusnet_blocking = false })
each(blockedUsers, (user) => mergeOrAdd(state.users, state.usersObject, user))
},
saveBlockIds (state, blockIds) {
state.currentUser.blockIds = blockIds
2019-02-13 17:05:23 +00:00
},
updateMutes (state, mutedUsers) {
2019-03-02 13:21:15 +00:00
// Reset muted of all fetched users
each(state.users, (user) => { user.muted = false })
2019-03-22 01:31:16 +00:00
each(mutedUsers, (user) => mergeOrAdd(state.users, state.usersObject, user))
},
saveMuteIds (state, muteIds) {
state.currentUser.muteIds = muteIds
2019-02-14 03:04:28 +00:00
},
setUserForStatus (state, status) {
2017-03-08 17:04:21 +00:00
status.user = state.usersObject[status.user.id]
2018-06-18 08:36:58 +00:00
},
2018-12-26 09:19:25 +00:00
setUserForNotification (state, notification) {
2019-04-01 01:59:18 +00:00
if (notification.type !== 'follow') {
notification.action.user = state.usersObject[notification.action.user.id]
}
2019-03-31 18:50:34 +00:00
notification.from_profile = state.usersObject[notification.from_profile.id]
2018-12-26 09:19:25 +00:00
},
setColor (state, { user: { id }, highlighted }) {
2018-06-18 08:36:58 +00:00
const user = state.usersObject[id]
set(user, 'highlight', highlighted)
},
signUpPending (state) {
state.signUpPending = true
state.signUpErrors = []
},
signUpSuccess (state) {
state.signUpPending = false
},
signUpFailure (state, errors) {
state.signUpPending = false
state.signUpErrors = errors
2016-11-30 17:29:44 +00:00
}
}
export const getters = {
findUser: state => query => {
const result = state.usersObject[query]
// In case it's a screen_name, we can try searching case-insensitive
if (!result && typeof query === 'string') {
return state.usersObject[query.toLowerCase()]
}
return result
}
}
2016-11-30 17:29:44 +00:00
export const defaultState = {
loggingIn: false,
lastLoginName: false,
2016-11-30 17:29:44 +00:00
currentUser: false,
2017-03-08 16:59:12 +00:00
users: [],
usersObject: {},
signUpPending: false,
signUpErrors: []
2016-11-30 17:29:44 +00:00
}
const users = {
state: defaultState,
mutations,
getters,
2016-10-27 16:03:14 +00:00
actions: {
fetchUser (store, id) {
return store.rootState.api.backendInteractor.fetchUser({ id })
.then((user) => {
store.commit('addNewUsers', [user])
return user
})
},
fetchUserRelationship (store, id) {
return store.rootState.api.backendInteractor.fetchUserRelationship({ id })
.then((relationships) => store.commit('updateUserRelationship', relationships))
},
2019-02-13 17:05:23 +00:00
fetchBlocks (store) {
return store.rootState.api.backendInteractor.fetchBlocks()
2019-02-13 17:05:23 +00:00
.then((blocks) => {
store.commit('saveBlockIds', map(blocks, 'id'))
store.commit('updateBlocks', blocks)
2019-02-13 17:05:23 +00:00
return blocks
})
},
blockUser (store, userId) {
return store.rootState.api.backendInteractor.blockUser(userId)
2019-03-22 01:44:59 +00:00
.then((relationship) => {
store.commit('updateUserRelationship', [relationship])
store.commit('removeStatus', { timeline: 'friends', userId })
store.commit('removeStatus', { timeline: 'public', userId })
store.commit('removeStatus', { timeline: 'publicAndExternal', userId })
})
2019-02-13 20:31:20 +00:00
},
unblockUser (store, id) {
return store.rootState.api.backendInteractor.unblockUser(id)
2019-03-22 01:44:59 +00:00
.then((relationship) => store.commit('updateUserRelationship', [relationship]))
2019-02-13 20:31:20 +00:00
},
2019-02-14 03:04:28 +00:00
fetchMutes (store) {
return store.rootState.api.backendInteractor.fetchMutes()
.then((mutes) => {
store.commit('updateMutes', mutes)
store.commit('saveMuteIds', map(mutes, 'id'))
return mutes
2019-02-14 03:04:28 +00:00
})
},
muteUser (store, id) {
return store.rootState.api.backendInteractor.muteUser(id)
2019-03-22 01:53:24 +00:00
.then((relationship) => store.commit('updateUserRelationship', [relationship]))
2019-02-14 03:04:28 +00:00
},
unmuteUser (store, id) {
return store.rootState.api.backendInteractor.unmuteUser(id)
2019-03-22 01:53:24 +00:00
.then((relationship) => store.commit('updateUserRelationship', [relationship]))
2019-02-14 03:04:28 +00:00
},
addFriends ({ rootState, commit }, fetchBy) {
return new Promise((resolve, reject) => {
const user = rootState.users.usersObject[fetchBy]
2019-03-27 20:04:59 +00:00
const maxId = user.lastFriendId
rootState.api.backendInteractor.fetchFriends({ id: user.id, maxId })
.then((friends) => {
2019-03-25 19:04:52 +00:00
commit('addFriends', { id: user.id, friends })
resolve(friends)
}).catch(() => {
reject()
})
})
},
addFollowers ({ rootState, commit }, fetchBy) {
2019-02-25 07:11:39 +00:00
const user = rootState.users.usersObject[fetchBy]
2019-03-27 20:04:59 +00:00
const maxId = user.lastFollowerId
return rootState.api.backendInteractor.fetchFollowers({ id: user.id, maxId })
2019-02-25 07:11:39 +00:00
.then((followers) => {
2019-03-25 19:04:52 +00:00
commit('addFollowers', { id: user.id, followers })
2019-02-25 07:11:39 +00:00
return followers
})
},
2019-02-25 09:51:23 +00:00
clearFriends ({ commit }, userId) {
commit('clearFriends', userId)
},
clearFollowers ({ commit }, userId) {
commit('clearFollowers', userId)
},
2018-12-10 15:36:25 +00:00
registerPushNotifications (store) {
const token = store.state.currentUser.credentials
const vapidPublicKey = store.rootState.instance.vapidPublicKey
const isEnabled = store.rootState.config.webPushNotifications
2018-12-25 13:43:18 +00:00
const notificationVisibility = store.rootState.config.notificationVisibility
2018-12-10 15:36:25 +00:00
2018-12-25 13:43:18 +00:00
registerPushNotifications(isEnabled, vapidPublicKey, token, notificationVisibility)
2018-12-10 15:36:25 +00:00
},
unregisterPushNotifications (store) {
const token = store.state.currentUser.credentials
unregisterPushNotifications(token)
},
2016-11-30 17:29:44 +00:00
addNewStatuses (store, { statuses }) {
const users = map(statuses, 'user')
const retweetedUsers = compact(map(statuses, 'retweeted_status.user'))
2016-11-30 17:29:44 +00:00
store.commit('addNewUsers', users)
store.commit('addNewUsers', retweetedUsers)
2017-02-13 23:01:50 +00:00
// Reconnect users to statuses
each(statuses, (status) => {
store.commit('setUserForStatus', status)
2017-02-13 23:01:50 +00:00
})
// Reconnect users to retweets
each(compact(map(statuses, 'retweeted_status')), (status) => {
store.commit('setUserForStatus', status)
2017-02-13 23:01:50 +00:00
})
2016-11-30 17:29:44 +00:00
},
2018-12-26 09:19:25 +00:00
addNewNotifications (store, { notifications }) {
const users = map(notifications, 'from_profile')
const notificationIds = notifications.map(_ => _.id)
2018-12-26 09:19:25 +00:00
store.commit('addNewUsers', users)
const notificationsObject = store.rootState.statuses.notifications.idStore
const relevantNotifications = Object.entries(notificationsObject)
.filter(([k, val]) => notificationIds.includes(k))
.map(([k, val]) => val)
// Reconnect users to notifications
each(relevantNotifications, (notification) => {
store.commit('setUserForNotification', notification)
})
},
async signUp (store, userInfo) {
store.commit('signUpPending')
let rootState = store.rootState
let response = await rootState.api.backendInteractor.register(userInfo)
if (response.ok) {
const data = {
oauth: rootState.oauth,
instance: rootState.instance.server
}
let app = await oauthApi.getOrCreateApp(data)
let result = await oauthApi.getTokenWithCredentials({
app,
instance: data.instance,
username: userInfo.username,
password: userInfo.password
})
store.commit('signUpSuccess')
store.commit('setToken', result.access_token)
store.dispatch('loginUser', result.access_token)
} else {
2019-02-19 14:22:42 +00:00
const data = await response.json()
let errors = JSON.parse(data.error)
// replace ap_id with username
if (errors.ap_id) {
errors.username = errors.ap_id
delete errors.ap_id
}
errors = humanizeErrors(errors)
store.commit('signUpFailure', errors)
throw Error(errors)
}
},
async getCaptcha (store) {
return await store.rootState.api.backendInteractor.getCaptcha()
},
2017-07-02 10:25:34 +00:00
logout (store) {
store.commit('clearCurrentUser')
store.dispatch('disconnectFromChat')
2018-10-26 13:16:23 +00:00
store.commit('setToken', false)
2017-07-02 10:25:34 +00:00
store.dispatch('stopFetching', 'friends')
store.commit('setBackendInteractor', backendInteractorService())
2019-04-03 16:04:46 +00:00
store.dispatch('stopFetching', 'notifications')
store.commit('clearNotifications')
store.commit('resetStatuses')
2017-07-02 10:25:34 +00:00
},
2018-10-26 13:16:23 +00:00
loginUser (store, accessToken) {
return new Promise((resolve, reject) => {
const commit = store.commit
commit('beginLogin')
2018-10-26 13:16:23 +00:00
store.rootState.api.backendInteractor.verifyCredentials(accessToken)
2019-01-17 19:11:51 +00:00
.then((data) => {
if (!data.error) {
2019-01-17 20:01:38 +00:00
const user = data
2019-01-17 19:11:51 +00:00
// user.credentials = userCredentials
user.credentials = accessToken
user.blockIds = []
user.muteIds = []
2019-01-17 19:11:51 +00:00
commit('setCurrentUser', user)
commit('addNewUsers', [user])
2016-11-30 20:27:25 +00:00
2019-01-17 19:11:51 +00:00
getNotificationPermission()
.then(permission => commit('setNotificationPermission', permission))
2018-12-13 11:04:09 +00:00
2019-01-17 19:11:51 +00:00
// Set our new backend interactor
commit('setBackendInteractor', backendInteractorService(accessToken))
2016-11-30 20:27:25 +00:00
2019-01-17 19:11:51 +00:00
if (user.token) {
store.dispatch('setWsToken', user.token)
// Initialize the chat socket.
store.dispatch('initializeSocket')
2019-01-17 19:11:51 +00:00
}
2017-12-04 18:08:33 +00:00
// Start getting fresh posts.
2019-04-04 16:03:56 +00:00
store.dispatch('startFetchingTimeline', { timeline: 'friends' })
2019-04-03 16:04:46 +00:00
// Start fetching notifications
2019-04-04 16:03:56 +00:00
store.dispatch('startFetchingNotifications')
// Get user mutes
2019-02-14 03:04:28 +00:00
store.dispatch('fetchMutes')
2019-01-17 19:11:51 +00:00
// Fetch our friends
store.rootState.api.backendInteractor.fetchFriends({ id: user.id })
.then((friends) => commit('addNewUsers', friends))
} else {
2019-01-17 19:11:51 +00:00
const response = data.error
// Authentication failed
commit('endLogin')
if (response.status === 401) {
reject('Wrong username or password')
} else {
2017-03-08 18:31:39 +00:00
reject('An error occurred, please try again')
}
}
commit('endLogin')
resolve()
})
2019-01-17 19:11:51 +00:00
.catch((error) => {
console.log(error)
commit('endLogin')
reject('Failed to connect to server, try again')
})
})
2016-10-27 16:03:14 +00:00
}
}
}
export default users