No OneTemporary
Actions

Authored By

Unknown

Size

38 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/components/lists_edit/lists_edit.js b/src/components/lists_edit/lists_edit.js
	index c7ead6b668..cea9236a56 100644
	--- a/src/components/lists_edit/lists_edit.js
	+++ b/src/components/lists_edit/lists_edit.js
	@@ -1,148 +1,148 @@
	import { mapState } from 'pinia'

	import BasicUserCard from 'src/components/basic_user_card/basic_user_card.vue'
	import ListsUserSearch from 'src/components/lists_user_search/lists_user_search.vue'
	import PanelLoading from 'src/components/panel_loading/panel_loading.vue'
	import TabSwitcher from 'src/components/tab_switcher/tab_switcher.jsx'
	import UserAvatar from 'src/components/user_avatar/user_avatar.vue'

	import { useInterfaceStore } from 'src/stores/interface.js'
	import { useListsStore } from 'src/stores/lists.js'
	import { useUsersStore } from 'src/stores/users.js'

	import { library } from '@fortawesome/fontawesome-svg-core'
	import { faChevronLeft, faSearch } from '@fortawesome/free-solid-svg-icons'

	library.add(faSearch, faChevronLeft)

	const ListsNew = {
	components: {
	BasicUserCard,
	UserAvatar,
	ListsUserSearch,
	TabSwitcher,
	PanelLoading,
	},
	data() {
	return {
	title: '',
	titleDraft: '',
	membersUserIds: [],
	removedUserIds: new Set([]), // users we added for members, to undo
	searchUserIds: [],
	addedUserIds: new Set([]), // users we added from search, to undo
	searchLoading: false,
	reallyDelete: false,
	}
	},
	created() {
	if (!this.id) return
	useListsStore()
	.fetchList({ listId: this.id })
	.then(() => {
	this.title = this.findListTitle(this.id)
	this.titleDraft = this.title
	})
	useListsStore()
	.fetchListAccounts({ listId: this.id })
	.then(() => {
	this.membersUserIds = this.findListAccounts(this.id)
	- this.membersUserIds.forEach((userId) => {
	- useUsersStore().fetchUserIfMissing(userId)
	+ this.membersUserIds.forEach((id) => {
	+ useUsersStore().fetchUserIfMissing({ id })
	})
	})
	},
	computed: {
	id() {
	return this.$route.params.id
	},
	membersUsers() {
	return [...this.membersUserIds, ...this.addedUserIds]
	.map((userId) => this.findUser(userId))
	.filter(Boolean)
	},
	searchUsers() {
	return this.searchUserIds
	.map((userId) => this.findUser(userId))
	.filter(Boolean)
	},
	...mapState(useUsersStore, ['currentUser', 'findUser']),
	...mapState(useListsStore, ['findListTitle', 'findListAccounts']),
	},
	methods: {
	onInput() {
	this.search(this.query)
	},
	toggleRemoveMember(user) {
	if (this.removedUserIds.has(user.id)) {
	this.id && this.addUser(user)
	this.removedUserIds.delete(user.id)
	} else {
	this.id && this.removeUser(user.id)
	this.removedUserIds.add(user.id)
	}
	},
	toggleAddFromSearch(user) {
	if (this.addedUserIds.has(user.id)) {
	this.id && this.removeUser(user.id)
	this.addedUserIds.delete(user.id)
	} else {
	this.id && this.addUser(user)
	this.addedUserIds.add(user.id)
	}
	},
	isRemoved(user) {
	return this.removedUserIds.has(user.id)
	},
	isAdded(user) {
	return this.addedUserIds.has(user.id)
	},
	addUser(user) {
	useListsStore().addListAccount({ accountId: user.id, listId: this.id })
	},
	removeUser(userId) {
	useListsStore().removeListAccount({ accountId: userId, listId: this.id })
	},
	onSearchLoading() {
	this.searchLoading = true
	},
	onSearchLoadingDone() {
	this.searchLoading = false
	},
	onSearchResults(results) {
	this.searchLoading = false
	this.searchUserIds = results
	},
	updateListTitle() {
	useListsStore().setList({ listId: this.id, title: this.titleDraft })
	this.title = this.findListTitle(this.id)
	},
	createList() {
	useListsStore()
	.createList({ title: this.titleDraft })
	.then((list) => {
	useListsStore().setListAccounts({
	listId: list.id,
	accountIds: [...this.addedUserIds],
	})
	return list.id
	})
	.then((listId) => {
	this.$router.push({ name: 'lists-timeline', params: { id: listId } })
	})
	.catch((e) => {
	useInterfaceStore().pushGlobalNotice({
	messageKey: 'lists.error',
	messageArgs: [e.message],
	level: 'error',
	})
	})
	},
	deleteList() {
	useListsStore().deleteList({ listId: this.id })
	this.$router.push({ name: 'lists' })
	},
	},
	}

	export default ListsNew
	diff --git a/src/components/staff_panel/staff_panel.js b/src/components/staff_panel/staff_panel.js
	index 8e8174394e..ea2a0194fd 100644
	--- a/src/components/staff_panel/staff_panel.js
	+++ b/src/components/staff_panel/staff_panel.js
	@@ -1,36 +1,36 @@
	import { groupBy, map } from 'lodash'
	import { mapState } from 'pinia'

	import BasicUserCard from 'src/components/basic_user_card/basic_user_card.vue'

	import { useInstanceStore } from 'src/stores/instance.js'
	import { useUsersStore } from 'src/stores/users.js'

	const StaffPanel = {
	created() {
	const nicknames = useInstanceStore().staffAccounts
	- nicknames.forEach((nickname) =>
	- useUsersStore().fetchUserIfMissing(nickname),
	+ nicknames.forEach((name) =>
	+ useUsersStore().fetchUserIfMissing({ name }),
	)
	},
	components: {
	BasicUserCard,
	},
	computed: {
	groupedStaffAccounts() {
	const staffAccounts = map(this.staffAccounts, this.findUserByName).filter(
	(_) => _,
	)
	const groupedStaffAccounts = groupBy(staffAccounts, 'role')

	return [
	{ role: 'admin', users: groupedStaffAccounts.admin },
	{ role: 'moderator', users: groupedStaffAccounts.moderator },
	].filter((group) => group.users)
	},
	...mapState(useUsersStore, ['findUserByName']),
	...mapState(useInstanceStore, ['staffAccounts']),
	},
	}

	export default StaffPanel
	diff --git a/src/components/status_body/status_body.js b/src/components/status_body/status_body.js
	index b303950158..d361f3a9a3 100644
	--- a/src/components/status_body/status_body.js
	+++ b/src/components/status_body/status_body.js
	@@ -1,200 +1,200 @@
	import { mapState } from 'pinia'

	import RichContent from 'src/components/rich_content/rich_content.jsx'

	import { useMergedConfigStore } from 'src/stores/merged_config.js'
	import { useUsersStore } from 'src/stores/users.js'

	import { library } from '@fortawesome/fontawesome-svg-core'
	import {
	faFile,
	faImage,
	faLink,
	faMusic,
	faPollH,
	} from '@fortawesome/free-solid-svg-icons'

	library.add(faFile, faMusic, faImage, faLink, faPollH)

	const StatusBody = {
	name: 'StatusBody',
	components: {
	RichContent,
	},
	props: {
	status: {
	// Main thing
	type: Object,
	required: true,
	},
	compact: {
	// Resizes emoji and minimizes vertical space used
	// Primarily used for showing status in react notifications
	type: Boolean,
	default: false,
	},
	collapse: {
	// replaces newlines with spaces
	type: Boolean,
	default: false,
	},
	singleLine: {
	// Show entire thing (subject and content) in a single line
	// Primarily used in chats
	type: Boolean,
	default: false,
	},
	inConversation: {
	// Is status rendered within open conversation?
	// Used to automatically expand subjects (if collapsed)
	type: Boolean,
	default: false,
	},
	ignoreSubject: {
	// Pretend subject line doesn't exist. Useful for chat messages
	// to indicate what post reply belongs to
	type: Boolean,
	default: false,
	},
	},
	data() {
	return {
	postLength: this.status.text.length,
	parseReadyDone: false,
	showingTall: false,
	showingLongSubject: false,
	expandingSubject: null,
	}
	},
	emits: ['parseReady'],
	computed: {
	allowNonSquareEmoji() {
	return this.mergedConfig.nonSquareEmoji
	},
	pauseMfm() {
	return this.mergedConfig.pauseMfm
	},
	scaleMfm() {
	return this.mergedConfig.scaleMfm
	},
	// This is a bit hacky, but we want to approximate post height before rendering
	// so we count newlines (masto uses <p> for paragraphs, GS uses <br> between them)
	// as well as approximate line count by counting characters and approximating ~80
	// per line.
	//
	// Using max-height + overflow: auto for status components resulted in false positives
	// very often with japanese characters, and it was very annoying.
	hasLongSubject() {
	return this.status.summary.length > 240
	},
	hasSubject() {
	return !!this.status.summary && !this.ignoreSubject
	},
	// When a status has a subject and is also tall, we should only have one show more/less
	// button. If the default is to collapse statuses with subjects, we just treat it like
	// a status with a subject; otherwise, we just treat it like a tall status.
	mightHideBecauseSubject() {
	return (
	!this.inConversation &&
	this.hasSubject &&
	this.mergedConfig.collapseMessageWithSubject
	)
	},
	mightHideBecauseTall() {
	if (this.singleLine \|\| this.compact) return false
	const lengthScore =
	this.status.raw_html.split(/<p\|<br/).length + this.postLength / 80
	return lengthScore > 20
	},
	hideSubjectStatus() {
	return this.mightHideBecauseSubject && !this.expandingSubject
	},
	hideTallStatus() {
	return this.mightHideBecauseTall && !this.showingTall
	},
	shouldShowExpandToggle() {
	return this.mightHideBecauseSubject \|\| this.mightHideBecauseTall
	},
	toggleButtonClasses() {
	return {
	'cw-status-hider': !this.showingMore && this.mightHideBecauseSubject,
	'tall-status-hider': !this.showingMore && this.mightHideBecauseTall,
	'status-unhider': this.showingMore,
	}
	},
	toggleText() {
	if (this.showingMore) {
	return this.mightHideBecauseSubject
	? this.$t('status.hide_content')
	: this.$t('general.show_less')
	} else {
	return this.mightHideBecauseSubject
	? this.$t('status.show_content')
	: this.$t('general.show_more')
	}
	},
	shouldHide() {
	return (
	!this.showingMore && this.mightHideBecauseSubject && this.hasSubject
	)
	},
	showingMore() {
	return (
	(this.mightHideBecauseTall && this.showingTall) \|\|
	(this.mightHideBecauseSubject && this.expandingSubject)
	)
	},
	attachmentTypes() {
	return this.status.attachments.map((file) => file.type)
	},
	collapsedStatus() {
	return this.status.raw_html.replaceAll('(\n\|<br\s?\/?>)', ' ')
	},
	...mapState(useMergedConfigStore, ['mergedConfig']),
	},
	mounted() {
	this.status.attentions?.forEach((attn) => {
	const { id } = attn
	- useUsersStore().fetchUserIfMissing(id)
	+ useUsersStore().fetchUserIfMissing({ id })
	})
	},
	methods: {
	onParseReady(event) {
	if (this.parseReadyDone) return
	this.parseReadyDone = true
	this.$emit('parseReady', event)
	const { writtenMentions, invisibleMentions } = event
	writtenMentions
	.filter((mention) => !mention.notifying)
	.forEach((mention) => {
	const { content, url } = mention
	const cleanedString = content.replaceAll(/<[^>]+?>/gi, '') // remove all tags
	if (!cleanedString.startsWith('@')) return
	const handle = cleanedString.slice(1)
	const host = url.replace(/^https?:\/\//, '').replace(/\/.+?$/, '')
	- useUsersStore().fetchUserIfMissing(`${handle}@${host}`)
	+ useUsersStore().fetchUserIfMissing({ name: `${handle}@${host}` })
	})
	/* This is a bit of a hack to make current tall status detector work
	* with rich mentions. Invisible mentions are detected at RichContent level
	* and also we generate plaintext version of mentions by stripping tags
	* so here we subtract from post length by each mention that became invisible
	* via MentionsLine
	*/
	this.postLength = invisibleMentions.reduce((acc, mention) => {
	return acc - mention.textContent.length - 1
	}, this.postLength)
	},
	toggleShowMore() {
	if (this.mightHideBecauseTall) {
	this.showingTall = !this.showingTall
	} else if (this.mightHideBecauseSubject) {
	this.expandingSubject = !this.expandingSubject
	}
	},
	generateTagLink(tag) {
	return `/tag/${tag}`
	},
	},
	}

	export default StatusBody
	diff --git a/src/components/user_profile/user_profile_admin_view.js b/src/components/user_profile/user_profile_admin_view.js
	index 534c85db35..da0a05372e 100644
	--- a/src/components/user_profile/user_profile_admin_view.js
	+++ b/src/components/user_profile/user_profile_admin_view.js
	@@ -1,69 +1,69 @@
	import Checkbox from 'src/components/checkbox/checkbox.vue'
	import List from 'src/components/list/list.vue'
	import Status from 'src/components/status/status.vue'
	import UserCard from 'src/components/user_card/user_card.vue'

	import { useAdminSettingsStore } from 'src/stores/admin_settings.js'
	import { useInterfaceStore } from 'src/stores/interface.js'
	import { useUsersStore } from 'src/stores/users.js'

	import { library } from '@fortawesome/fontawesome-svg-core'
	import { faCircleNotch } from '@fortawesome/free-solid-svg-icons'

	library.add(faCircleNotch)

	const UserProfileAdminView = {
	data() {
	return {
	godmode: false,
	showReblogs: false,
	}
	},
	created() {
	- useUsersStore().fetchUserIfMissing(this.userId)
	+ useUsersStore().fetchUserIfMissing({ id: this.userId })
	useInterfaceStore().setForeignProfileBackground(this.user?.background_image)
	},
	updated() {
	useInterfaceStore().setForeignProfileBackground(this.user?.background_image)
	},
	unmounted() {
	useInterfaceStore().setForeignProfileBackground(null)
	},
	computed: {
	fetchOptions() {
	return {
	pageSize: 20,
	godmode: this.godmode,
	id: this.userId,
	withReblogs: this.showReblogs,
	}
	},
	user() {
	return useUsersStore().findUser(this.userId)
	},
	userId() {
	return this.$route.params.id
	},
	},
	methods: {
	fetchStatuses(page) {
	return useAdminSettingsStore().fetchStatuses({
	...this.fetchOptions,
	page,
	})
	},
	},
	components: {
	UserCard,
	List,
	Status,
	Checkbox,
	},
	watch: {
	fetchOptions() {
	this.$refs.list.reset()
	},
	},
	}

	export default UserProfileAdminView
	diff --git a/src/stores/users.js b/src/stores/users.js
	index 0b9b233d12..c1f85d5f89 100644
	--- a/src/stores/users.js
	+++ b/src/stores/users.js
	@@ -1,689 +1,748 @@
	import Cookies from 'js-cookie'
	import { last, map } from 'lodash'
	import { defineStore } from 'pinia'

	import {
	registerPushNotifications,
	unregisterPushNotifications,
	} from '../services/sw/sw.js'
	import {
	windowHeight,
	windowWidth,
	} from '../services/window_utils/window_utils'

	import { useAnnouncementsStore } from 'src/stores/announcements.js'
	import { useBookmarkFoldersStore } from 'src/stores/bookmark_folders.js'
	import { useChatsStore } from 'src/stores/chats.js'
	import { useEmojiStore } from 'src/stores/emoji.js'
	import { useInstanceStore } from 'src/stores/instance.js'
	import { useInstanceCapabilitiesStore } from 'src/stores/instance_capabilities.js'
	import { useInterfaceStore } from 'src/stores/interface.js'
	import { useListsStore } from 'src/stores/lists.js'
	import { useMergedConfigStore } from 'src/stores/merged_config.js'
	import { useOAuthStore } from 'src/stores/oauth.js'
	import { useSyncConfigStore } from 'src/stores/sync_config.js'
	import { useUserHighlightStore } from 'src/stores/user_highlight.js'

	import { revokeToken } from 'src/api/oauth.js'
	import {
	fetchFollowers,
	fetchFriends,
	fetchUser,
	fetchUserByName,
	searchUsers,
	verifyCredentials,
	} from 'src/api/public.js'
	import {
	blockUser,
	editUserNote,
	fetchBlocks,
	fetchDomainMutes,
	fetchMutes,
	fetchUserInLists,
	fetchUserRelationship,
	followUser,
	muteDomain,
	muteUser,
	removeUserFromFollowers,
	unblockUser,
	unmuteDomain,
	unmuteUser,
	} from 'src/api/user.js'

	const getNotificationPermission = async () => {
	const Notification = window.Notification

	if (!Notification) return null
	if (Notification.permission === 'default')
	return Notification.requestPermission()
	return Notification.permission
	}

	export const useUsersStore = defineStore('users', {
	state: () => ({
	loggingIn: false,
	lastLoginName: null,
	currentUser: null,
	users: new Map(),
	usersByName: new Map(),
	usersByURL: new Map(),
	relationships: new Map(),
	timestamps: new WeakMap(),
	+ fetchesIds: new Map(),
	+ fetchesNames: new Map(),
	}),
	getters: {
	loggedIn: (state) => !!state.currentUser,
	findUser: (state) => (query) => {
	return state.users.get(query)
	},
	findUserByName: (state) => (query) => {
	return state.usersByName.get(query.toLowerCase())
	},
	findUserByUrl: (state) => (query) => {
	return state.usersByURL.get(query.toLowerCase())
	},
	relationship: (state) => (id) => {
	const rel = id && state.relationships.get(id)
	return rel \|\| { id, loading: true }
	},
	},
	actions: {
	tagUser({ user: { id }, tag }) {
	const user = this.users.get(id)
	user.tags.add(tag)
	},
	untagUser({ user: { id }, tag }) {
	const user = this.users.get(id)
	user.tags.delete(tag)
	},
	updateRight({ user: { id }, right, value }) {
	const user = this.users.get(id)
	const newRights = user.rights
	newRights[right] = value
	user.rights = newRights
	},
	async updateUserAdminData({ user }) {
	- const localUser = await this.fetchUserIfMissing(user.id)
	+ const localUser = await this.fetchUserIfMissing({ id: user.id })

	localUser.adminData = user
	localUser.deactivated = !user.is_active
	localUser.tags = new Set(user.tags)
	},
	setCurrentUser(user) {
	this.lastLoginName = user.screen_name
	this.currentUser = user
	},
	clearCurrentUser() {
	this.currentUser = null
	this.lastLoginName = null
	},
	saveFriendIds({ id, friendIds }) {
	const user = this.users.get(id)
	user.friendIds = [...new Set([...(user.friendIds \|\| []), ...friendIds])]
	},
	saveFollowerIds({ id, followerIds }) {
	const user = this.users.get(id)
	user.followerIds = [...new Set([user.followerIds \|\| [], ...followerIds])]
	},
	// Because frontend doesn't have a reason to keep these stuff in memory
	// outside of viewing someones user profile.
	clearFriends(userId) {
	const user = this.users.get(userId)
	if (user) {
	user.friendIds = []
	}
	},
	clearFollowers(userId) {
	const user = this.users.get(userId)
	if (user) {
	user.followerIds = []
	}
	},
	addNewUsers(response) {
	const { data, timestamp } = response
	const users = Array.isArray(data) ? data : [data]

	users.forEach((user) => {
	const existing = this.users.get(user.id) ?? {}
	const oldTimestamp = this.timestamps.get(existing)

	// implicit: if oldTimestamp is undefined this will still be false
	if (oldTimestamp > timestamp) return // not overwriting old data with new

	const { relationship, ...old } = existing
	const { relationshop, ...neu } = user
	const newUser = { ...old, ...neu }

	this.users.set(user.id, newUser)
	this.usersByName.set(user.screen_name.toLowerCase(), newUser)
	this.usersByURL.set(user.url.toLowerCase(), newUser)
	this.timestamps.set(newUser, timestamp)

	if (user.id === this.currentUser.id) {
	this.currentUser = newUser
	}
	})
	},
	updateUserRelationship(relationships) {
	relationships.forEach((relationship) => {
	this.relationships[relationship.id] = relationship
	})
	},
	updateUserInLists({ id, inLists }) {
	this.users.get(id).inLists = inLists
	},
	saveBlockIds(blockIds) {
	this.currentUser.blockIds = blockIds
	},
	addBlockId(blockId) {
	if (this.currentUser.blockIds.includes(blockId)) {
	this.currentUser.blockIds.push(blockId)
	}
	},
	setBlockIdsMaxId(blockIdsMaxId) {
	this.currentUser.blockIdsMaxId = blockIdsMaxId
	},
	saveMuteIds(muteIds) {
	this.currentUser.muteIds = muteIds
	},
	setMuteIdsMaxId(muteIdsMaxId) {
	this.currentUser.muteIdsMaxId = muteIdsMaxId
	},
	addMuteId(muteId) {
	if (this.currentUser.muteIds.includes(muteId)) {
	this.currentUser.muteIds.push(muteId)
	}
	},
	saveDomainMutes(domainMutes) {
	this.currentUser.domainMutes = domainMutes
	},
	addDomainMute(domain) {
	if (this.currentUser.domainMutes.includes(domain)) {
	this.currentUser.domainMutes.push(domain)
	}
	},
	removeDomainMute(domain) {
	const index = this.currentUser.domainMutes.indexOf(domain)
	if (index !== -1) {
	this.currentUser.domainMutes.splice(index, 1)
	}
	},
	setPinnedToUser(status) {
	const user = this.users.get(status.user.id)
	user.pinnedStatusIds = user.pinnedStatusIds \|\| []
	const index = user.pinnedStatusIds.indexOf(status.id)

	if (status.pinned && index === -1) {
	user.pinnedStatusIds.push(status.id)
	} else if (!status.pinned && index !== -1) {
	user.pinnedStatusIds.splice(index, 1)
	}
	},
	setUserForStatus(status) {
	status.user = this.users.get(status.user.id)
	},
	setUserForNotification(notification) {
	if (notification.type !== 'follow') {
	notification.action.user = this.users.get(notification.action.user.id)
	}
	notification.from_profile = this.users.get(notification.from_profile.id)
	},
	- async fetchUserIfMissing(id) {
	- const user = this.findUser(id)
	+ async fetchUserIfMissing({ id, name }) {
	+ let findFunc
	+ let fetchFunc
	+ let map
	+ let otherMap
	+ let identifier
	+
	+ if (id) {
	+ findFunc = this.findUser
	+ fetchFunc = this.fetchUser
	+ map = this.fetchesIds
	+ identifier = id
	+ } else if (name) {
	+ findFunc = this.findUserByName
	+ fetchFunc = this.fetchUserByName
	+ map = this.fetchesNames
	+ identifier = name
	+ } else {
	+ throw new TypeError('No identifier provided')
	+ }
	+
	+ const user = findFunc(identifier)
	+
	if (!user) {
	- return this.fetchUser(id)
	+ let promise
	+
	+ if (map.has(identifier)) {
	+ promise = map.get(identifier)
	+ } else {
	+ promise = fetchFunc(identifier)
	+ }
	+
	+ map.set(identifier, promise)
	+
	+ const result = await promise
	+
	+ if (result?.data) {
	+ const { id, screen_name } = result.data
	+
	+ this.fetchesIds.set(id, promise)
	+ this.fetchesNames.set(screen_name, promise)
	+ this.addNewUsers(result)
	+ return this.users.get(id)
	+ } else {
	+ return null
	+ }
	} else {
	return user
	}
	},
	- fetchUser(id) {
	- return fetchUser({
	- id,
	- credentials: useOAuthStore().token,
	- })
	- .then(({ data: user }) => {
	- this.addNewUsers([user])
	- return user
	- })
	- .catch((error) => {
	- if (error.statusCode === 404) {
	- console.warn(`User ${id} not found`)
	- } else {
	- throw error
	- }
	+ async fetchUser(id) {
	+ try {
	+ const result = await fetchUser({
	+ id,
	+ credentials: useOAuthStore().token,
	})
	+
	+ this.addNewUsers(result)
	+ return this.users.get(result.data.id)
	+ } catch(error) {
	+ if (
	+ error.name === 'StatusCodeError' &&
	+ error.statusCode === 404
	+ ) {
	+ console.warn(`User ${id} not found`)
	+ return null
	+ } else {
	+ throw error
	+ }
	+ }
	},
	- fetchUserByName(name) {
	- return fetchUserByName({
	- name,
	- credentials: useOAuthStore().token,
	- }).then(({ data: user }) => {
	- this.addNewUsers([user])
	- return user
	- })
	+ async fetchUserByName(name) {
	+ try {
	+ const result = fetchUserByName({
	+ name,
	+ credentials: useOAuthStore().token,
	+ })
	+
	+ this.addNewUsers(result)
	+
	+ return this.users.get(result.data.id)
	+ } catch(error) {
	+ if (
	+ error.name === 'StatusCodeError' &&
	+ error.statusCode === 404
	+ ) {
	+ console.warn(`User ${id} not found`)
	+ return null
	+ } else {
	+ throw error
	+ }
	+ }
	},
	fetchUserRelationship(id) {
	if (this.currentUser) {
	fetchUserRelationship({
	id,
	credentials: useOAuthStore().token,
	}).then(({ data: relationships }) =>
	this.updateUserRelationship(relationships),
	)
	}
	},
	fetchUserInLists(id) {
	if (this.currentUser) {
	fetchUserInLists({
	id,
	credentials: useOAuthStore().token,
	}).then(({ data: inLists }) => this.updateUserInLists({ id, inLists }))
	}
	},
	fetchBlocks(args) {
	const { reset } = args \|\| {}

	const maxId = this.currentUser.blockIdsMaxId
	return fetchBlocks({
	maxId,
	credentials: useOAuthStore().token,
	}).then((result) => {
	const { data: blocks } = result
	if (reset) {
	this.saveBlockIds(blocks.map(({ id }) => id))
	} else {
	blocks.forEach(({ id }) => this.addBlockId(id))
	}
	if (blocks.length) {
	this.setBlockIdsMaxId(last(blocks).id)
	}
	this.addNewUsers(result)
	return blocks
	})
	},
	blockUser(id, expiresIn = 0) {
	const store = window.vuex

	const predictedRelationship = this.relationships[id] \|\| { id }
	this.updateUserRelationship([predictedRelationship])
	this.addBlockId(id)

	return blockUser({ id, expiresIn }).then(({ data: relationship }) => {
	this.updateUserRelationship([relationship])
	this.addBlockId(id)

	store.commit('removeStatus', { timeline: 'friends', userId: id })
	store.commit('removeStatus', { timeline: 'public', userId: id })
	store.commit('removeStatus', {
	timeline: 'publicAndExternal',
	userId: id,
	})
	})
	},
	unblockUser(id) {
	return unblockUser({ id }).then(({ data: relationship }) =>
	this.updateUserRelationship([relationship]),
	)
	},
	removeUserFromFollowers(id) {
	return removeUserFromFollowers({ id }).then((relationship) =>
	this.updateUserRelationship([relationship]),
	)
	},
	blockUsers(data = []) {
	return Promise.all(data.map((d) => this.blockUser(d)))
	},
	unblockUsers(data = []) {
	return Promise.all(data.map((d) => unblockUser(d)))
	},
	editUserNote({ id, comment }) {
	return editUserNote({ id, comment }).then((relationship) =>
	this.updateUserRelationship([relationship]),
	)
	},
	fetchMutes(args) {
	const { reset } = args \|\| {}

	const maxId = this.currentUser.muteIdsMaxId
	return fetchMutes({
	maxId,
	credentials: useOAuthStore().token,
	}).then((result) => {
	const { data: mutes } = result
	if (reset) {
	this.saveMuteIds(mutes.map(({ id }) => id))
	} else {
	mutes.forEach(({ id }) => this.addMuteId(id))
	}
	if (mutes.length) {
	this.setMuteIdsMaxId(last(mutes).id)
	}
	this.addNewUsers(result)
	return mutes
	})
	},
	muteUser(id, expiresIn = 0) {
	const predictedRelationship = this.relationships[id] \|\| { id }
	this.updateUserRelationship([predictedRelationship])
	this.addMuteId(id)

	return muteUser({
	id,
	expiresIn,
	credentials: useOAuthStore().token,
	}).then(({ data: relationship }) => {
	this.updateUserRelationship([relationship])
	this.addMuteId(id)
	})
	},
	unmuteUser(id) {
	const predictedRelationship = this.relationships[id] \|\| { id }
	predictedRelationship.muting = false
	this.updateUserRelationship([predictedRelationship])

	return unmuteUser({ id }).then(({ data: relationship }) =>
	this.updateUserRelationship([relationship]),
	)
	},
	hideReblogs(id) {
	return followUser({
	id,
	reblogs: false,
	credentials: useOAuthStore().token,
	}).then(({ data: relationship }) =>
	this.updateUserRelationship([relationship]),
	)
	},
	showReblogs(id) {
	return followUser({
	id,
	reblogs: true,
	credentials: useOAuthStore().token,
	}).then(({ data: relationship }) =>
	this.updateUserRelationship([relationship]),
	)
	},
	muteUsers(data = []) {
	return Promise.all(data.map((d) => this.muteUser(d)))
	},
	unmuteUsers(ids = []) {
	return Promise.all(ids.map((d) => this.unmuteUser(d)))
	},
	fetchDomainMutes() {
	return fetchDomainMutes({
	credentials: useOAuthStore().token,
	}).then(({ data: domainMutes }) => {
	this.saveDomainMutes(domainMutes)
	return domainMutes
	})
	},
	muteDomain(domain) {
	return muteDomain({
	domain,
	credentials: useOAuthStore().token,
	}).then(() => this.addDomainMute(domain))
	},
	unmuteDomain(domain) {
	return unmuteDomain({
	domain,
	credentials: useOAuthStore().token,
	}).then(() => this.removeDomainMute(domain))
	},
	muteDomains(domains = []) {
	return Promise.all(domains.map((domain) => this.muteDomain(domain)))
	},
	unmuteDomains(domain = []) {
	return Promise.all(domain.map((domain) => this.unmuteDomain(domain)))
	},
	fetchFriends(id) {
	const user = this.users.get(id)
	const maxId = last(user.friendIds)
	return fetchFriends({
	id,
	maxId,
	credentials: useOAuthStore().token,
	}).then(({ data: friends }) => {
	this.addNewUsers(friends)
	this.saveFriendIds({ id, friendIds: map(friends, 'id') })
	return friends
	})
	},
	fetchFollowers(id) {
	const user = this.users.get(id)
	const maxId = last(user.followerIds)
	return fetchFollowers({
	id,
	maxId,
	credentials: useOAuthStore().token,
	}).then(({ data: followers }) => {
	this.addNewUsers(followers)
	this.saveFollowerIds({ id, followerIds: map(followers, 'id') })
	return followers
	})
	},
	subscribeUser(id) {
	return followUser({
	id,
	notify: true,
	credentials: useOAuthStore().token,
	}).then(({ data: relationship }) =>
	this.updateUserRelationship([relationship]),
	)
	},
	unsubscribeUser(id) {
	return followUser({
	id,
	notify: false,
	credentials: useOAuthStore().token,
	}).then(({ data: relationship }) =>
	this.updateUserRelationship([relationship]),
	)
	},
	registerPushNotifications() {
	const token = this.currentUser.credentials
	const vapidPublicKey = useInstanceStore().vapidPublicKey
	const isEnabled = useMergedConfigStore().mergedConfig.webPushNotifications
	const notificationVisibility =
	useMergedConfigStore().mergedConfig.notificationVisibility

	registerPushNotifications(
	isEnabled,
	vapidPublicKey,
	token,
	notificationVisibility,
	)
	},
	unregisterPushNotifications() {
	const token = this.currentUser.credentials

	unregisterPushNotifications(token)
	},
	searchUsers({ query }) {
	return searchUsers({
	query,
	credentials: useOAuthStore().token,
	}).then(({ data: users }) => {
	this.addNewUsers(users)
	return users
	})
	},

	logout() {
	const store = window.vuex
	const oauth = useOAuthStore()

	// NOTE: No need to verify the app still exists, because if it doesn't,
	// the token will be invalid too
	return oauth
	.ensureApp()
	.then((app) => {
	const params = {
	app,
	instance: useInstanceStore().server,
	token: oauth.userToken,
	}

	return revokeToken(params)
	})
	.then(() => {
	this.clearCurrentUser()
	store.dispatch('disconnectFromSocket')
	store.dispatch('stopFetchingTimeline', 'friends')
	store.dispatch('stopFetchingNotifications')
	useListsStore().stopFetching()
	useBookmarkFoldersStore().stopFetching()
	store.dispatch('stopFetchingFollowRequests')
	store.commit('clearNotifications')
	store.commit('resetStatuses')
	useChatsStore().resetChats()
	oauth.clearToken()
	Cookies.remove('__Host-pleroma_key', { path: '/' })
	useInterfaceStore().setLastTimeline('public-timeline')
	useInterfaceStore().setLayoutWidth(windowWidth())
	useInterfaceStore().setLayoutHeight(windowHeight())
	})
	},
	loginUser(accessToken) {
	return new Promise((resolve, reject) => {
	const store = window.vuex
	const dispatch = store.dispatch

	this.loggingIn = true

	verifyCredentials({
	credentials: useOAuthStore().token,
	})
	.then(({ data: user, ...rest }) => {
	// user.credentials = userCredentials
	user.credentials = accessToken
	user.blockIds = []
	user.muteIds = []
	user.domainMutes = []
	this.setCurrentUser(user)

	useSyncConfigStore()
	.initSyncConfig(user)
	.then(() => {
	useInterfaceStore()
	.applyTheme()
	.catch((e) => {
	console.error('Error setting theme', e)
	})
	})
	useUserHighlightStore().initUserHighlight(user)
	this.addNewUsers({ data: user, ...rest })

	useEmojiStore().fetchEmoji()

	getNotificationPermission().then((permission) =>
	useInterfaceStore().setNotificationPermission(permission),
	)

	// Do server-side storage migrations

	// Debug snippet to clean up storage and reset migrations
	/*
	// Reset wordfilter
	Object.keys(
	useSyncConfigStore().prefsStorage.simple.muteFilters
	).forEach(key => {
	useSyncConfigStore().unsetSimplePrefAndSave({ path: 'muteFilters.' + key, value: null })
	})

	// Reset flag to 0 to re-run migrations
	useSyncConfigStore().setFlag({ flag: 'configMigration', value: 0 })
	/**/

	if (user.token) {
	dispatch('setWsToken', user.token)

	// Initialize the shout socket.
	dispatch('initializeSocket')
	}

	const startPolling = () => {
	// Start getting fresh posts.
	dispatch('startFetchingTimeline', { timeline: 'friends' })

	// Start fetching notifications
	dispatch('startFetchingNotifications')

	if (useInstanceCapabilitiesStore().pleromaChatMessagesAvailable) {
	// Start fetching chats
	useChatsStore().startFetchingChats()
	}
	}

	useListsStore().startFetching()
	useBookmarkFoldersStore().startFetching()

	if (user.locked) {
	dispatch('startFetchingFollowRequests')
	}

	if (useMergedConfigStore().mergedConfig.useStreamingApi) {
	dispatch('fetchTimeline', {
	timeline: 'friends',
	sinceId: null,
	})
	dispatch('fetchNotifications', { sinceId: null })
	dispatch('enableMastoSockets', true)
	.catch((error) => {
	console.error(
	'Failed initializing MastoAPI Streaming socket',
	error,
	)
	})
	.then(() => {
	dispatch('fetchChats', { latest: true })
	setTimeout(
	() => dispatch('setNotificationsSilence', false),
	10000,
	)
	})
	} else {
	startPolling()
	}

	// Start fetching things that don't need to block the UI
	useAnnouncementsStore().startFetchingAnnouncements()

	this.fetchMutes()
	dispatch('loadDrafts')

	useInterfaceStore().setLayoutWidth(windowWidth())
	useInterfaceStore().setLayoutHeight(windowHeight())

	// Fetch our friends
	fetchFriends({ id: user.id }).then((friends) =>
	this.addNewUsers(friends),
	)
	this.loggingIn = false
	resolve()
	})
	.catch((error) => {
	console.error(error)

	// Authentication failed
	this.loggingIn = false

	// remove authentication token on client/authentication errors
	if ([400, 401, 403, 422].includes(error.statusCode)) {
	useOAuthStore().clearToken()
	}

	this.loggingIn = false
	if (error.tatusCode === 401) {
	throw new Error('Wrong username or password', error)
	} else {
	throw new Error('An error occurred, please try again', error)
	}
	})
	})
	},
	},
	persist: {
	- afterLoad({ lastLoginName }) {
	- return { lastLoginName }
	- },
	+ paths: ['lastLoginName'],
	},
	})

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 9:00 PM (13 h, 35 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803326
Default Alt Text: (38 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions