pleroma-fe/src/modules/users.js

625 lines
21 KiB
JavaScript
Raw Normal View History

import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js'
import { windowWidth, windowHeight } from '../services/window_utils/window_utils'
2019-07-02 08:33:40 +00:00
import oauthApi from '../services/new_api/oauth.js'
2019-11-17 13:34:00 +00:00
import { compact, map, each, mergeWith, last, concat, uniq, isArray } from 'lodash'
import { registerPushNotifications, unregisterPushNotifications } from '../services/push/push.js'
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.
2019-11-17 13:34:00 +00:00
mergeWith(oldItem, item, mergeArrayLength)
return { item: oldItem, new: false }
2016-11-30 17:29:44 +00:00
} else {
// This is a new item, prepare it
arr.push(item)
2021-04-25 10:24:08 +00:00
obj[item.id] = item
if (item.screen_name && !item.screen_name.includes('@')) {
2021-04-25 10:24:08 +00:00
obj[item.screen_name.toLowerCase()] = item
}
return { item, new: true }
2016-11-30 17:29:44 +00:00
}
}
2019-11-17 13:34:00 +00:00
const mergeArrayLength = (oldValue, newValue) => {
if (isArray(oldValue) && isArray(newValue)) {
oldValue.length = newValue.length
return mergeWith(oldValue, newValue, mergeArrayLength)
}
}
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)
}
const blockUser = (store, id) => {
return store.rootState.api.backendInteractor.blockUser({ id })
2019-04-04 17:54:52 +00:00
.then((relationship) => {
store.commit('updateUserRelationship', [relationship])
store.commit('addBlockId', id)
store.commit('removeStatus', { timeline: 'friends', userId: id })
store.commit('removeStatus', { timeline: 'public', userId: id })
store.commit('removeStatus', { timeline: 'publicAndExternal', userId: id })
2019-04-04 17:54:52 +00:00
})
}
const unblockUser = (store, id) => {
return store.rootState.api.backendInteractor.unblockUser({ id })
.then((relationship) => store.commit('updateUserRelationship', [relationship]))
}
const removeUserFromFollowers = (store, id) => {
return store.rootState.api.backendInteractor.removeUserFromFollowers({ id })
.then((relationship) => store.commit('updateUserRelationship', [relationship]))
}
const muteUser = (store, id) => {
const predictedRelationship = store.state.relationships[id] || { id }
predictedRelationship.muting = true
store.commit('updateUserRelationship', [predictedRelationship])
store.commit('addMuteId', id)
return store.rootState.api.backendInteractor.muteUser({ id })
.then((relationship) => {
store.commit('updateUserRelationship', [relationship])
store.commit('addMuteId', id)
})
}
const unmuteUser = (store, id) => {
const predictedRelationship = store.state.relationships[id] || { id }
predictedRelationship.muting = false
store.commit('updateUserRelationship', [predictedRelationship])
return store.rootState.api.backendInteractor.unmuteUser({ id })
2019-04-04 17:54:52 +00:00
.then((relationship) => store.commit('updateUserRelationship', [relationship]))
}
const hideReblogs = (store, userId) => {
return store.rootState.api.backendInteractor.followUser({ id: userId, reblogs: false })
.then((relationship) => {
store.commit('updateUserRelationship', [relationship])
})
}
const showReblogs = (store, userId) => {
return store.rootState.api.backendInteractor.followUser({ id: userId, reblogs: true })
.then((relationship) => store.commit('updateUserRelationship', [relationship]))
}
2020-05-08 13:38:46 +00:00
const fetchMascot = (store) => {
return store.rootState.api.backendInteractor.fetchMascot()
.then(({ url }) => store.commit('updateMascot', url))
}
2020-01-15 20:22:54 +00:00
const muteDomain = (store, domain) => {
return store.rootState.api.backendInteractor.muteDomain({ domain })
.then(() => store.commit('addDomainMute', domain))
}
const unmuteDomain = (store, domain) => {
return store.rootState.api.backendInteractor.unmuteDomain({ domain })
.then(() => store.commit('removeDomainMute', domain))
}
2022-06-22 15:46:47 +00:00
const setNote = (store, { id, note }) => {
return store.rootState.api.backendInteractor.setNote({ id, note })
.then((relationship) => store.commit('updateUserRelationship', [relationship]))
}
2016-11-30 17:29:44 +00:00
export const mutations = {
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])
2021-04-25 10:24:08 +00:00
user['tags'] = newTags
2019-02-18 14:49:32 +00:00
},
untagUser (state, { user: { id }, tag }) {
const user = state.usersObject[id]
const tags = user.tags || []
const newTags = tags.filter(t => t !== tag)
2021-04-25 10:24:08 +00:00
user['tags'] = newTags
2019-02-18 14:49:32 +00:00
},
updateRight (state, { user: { id }, right, value }) {
const user = state.usersObject[id]
let newRights = user.rights
newRights[right] = value
2021-04-25 10:24:08 +00:00
user['rights'] = newRights
2019-02-18 14:49:32 +00:00
},
2019-11-19 01:42:10 +00:00
updateActivationStatus (state, { user: { id }, deactivated }) {
2019-02-18 14:49:32 +00:00
const user = state.usersObject[id]
2021-04-25 10:24:08 +00:00
user['deactivated'] = deactivated
2019-02-18 14:49:32 +00:00
},
2016-11-30 17:29:44 +00:00
setCurrentUser (state, user) {
state.lastLoginName = user.screen_name
2019-11-17 13:34:00 +00:00
state.currentUser = mergeWith(state.currentUser || {}, user, mergeArrayLength)
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
},
saveFriendIds (state, { id, friendIds }) {
const user = state.usersObject[id]
user.friendIds = uniq(concat(user.friendIds || [], friendIds))
},
saveFollowerIds (state, { id, followerIds }) {
const user = state.usersObject[id]
user.followerIds = uniq(concat(user.followerIds || [], followerIds))
},
// 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) {
2021-04-25 10:24:08 +00:00
user['friendIds'] = []
}
2019-02-25 09:51:23 +00:00
},
clearFollowers (state, userId) {
const user = state.usersObject[userId]
if (user) {
2021-04-25 10:24:08 +00:00
user['followerIds'] = []
2019-02-25 09:51:23 +00:00
}
},
2016-11-30 17:29:44 +00:00
addNewUsers (state, users) {
2020-04-21 20:27:51 +00:00
each(users, (user) => {
if (user.relationship) {
2021-04-25 10:24:08 +00:00
state.relationships[user.relationship.id] = user.relationship
2020-04-21 20:27:51 +00:00
}
mergeOrAdd(state.users, state.usersObject, user)
})
},
updateUserRelationship (state, relationships) {
relationships.forEach((relationship) => {
2021-04-25 10:24:08 +00:00
state.relationships[relationship.id] = relationship
})
},
saveBlockIds (state, blockIds) {
state.currentUser.blockIds = blockIds
2019-02-13 17:05:23 +00:00
},
addBlockId (state, blockId) {
if (state.currentUser.blockIds.indexOf(blockId) === -1) {
state.currentUser.blockIds.push(blockId)
}
},
saveMuteIds (state, muteIds) {
state.currentUser.muteIds = muteIds
2019-02-14 03:04:28 +00:00
},
addMuteId (state, muteId) {
if (state.currentUser.muteIds.indexOf(muteId) === -1) {
state.currentUser.muteIds.push(muteId)
}
},
2020-05-08 13:38:46 +00:00
updateMascot (state, mascotUrl) {
state.currentUser.mascot = mascotUrl
},
2020-01-15 20:22:54 +00:00
saveDomainMutes (state, domainMutes) {
state.currentUser.domainMutes = domainMutes
},
addDomainMute (state, domain) {
if (state.currentUser.domainMutes.indexOf(domain) === -1) {
state.currentUser.domainMutes.push(domain)
}
},
removeDomainMute (state, domain) {
const index = state.currentUser.domainMutes.indexOf(domain)
if (index !== -1) {
state.currentUser.domainMutes.splice(index, 1)
}
},
2019-08-30 19:55:28 +00:00
setPinnedToUser (state, status) {
const user = state.usersObject[status.user.id]
user.pinnedStatusIds = user.pinnedStatusIds || []
2019-07-20 02:49:29 +00:00
const index = user.pinnedStatusIds.indexOf(status.id)
if (status.pinned && index === -1) {
2019-07-20 02:49:29 +00:00
user.pinnedStatusIds.push(status.id)
} else if (!status.pinned && index !== -1) {
2019-07-20 02:49:29 +00:00
user.pinnedStatusIds.splice(index, 1)
}
},
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]
2021-04-25 10:24:08 +00:00
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
},
2021-06-07 13:16:10 +00:00
findUserByUrl: state => query => {
return state.users
2021-06-07 17:01:57 +00:00
.find(u => u.statusnet_profile_url &&
u.statusnet_profile_url.toLowerCase() === query.toLowerCase())
2021-06-07 13:16:10 +00:00
},
relationship: state => id => {
2020-04-27 07:06:17 +00:00
const rel = id && state.relationships[id]
return rel || { id, loading: true }
}
}
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,
2020-04-21 20:27:51 +00:00
signUpErrors: [],
relationships: {}
2016-11-30 17:29:44 +00:00
}
const users = {
state: defaultState,
mutations,
getters,
2016-10-27 16:03:14 +00:00
actions: {
fetchUserIfMissing (store, id) {
if (!store.getters.findUser(id)) {
store.dispatch('fetchUser', id)
}
},
fetchUser (store, id) {
return store.rootState.api.backendInteractor.fetchUser({ id })
.then((user) => {
store.commit('addNewUsers', [user])
return user
})
},
fetchUserRelationship (store, id) {
if (store.state.currentUser) {
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'))
2020-04-21 20:27:51 +00:00
store.commit('addNewUsers', blocks)
2019-02-13 17:05:23 +00:00
return blocks
})
},
blockUser (store, id) {
return blockUser(store, id)
2019-04-04 17:54:52 +00:00
},
unblockUser (store, id) {
return unblockUser(store, id)
2019-04-04 17:54:52 +00:00
},
removeUserFromFollowers (store, id) {
return removeUserFromFollowers(store, id)
},
blockUsers (store, ids = []) {
return Promise.all(ids.map(id => blockUser(store, id)))
2019-02-13 20:31:20 +00:00
},
unblockUsers (store, ids = []) {
return Promise.all(ids.map(id => unblockUser(store, id)))
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('saveMuteIds', map(mutes, 'id'))
2020-04-21 20:27:51 +00:00
store.commit('addNewUsers', mutes)
return mutes
2019-02-14 03:04:28 +00:00
})
},
muteUser (store, id) {
return muteUser(store, id)
2019-02-14 03:04:28 +00:00
},
unmuteUser (store, id) {
return unmuteUser(store, id)
},
hideReblogs (store, id) {
return hideReblogs(store, id)
},
showReblogs (store, id) {
return showReblogs(store, id)
},
muteUsers (store, ids = []) {
return Promise.all(ids.map(id => muteUser(store, id)))
},
unmuteUsers (store, ids = []) {
return Promise.all(ids.map(id => unmuteUser(store, id)))
2019-02-14 03:04:28 +00:00
},
2020-05-08 13:38:46 +00:00
fetchMascot (store) {
return fetchMascot(store)
},
2020-01-15 20:22:54 +00:00
fetchDomainMutes (store) {
return store.rootState.api.backendInteractor.fetchDomainMutes()
.then((domainMutes) => {
store.commit('saveDomainMutes', domainMutes)
return domainMutes
})
},
muteDomain (store, domain) {
return muteDomain(store, domain)
},
unmuteDomain (store, domain) {
return unmuteDomain(store, domain)
},
muteDomains (store, domains = []) {
return Promise.all(domains.map(domain => muteDomain(store, domain)))
},
unmuteDomains (store, domain = []) {
return Promise.all(domain.map(domain => unmuteDomain(store, domain)))
},
2022-06-22 15:46:47 +00:00
setNote (store, { id, note }) {
return setNote(store, { id, note })
},
fetchFriends ({ rootState, commit }, id) {
const user = rootState.users.usersObject[id]
const maxId = last(user.friendIds)
return rootState.api.backendInteractor.fetchFriends({ id, maxId })
.then((friends) => {
commit('addNewUsers', friends)
commit('saveFriendIds', { id, friendIds: map(friends, 'id') })
return friends
})
},
fetchFollowers ({ rootState, commit }, id) {
const user = rootState.users.usersObject[id]
const maxId = last(user.followerIds)
return rootState.api.backendInteractor.fetchFollowers({ id, maxId })
2019-02-25 07:11:39 +00:00
.then((followers) => {
commit('addNewUsers', followers)
commit('saveFollowerIds', { id, followerIds: map(followers, 'id') })
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)
},
subscribeUser ({ rootState, commit }, id) {
return rootState.api.backendInteractor.subscribeUser({ id })
.then((relationship) => commit('updateUserRelationship', [relationship]))
},
unsubscribeUser ({ rootState, commit }, id) {
return rootState.api.backendInteractor.unsubscribeUser({ id })
.then((relationship) => commit('updateUserRelationship', [relationship]))
},
toggleActivationStatus ({ rootState, commit }, { user }) {
const api = user.deactivated ? rootState.api.backendInteractor.activateUser : rootState.api.backendInteractor.deactivateUser
api({ user })
.then((user) => { let deactivated = !user.is_active; commit('updateActivationStatus', { user, deactivated }) })
2019-11-19 01:42:10 +00:00
},
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)
},
addNewUsers ({ commit }, users) {
commit('addNewUsers', users)
},
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
each(statuses, (status) => {
// Reconnect users to statuses
store.commit('setUserForStatus', status)
// Set pinned statuses to user
2019-08-30 19:55:28 +00:00
store.commit('setPinnedToUser', status)
2017-02-13 23:01:50 +00:00
})
each(compact(map(statuses, 'retweeted_status')), (status) => {
// Reconnect users to retweets
store.commit('setUserForStatus', status)
// Set pinned retweets to user
2019-08-30 19:55:28 +00:00
store.commit('setPinnedToUser', 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')
2020-04-21 20:27:51 +00:00
const targetUsers = map(notifications, 'target').filter(_ => _)
const notificationIds = notifications.map(_ => _.id)
2018-12-26 09:19:25 +00:00
store.commit('addNewUsers', users)
2019-12-11 09:48:18 +00:00
store.commit('addNewUsers', targetUsers)
2018-12-26 09:19:25 +00:00
const notificationsObject = store.rootState.statuses.notifications.idStore
const relevantNotifications = Object.entries(notificationsObject)
2019-07-05 07:02:14 +00:00
.filter(([k, val]) => notificationIds.includes(k))
.map(([k, val]) => val)
2018-12-26 09:19:25 +00:00
// Reconnect users to notifications
each(relevantNotifications, (notification) => {
store.commit('setUserForNotification', notification)
})
},
searchUsers ({ rootState, commit }, { query }) {
return rootState.api.backendInteractor.searchUsers({ query })
.then((users) => {
commit('addNewUsers', users)
return users
})
},
async signUp (store, userInfo) {
store.commit('signUpPending')
let rootState = store.rootState
try {
let data = await rootState.api.backendInteractor.register(
{ params: { ...userInfo } }
)
store.commit('signUpSuccess')
store.commit('setToken', data.access_token)
store.dispatch('loginUser', data.access_token)
} catch (e) {
let errors = e.message
store.commit('signUpFailure', errors)
throw e
}
},
async getCaptcha (store) {
2019-07-06 21:54:17 +00:00
return store.rootState.api.backendInteractor.getCaptcha()
},
2017-07-02 10:25:34 +00:00
logout (store) {
2019-07-02 08:33:40 +00:00
const { oauth, instance } = store.rootState
const data = {
...oauth,
commit: store.commit,
instance: instance.server
}
return oauthApi.getOrCreateApp(data)
.then((app) => {
const params = {
app,
instance: data.instance,
token: oauth.userToken
}
return oauthApi.revokeToken(params)
})
.then(() => {
store.commit('clearCurrentUser')
store.dispatch('disconnectFromSocket')
2019-07-02 08:33:40 +00:00
store.commit('clearToken')
store.dispatch('stopFetchingTimeline', 'friends')
2019-07-02 08:33:40 +00:00
store.commit('setBackendInteractor', backendInteractorService(store.getters.getToken()))
store.dispatch('stopFetchingNotifications')
store.dispatch('stopFetchingFollowRequests')
store.dispatch('stopFetchingConfig')
2019-07-02 08:33:40 +00:00
store.commit('clearNotifications')
store.commit('resetStatuses')
store.dispatch('setLastTimeline', 'public-timeline')
store.dispatch('setLayoutWidth', windowWidth())
store.dispatch('setLayoutHeight', windowHeight())
2019-07-02 08:33:40 +00:00
})
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 = []
2020-01-15 20:22:54 +00:00
user.domainMutes = []
2019-01-17 19:11:51 +00:00
commit('setCurrentUser', user)
commit('addNewUsers', [user])
2016-11-30 20:27:25 +00:00
store.dispatch('fetchEmoji')
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)
2019-01-17 19:11:51 +00:00
}
2017-12-04 18:08:33 +00:00
2019-12-10 19:30:27 +00:00
const startPolling = () => {
2019-11-24 16:50:28 +00:00
// Start getting fresh posts.
store.dispatch('startFetchingTimeline', { timeline: 'friends' })
// Start fetching notifications
store.dispatch('startFetchingNotifications')
2019-12-10 19:30:27 +00:00
}
2019-12-10 19:30:27 +00:00
if (store.getters.mergedConfig.useStreamingApi) {
store.dispatch('fetchTimeline', 'friends', { since: null })
store.dispatch('fetchNotifications', { since: null })
store.dispatch('enableMastoSockets', true).catch((error) => {
2019-12-10 19:30:27 +00:00
console.error('Failed initializing MastoAPI Streaming socket', error)
}).then(() => {
setTimeout(() => store.dispatch('setNotificationsSilence', false), 10000)
2019-12-10 19:30:27 +00:00
})
} else {
startPolling()
}
// Get user mutes
2019-02-14 03:04:28 +00:00
store.dispatch('fetchMutes')
store.dispatch('setLayoutWidth', windowWidth())
store.dispatch('setLayoutHeight', windowHeight())
store.dispatch('getSupportedTranslationlanguages')
store.dispatch('getSettingsProfile')
store.dispatch('listSettingsProfiles')
store.dispatch('startFetchingConfig')
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) {
2019-07-06 21:54:17 +00:00
reject(new Error('Wrong username or password'))
} else {
2019-07-06 21:54:17 +00:00
reject(new Error('An error occurred, please try again'))
}
}
commit('endLogin')
resolve()
})
2019-07-05 07:02:14 +00:00
.catch((error) => {
console.log(error)
commit('endLogin')
2019-07-06 21:54:17 +00:00
reject(new Error('Failed to connect to server, try again'))
2019-07-05 07:02:14 +00:00
})
})
2016-10-27 16:03:14 +00:00
}
}
}
export default users