No OneTemporary
Actions

Size

66 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/components/block_card/block_card.js b/src/components/block_card/block_card.js
	index 659c75d8bf..0bf4e37bc0 100644
	--- a/src/components/block_card/block_card.js
	+++ b/src/components/block_card/block_card.js
	@@ -1,40 +1,40 @@
	import BasicUserCard from '../basic_user_card/basic_user_card.vue'

	const BlockCard = {
	props: ['userId'],
	data () {
	return {
	progress: false
	}
	},
	computed: {
	user () {
	return this.$store.getters.findUser(this.userId)
	},
	relationship () {
	- return this.$store.state.users.relationships[this.userId] \|\| {}
	+ return this.$store.getters.relationship(this.userId)
	},
	blocked () {
	return this.relationship.blocking
	}
	},
	components: {
	BasicUserCard
	},
	methods: {
	unblockUser () {
	this.progress = true
	this.$store.dispatch('unblockUser', this.user.id).then(() => {
	this.progress = false
	})
	},
	blockUser () {
	this.progress = true
	this.$store.dispatch('blockUser', this.user.id).then(() => {
	this.progress = false
	})
	}
	}
	}

	export default BlockCard
	diff --git a/src/components/follow_card/follow_card.js b/src/components/follow_card/follow_card.js
	index 620ae7fd9d..6dcb6d47bd 100644
	--- a/src/components/follow_card/follow_card.js
	+++ b/src/components/follow_card/follow_card.js
	@@ -1,28 +1,28 @@
	import BasicUserCard from '../basic_user_card/basic_user_card.vue'
	import RemoteFollow from '../remote_follow/remote_follow.vue'
	import FollowButton from '../follow_button/follow_button.vue'

	const FollowCard = {
	props: [
	'user',
	'noFollowsYou'
	],
	components: {
	BasicUserCard,
	RemoteFollow,
	FollowButton
	},
	computed: {
	isMe () {
	return this.$store.state.users.currentUser.id === this.user.id
	},
	loggedIn () {
	return this.$store.state.users.currentUser
	},
	relationship () {
	- return this.$store.state.users.relationships[this.user.id]
	+ return this.$store.getters.relationship(this.user.id)
	}
	}
	}

	export default FollowCard
	diff --git a/src/components/mute_card/mute_card.js b/src/components/mute_card/mute_card.js
	index be528d3751..cbec0e9bb3 100644
	--- a/src/components/mute_card/mute_card.js
	+++ b/src/components/mute_card/mute_card.js
	@@ -1,40 +1,40 @@
	import BasicUserCard from '../basic_user_card/basic_user_card.vue'

	const MuteCard = {
	props: ['userId'],
	data () {
	return {
	progress: false
	}
	},
	computed: {
	user () {
	return this.$store.getters.findUser(this.userId)
	},
	relationship () {
	- return this.$store.state.users.relationships[this.userId]
	+ return this.$store.getters.relationship(this.userId)
	},
	muted () {
	return this.relationship.muting
	}
	},
	components: {
	BasicUserCard
	},
	methods: {
	unmuteUser () {
	this.progress = true
	this.$store.dispatch('unmuteUser', this.userId).then(() => {
	this.progress = false
	})
	},
	muteUser () {
	this.progress = true
	this.$store.dispatch('muteUser', this.userId).then(() => {
	this.progress = false
	})
	}
	}
	}

	export default MuteCard
	diff --git a/src/components/notification/notification.js b/src/components/notification/notification.js
	index 09554f54dd..ff1c281747 100644
	--- a/src/components/notification/notification.js
	+++ b/src/components/notification/notification.js
	@@ -1,64 +1,64 @@
	import Status from '../status/status.vue'
	import UserAvatar from '../user_avatar/user_avatar.vue'
	import UserCard from '../user_card/user_card.vue'
	import Timeago from '../timeago/timeago.vue'
	import { highlightClass, highlightStyle } from '../../services/user_highlighter/user_highlighter.js'
	import generateProfileLink from 'src/services/user_profile_link_generator/user_profile_link_generator'

	const Notification = {
	data () {
	return {
	userExpanded: false,
	betterShadow: this.$store.state.interface.browserSupport.cssFilter,
	unmuted: false
	}
	},
	props: [ 'notification' ],
	components: {
	Status,
	UserAvatar,
	UserCard,
	Timeago
	},
	methods: {
	toggleUserExpanded () {
	this.userExpanded = !this.userExpanded
	},
	generateUserProfileLink (user) {
	return generateProfileLink(user.id, user.screen_name, this.$store.state.instance.restrictedNicknames)
	},
	getUser (notification) {
	return this.$store.state.users.usersObject[notification.from_profile.id]
	},
	toggleMute () {
	this.unmuted = !this.unmuted
	}
	},
	computed: {
	userClass () {
	return highlightClass(this.notification.from_profile)
	},
	userStyle () {
	const highlight = this.$store.getters.mergedConfig.highlight
	const user = this.notification.from_profile
	return highlightStyle(highlight[user.screen_name])
	},
	user () {
	return this.$store.getters.findUser(this.notification.from_profile.id)
	},
	userProfileLink () {
	return this.generateUserProfileLink(this.user)
	},
	targetUser () {
	return this.$store.getters.findUser(this.notification.target.id)
	},
	targetUserProfileLink () {
	return this.generateUserProfileLink(this.targetUser)
	},
	needMute () {
	- return (this.$store.state.users.relationships[this.user.id] \|\| {}).muting
	+ return this.$store.getters.relationship(this.user.id).muting
	}
	}
	}

	export default Notification
	diff --git a/src/components/status/status.js b/src/components/status/status.js
	index a73e3ae235..a36de028e6 100644
	--- a/src/components/status/status.js
	+++ b/src/components/status/status.js
	@@ -1,477 +1,477 @@
	import Attachment from '../attachment/attachment.vue'
	import FavoriteButton from '../favorite_button/favorite_button.vue'
	import ReactButton from '../react_button/react_button.vue'
	import RetweetButton from '../retweet_button/retweet_button.vue'
	import Poll from '../poll/poll.vue'
	import ExtraButtons from '../extra_buttons/extra_buttons.vue'
	import PostStatusForm from '../post_status_form/post_status_form.vue'
	import UserCard from '../user_card/user_card.vue'
	import UserAvatar from '../user_avatar/user_avatar.vue'
	import Gallery from '../gallery/gallery.vue'
	import LinkPreview from '../link-preview/link-preview.vue'
	import AvatarList from '../avatar_list/avatar_list.vue'
	import Timeago from '../timeago/timeago.vue'
	import StatusPopover from '../status_popover/status_popover.vue'
	import EmojiReactions from '../emoji_reactions/emoji_reactions.vue'
	import generateProfileLink from 'src/services/user_profile_link_generator/user_profile_link_generator'
	import fileType from 'src/services/file_type/file_type.service'
	import { processHtml } from 'src/services/tiny_post_html_processor/tiny_post_html_processor.service.js'
	import { highlightClass, highlightStyle } from '../../services/user_highlighter/user_highlighter.js'
	import { mentionMatchesUrl, extractTagFromUrl } from 'src/services/matcher/matcher.service.js'
	import { filter, unescape, uniqBy } from 'lodash'
	import { mapGetters, mapState } from 'vuex'

	const Status = {
	name: 'Status',
	props: [
	'statusoid',
	'expandable',
	'inConversation',
	'focused',
	'highlight',
	'compact',
	'replies',
	'isPreview',
	'noHeading',
	'inlineExpanded',
	'showPinned',
	'inProfile',
	'profileUserId'
	],
	data () {
	return {
	replying: false,
	unmuted: false,
	userExpanded: false,
	showingTall: this.inConversation && this.focused,
	showingLongSubject: false,
	error: null,
	// not as computed because it sets the initial state which will be changed later
	expandingSubject: !this.$store.getters.mergedConfig.collapseMessageWithSubject
	}
	},
	computed: {
	localCollapseSubjectDefault () {
	return this.mergedConfig.collapseMessageWithSubject
	},
	muteWords () {
	return this.mergedConfig.muteWords
	},
	repeaterClass () {
	const user = this.statusoid.user
	return highlightClass(user)
	},
	userClass () {
	const user = this.retweet ? (this.statusoid.retweeted_status.user) : this.statusoid.user
	return highlightClass(user)
	},
	deleted () {
	return this.statusoid.deleted
	},
	repeaterStyle () {
	const user = this.statusoid.user
	const highlight = this.mergedConfig.highlight
	return highlightStyle(highlight[user.screen_name])
	},
	userStyle () {
	if (this.noHeading) return
	const user = this.retweet ? (this.statusoid.retweeted_status.user) : this.statusoid.user
	const highlight = this.mergedConfig.highlight
	return highlightStyle(highlight[user.screen_name])
	},
	hideAttachments () {
	return (this.mergedConfig.hideAttachments && !this.inConversation) \|\|
	(this.mergedConfig.hideAttachmentsInConv && this.inConversation)
	},
	userProfileLink () {
	return this.generateUserProfileLink(this.status.user.id, this.status.user.screen_name)
	},
	replyProfileLink () {
	if (this.isReply) {
	return this.generateUserProfileLink(this.status.in_reply_to_user_id, this.replyToName)
	}
	},
	retweet () { return !!this.statusoid.retweeted_status },
	retweeter () { return this.statusoid.user.name \|\| this.statusoid.user.screen_name },
	retweeterHtml () { return this.statusoid.user.name_html },
	retweeterProfileLink () { return this.generateUserProfileLink(this.statusoid.user.id, this.statusoid.user.screen_name) },
	status () {
	if (this.retweet) {
	return this.statusoid.retweeted_status
	} else {
	return this.statusoid
	}
	},
	statusFromGlobalRepository () {
	// NOTE: Consider to replace status with statusFromGlobalRepository
	return this.$store.state.statuses.allStatusesObject[this.status.id]
	},
	loggedIn () {
	return !!this.currentUser
	},
	muteWordHits () {
	const statusText = this.status.text.toLowerCase()
	const statusSummary = this.status.summary.toLowerCase()
	const hits = filter(this.muteWords, (muteWord) => {
	return statusText.includes(muteWord.toLowerCase()) \|\| statusSummary.includes(muteWord.toLowerCase())
	})

	return hits
	},
	muted () {
	- const relationship = this.$store.state.users.relationships[this.status.user.id] \|\| {}
	+ const relationship = this.$store.getters.relationship(this.userId)
	return !this.unmuted && (
	(!(this.inProfile && this.status.user.id === this.profileUserId) && relationship.muting) \|\|
	(!this.inConversation && this.status.thread_muted) \|\|
	this.muteWordHits.length > 0)
	},
	hideFilteredStatuses () {
	return this.mergedConfig.hideFilteredStatuses
	},
	hideStatus () {
	return (this.hideReply \|\| this.deleted) \|\| (this.muted && this.hideFilteredStatuses)
	},
	isFocused () {
	// retweet or root of an expanded conversation
	if (this.focused) {
	return true
	} else if (!this.inConversation) {
	return false
	}
	// use conversation highlight only when in conversation
	return this.status.id === this.highlight
	},
	// 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.
	tallStatus () {
	const lengthScore = this.status.statusnet_html.split(/<p\|<br/).length + this.status.text.length / 80
	return lengthScore > 20
	},
	longSubject () {
	return this.status.summary.length > 900
	},
	isReply () {
	return !!(this.status.in_reply_to_status_id && this.status.in_reply_to_user_id)
	},
	replyToName () {
	if (this.status.in_reply_to_screen_name) {
	return this.status.in_reply_to_screen_name
	} else {
	const user = this.$store.getters.findUser(this.status.in_reply_to_user_id)
	return user && user.screen_name
	}
	},
	hideReply () {
	if (this.mergedConfig.replyVisibility === 'all') {
	return false
	}
	if (this.inConversation \|\| !this.isReply) {
	return false
	}
	if (this.status.user.id === this.currentUser.id) {
	return false
	}
	if (this.status.type === 'retweet') {
	return false
	}
	const checkFollowing = this.mergedConfig.replyVisibility === 'following'
	for (var i = 0; i < this.status.attentions.length; ++i) {
	if (this.status.user.id === this.status.attentions[i].id) {
	continue
	}
	// There's zero guarantee of this working. If we happen to have that user and their
	// relationship in store then it will work, but there's kinda little chance of having
	// them for people you're not following.
	const relationship = this.$store.state.users.relationships[this.status.attentions[i].id]
	if (checkFollowing && relationship && relationship.following) {
	return false
	}
	if (this.status.attentions[i].id === this.currentUser.id) {
	return false
	}
	}
	return this.status.attentions.length > 0
	},
	hideSubjectStatus () {
	if (this.tallStatus && !this.localCollapseSubjectDefault) {
	return false
	}
	return !this.expandingSubject && this.status.summary
	},
	hideTallStatus () {
	if (this.status.summary && this.localCollapseSubjectDefault) {
	return false
	}
	if (this.showingTall) {
	return false
	}
	return this.tallStatus
	},
	showingMore () {
	return (this.tallStatus && this.showingTall) \|\| (this.status.summary && this.expandingSubject)
	},
	nsfwClickthrough () {
	if (!this.status.nsfw) {
	return false
	}
	if (this.status.summary && this.localCollapseSubjectDefault) {
	return false
	}
	return true
	},
	replySubject () {
	if (!this.status.summary) return ''
	const decodedSummary = unescape(this.status.summary)
	const behavior = this.mergedConfig.subjectLineBehavior
	const startsWithRe = decodedSummary.match(/^re[: ]/i)
	if ((behavior !== 'noop' && startsWithRe) \|\| behavior === 'masto') {
	return decodedSummary
	} else if (behavior === 'email') {
	return 're: '.concat(decodedSummary)
	} else if (behavior === 'noop') {
	return ''
	}
	},
	attachmentSize () {
	if ((this.mergedConfig.hideAttachments && !this.inConversation) \|\|
	(this.mergedConfig.hideAttachmentsInConv && this.inConversation) \|\|
	(this.status.attachments.length > this.maxThumbnails)) {
	return 'hide'
	} else if (this.compact) {
	return 'small'
	}
	return 'normal'
	},
	galleryTypes () {
	if (this.attachmentSize === 'hide') {
	return []
	}
	return this.mergedConfig.playVideosInModal
	? ['image', 'video']
	: ['image']
	},
	galleryAttachments () {
	return this.status.attachments.filter(
	file => fileType.fileMatchesSomeType(this.galleryTypes, file)
	)
	},
	nonGalleryAttachments () {
	return this.status.attachments.filter(
	file => !fileType.fileMatchesSomeType(this.galleryTypes, file)
	)
	},
	hasImageAttachments () {
	return this.status.attachments.some(
	file => fileType.fileType(file.mimetype) === 'image'
	)
	},
	hasVideoAttachments () {
	return this.status.attachments.some(
	file => fileType.fileType(file.mimetype) === 'video'
	)
	},
	maxThumbnails () {
	return this.mergedConfig.maxThumbnails
	},
	postBodyHtml () {
	const html = this.status.statusnet_html

	if (this.mergedConfig.greentext) {
	try {
	if (html.includes('>')) {
	// This checks if post has '>' at the beginning, excluding mentions so that @mention >impying works
	return processHtml(html, (string) => {
	if (string.includes('>') &&
	string
	.replace(/<[^>]+?>/gi, '') // remove all tags
	.replace(/@\w+/gi, '') // remove mentions (even failed ones)
	.trim()
	.startsWith('>')) {
	return `<span class='greentext'>${string}</span>`
	} else {
	return string
	}
	})
	} else {
	return html
	}
	} catch (e) {
	console.err('Failed to process status html', e)
	return html
	}
	} else {
	return html
	}
	},
	contentHtml () {
	if (!this.status.summary_html) {
	return this.postBodyHtml
	}
	return this.status.summary_html + '<br />' + this.postBodyHtml
	},
	combinedFavsAndRepeatsUsers () {
	// Use the status from the global status repository since favs and repeats are saved in it
	const combinedUsers = [].concat(
	this.statusFromGlobalRepository.favoritedBy,
	this.statusFromGlobalRepository.rebloggedBy
	)
	return uniqBy(combinedUsers, 'id')
	},
	ownStatus () {
	return this.status.user.id === this.currentUser.id
	},
	tags () {
	return this.status.tags.filter(tagObj => tagObj.hasOwnProperty('name')).map(tagObj => tagObj.name).join(' ')
	},
	hidePostStats () {
	return this.mergedConfig.hidePostStats
	},
	...mapGetters(['mergedConfig']),
	...mapState({
	betterShadow: state => state.interface.browserSupport.cssFilter,
	currentUser: state => state.users.currentUser
	})
	},
	components: {
	Attachment,
	FavoriteButton,
	ReactButton,
	RetweetButton,
	ExtraButtons,
	PostStatusForm,
	Poll,
	UserCard,
	UserAvatar,
	Gallery,
	LinkPreview,
	AvatarList,
	Timeago,
	StatusPopover,
	EmojiReactions
	},
	methods: {
	visibilityIcon (visibility) {
	switch (visibility) {
	case 'private':
	return 'icon-lock'
	case 'unlisted':
	return 'icon-lock-open-alt'
	case 'direct':
	return 'icon-mail-alt'
	default:
	return 'icon-globe'
	}
	},
	showError (error) {
	this.error = error
	},
	clearError () {
	this.error = undefined
	},
	linkClicked (event) {
	const target = event.target.closest('.status-content a')
	if (target) {
	if (target.className.match(/mention/)) {
	const href = target.href
	const attn = this.status.attentions.find(attn => mentionMatchesUrl(attn, href))
	if (attn) {
	event.stopPropagation()
	event.preventDefault()
	const link = this.generateUserProfileLink(attn.id, attn.screen_name)
	this.$router.push(link)
	return
	}
	}
	if (target.rel.match(/(?:^\|\s)tag(?:$\|\s)/) \|\| target.className.match(/hashtag/)) {
	// Extract tag name from link url
	const tag = extractTagFromUrl(target.href)
	if (tag) {
	const link = this.generateTagLink(tag)
	this.$router.push(link)
	return
	}
	}
	window.open(target.href, '_blank')
	}
	},
	toggleReplying () {
	this.replying = !this.replying
	},
	gotoOriginal (id) {
	if (this.inConversation) {
	this.$emit('goto', id)
	}
	},
	toggleExpanded () {
	this.$emit('toggleExpanded')
	},
	toggleMute () {
	this.unmuted = !this.unmuted
	},
	toggleUserExpanded () {
	this.userExpanded = !this.userExpanded
	},
	toggleShowMore () {
	if (this.showingTall) {
	this.showingTall = false
	} else if (this.expandingSubject && this.status.summary) {
	this.expandingSubject = false
	} else if (this.hideTallStatus) {
	this.showingTall = true
	} else if (this.hideSubjectStatus && this.status.summary) {
	this.expandingSubject = true
	}
	},
	generateUserProfileLink (id, name) {
	return generateProfileLink(id, name, this.$store.state.instance.restrictedNicknames)
	},
	generateTagLink (tag) {
	return `/tag/${tag}`
	},
	setMedia () {
	const attachments = this.attachmentSize === 'hide' ? this.status.attachments : this.galleryAttachments
	return () => this.$store.dispatch('setMedia', attachments)
	}
	},
	watch: {
	'highlight': function (id) {
	if (this.status.id === id) {
	let rect = this.$el.getBoundingClientRect()
	if (rect.top < 100) {
	// Post is above screen, match its top to screen top
	window.scrollBy(0, rect.top - 100)
	} else if (rect.height >= (window.innerHeight - 50)) {
	// Post we want to see is taller than screen so match its top to screen top
	window.scrollBy(0, rect.top - 100)
	} else if (rect.bottom > window.innerHeight - 50) {
	// Post is below screen, match its bottom to screen bottom
	window.scrollBy(0, rect.bottom - window.innerHeight + 50)
	}
	}
	},
	'status.repeat_num': function (num) {
	// refetch repeats when repeat_num is changed in any way
	if (this.isFocused && this.statusFromGlobalRepository.rebloggedBy && this.statusFromGlobalRepository.rebloggedBy.length !== num) {
	this.$store.dispatch('fetchRepeats', this.status.id)
	}
	},
	'status.fave_num': function (num) {
	// refetch favs when fave_num is changed in any way
	if (this.isFocused && this.statusFromGlobalRepository.favoritedBy && this.statusFromGlobalRepository.favoritedBy.length !== num) {
	this.$store.dispatch('fetchFavs', this.status.id)
	}
	}
	},
	filters: {
	capitalize: function (str) {
	return str.charAt(0).toUpperCase() + str.slice(1)
	}
	}
	}

	export default Status
	diff --git a/src/components/user_card/user_card.js b/src/components/user_card/user_card.js
	index fb3cfebc5e..8e6b9d7fa5 100644
	--- a/src/components/user_card/user_card.js
	+++ b/src/components/user_card/user_card.js
	@@ -1,152 +1,152 @@
	import UserAvatar from '../user_avatar/user_avatar.vue'
	import RemoteFollow from '../remote_follow/remote_follow.vue'
	import ProgressButton from '../progress_button/progress_button.vue'
	import FollowButton from '../follow_button/follow_button.vue'
	import ModerationTools from '../moderation_tools/moderation_tools.vue'
	import AccountActions from '../account_actions/account_actions.vue'
	import generateProfileLink from 'src/services/user_profile_link_generator/user_profile_link_generator'
	import { mapGetters } from 'vuex'

	export default {
	props: [
	'userId', 'switcher', 'selected', 'hideBio', 'rounded', 'bordered', 'allowZoomingAvatar'
	],
	data () {
	return {
	followRequestInProgress: false,
	betterShadow: this.$store.state.interface.browserSupport.cssFilter
	}
	},
	created () {
	this.$store.dispatch('fetchUserRelationship', this.user.id)
	},
	computed: {
	user () {
	return this.$store.getters.findUser(this.userId)
	},
	relationship () {
	- return this.$store.state.users.relationships[this.userId] \|\| {}
	+ return this.$store.getters.relationship(this.userId)
	},
	classes () {
	return [{
	'user-card-rounded-t': this.rounded === 'top', // set border-top-left-radius and border-top-right-radius
	'user-card-rounded': this.rounded === true, // set border-radius for all sides
	'user-card-bordered': this.bordered === true // set border for all sides
	}]
	},
	style () {
	return {
	backgroundImage: [
	`linear-gradient(to bottom, var(--profileTint), var(--profileTint))`,
	`url(${this.user.cover_photo})`
	].join(', ')
	}
	},
	isOtherUser () {
	return this.user.id !== this.$store.state.users.currentUser.id
	},
	subscribeUrl () {
	// eslint-disable-next-line no-undef
	const serverUrl = new URL(this.user.statusnet_profile_url)
	return `${serverUrl.protocol}//${serverUrl.host}/main/ostatus`
	},
	loggedIn () {
	return this.$store.state.users.currentUser
	},
	dailyAvg () {
	const days = Math.ceil((new Date() - new Date(this.user.created_at)) / (60 * 60 * 24 * 1000))
	return Math.round(this.user.statuses_count / days)
	},
	userHighlightType: {
	get () {
	const data = this.$store.getters.mergedConfig.highlight[this.user.screen_name]
	return (data && data.type) \|\| 'disabled'
	},
	set (type) {
	const data = this.$store.getters.mergedConfig.highlight[this.user.screen_name]
	if (type !== 'disabled') {
	this.$store.dispatch('setHighlight', { user: this.user.screen_name, color: (data && data.color) \|\| '#FFFFFF', type })
	} else {
	this.$store.dispatch('setHighlight', { user: this.user.screen_name, color: undefined })
	}
	},
	...mapGetters(['mergedConfig'])
	},
	userHighlightColor: {
	get () {
	const data = this.$store.getters.mergedConfig.highlight[this.user.screen_name]
	return data && data.color
	},
	set (color) {
	this.$store.dispatch('setHighlight', { user: this.user.screen_name, color })
	}
	},
	visibleRole () {
	const rights = this.user.rights
	if (!rights) { return }
	const validRole = rights.admin \|\| rights.moderator
	const roleTitle = rights.admin ? 'admin' : 'moderator'
	return validRole && roleTitle
	},
	hideFollowsCount () {
	return this.isOtherUser && this.user.hide_follows_count
	},
	hideFollowersCount () {
	return this.isOtherUser && this.user.hide_followers_count
	},
	...mapGetters(['mergedConfig'])
	},
	components: {
	UserAvatar,
	RemoteFollow,
	ModerationTools,
	AccountActions,
	ProgressButton,
	FollowButton
	},
	methods: {
	muteUser () {
	this.$store.dispatch('muteUser', this.user.id)
	},
	unmuteUser () {
	this.$store.dispatch('unmuteUser', this.user.id)
	},
	subscribeUser () {
	return this.$store.dispatch('subscribeUser', this.user.id)
	},
	unsubscribeUser () {
	return this.$store.dispatch('unsubscribeUser', this.user.id)
	},
	setProfileView (v) {
	if (this.switcher) {
	const store = this.$store
	store.commit('setProfileView', { v })
	}
	},
	linkClicked ({ target }) {
	if (target.tagName === 'SPAN') {
	target = target.parentNode
	}
	if (target.tagName === 'A') {
	window.open(target.href, '_blank')
	}
	},
	userProfileLink (user) {
	return generateProfileLink(
	user.id, user.screen_name,
	this.$store.state.instance.restrictedNicknames
	)
	},
	zoomAvatar () {
	const attachment = {
	url: this.user.profile_image_url_original,
	mimetype: 'image'
	}
	this.$store.dispatch('setMedia', [attachment])
	this.$store.dispatch('setCurrent', attachment)
	},
	mentionUser () {
	this.$store.dispatch('openPostStatusModal', { replyTo: true, repliedUser: this.user })
	}
	}
	}
	diff --git a/src/components/user_settings/user_settings.js b/src/components/user_settings/user_settings.js
	index adfab8fa21..5338c97402 100644
	--- a/src/components/user_settings/user_settings.js
	+++ b/src/components/user_settings/user_settings.js
	@@ -1,393 +1,393 @@
	import unescape from 'lodash/unescape'
	import get from 'lodash/get'
	import map from 'lodash/map'
	import reject from 'lodash/reject'
	import TabSwitcher from '../tab_switcher/tab_switcher.js'
	import ImageCropper from '../image_cropper/image_cropper.vue'
	import StyleSwitcher from '../style_switcher/style_switcher.vue'
	import ScopeSelector from '../scope_selector/scope_selector.vue'
	import fileSizeFormatService from '../../services/file_size_format/file_size_format.js'
	import BlockCard from '../block_card/block_card.vue'
	import MuteCard from '../mute_card/mute_card.vue'
	import DomainMuteCard from '../domain_mute_card/domain_mute_card.vue'
	import SelectableList from '../selectable_list/selectable_list.vue'
	import ProgressButton from '../progress_button/progress_button.vue'
	import EmojiInput from '../emoji_input/emoji_input.vue'
	import suggestor from '../emoji_input/suggestor.js'
	import Autosuggest from '../autosuggest/autosuggest.vue'
	import Importer from '../importer/importer.vue'
	import Exporter from '../exporter/exporter.vue'
	import withSubscription from '../../hocs/with_subscription/with_subscription'
	import Checkbox from '../checkbox/checkbox.vue'
	import Mfa from './mfa.vue'

	const BlockList = withSubscription({
	fetch: (props, $store) => $store.dispatch('fetchBlocks'),
	select: (props, $store) => get($store.state.users.currentUser, 'blockIds', []),
	childPropName: 'items'
	})(SelectableList)

	const MuteList = withSubscription({
	fetch: (props, $store) => $store.dispatch('fetchMutes'),
	select: (props, $store) => get($store.state.users.currentUser, 'muteIds', []),
	childPropName: 'items'
	})(SelectableList)

	const DomainMuteList = withSubscription({
	fetch: (props, $store) => $store.dispatch('fetchDomainMutes'),
	select: (props, $store) => get($store.state.users.currentUser, 'domainMutes', []),
	childPropName: 'items'
	})(SelectableList)

	const UserSettings = {
	data () {
	return {
	newEmail: '',
	newName: this.$store.state.users.currentUser.name,
	newBio: unescape(this.$store.state.users.currentUser.description),
	newLocked: this.$store.state.users.currentUser.locked,
	newNoRichText: this.$store.state.users.currentUser.no_rich_text,
	newDefaultScope: this.$store.state.users.currentUser.default_scope,
	hideFollows: this.$store.state.users.currentUser.hide_follows,
	hideFollowers: this.$store.state.users.currentUser.hide_followers,
	hideFollowsCount: this.$store.state.users.currentUser.hide_follows_count,
	hideFollowersCount: this.$store.state.users.currentUser.hide_followers_count,
	showRole: this.$store.state.users.currentUser.show_role,
	role: this.$store.state.users.currentUser.role,
	discoverable: this.$store.state.users.currentUser.discoverable,
	allowFollowingMove: this.$store.state.users.currentUser.allow_following_move,
	pickAvatarBtnVisible: true,
	bannerUploading: false,
	backgroundUploading: false,
	banner: null,
	bannerPreview: null,
	background: null,
	backgroundPreview: null,
	bannerUploadError: null,
	backgroundUploadError: null,
	changeEmailError: false,
	changeEmailPassword: '',
	changedEmail: false,
	deletingAccount: false,
	deleteAccountConfirmPasswordInput: '',
	deleteAccountError: false,
	changePasswordInputs: [ '', '', '' ],
	changedPassword: false,
	changePasswordError: false,
	activeTab: 'profile',
	notificationSettings: this.$store.state.users.currentUser.notification_settings,
	newDomainToMute: ''
	}
	},
	created () {
	this.$store.dispatch('fetchTokens')
	},
	components: {
	StyleSwitcher,
	ScopeSelector,
	TabSwitcher,
	ImageCropper,
	BlockList,
	MuteList,
	DomainMuteList,
	EmojiInput,
	Autosuggest,
	BlockCard,
	MuteCard,
	DomainMuteCard,
	ProgressButton,
	Importer,
	Exporter,
	Mfa,
	Checkbox
	},
	computed: {
	user () {
	return this.$store.state.users.currentUser
	},
	emojiUserSuggestor () {
	return suggestor({
	emoji: [
	...this.$store.state.instance.emoji,
	...this.$store.state.instance.customEmoji
	],
	users: this.$store.state.users.users,
	updateUsersList: (input) => this.$store.dispatch('searchUsers', input)
	})
	},
	emojiSuggestor () {
	return suggestor({ emoji: [
	...this.$store.state.instance.emoji,
	...this.$store.state.instance.customEmoji
	] })
	},
	pleromaBackend () {
	return this.$store.state.instance.pleromaBackend
	},
	minimalScopesMode () {
	return this.$store.state.instance.minimalScopesMode
	},
	vis () {
	return {
	public: { selected: this.newDefaultScope === 'public' },
	unlisted: { selected: this.newDefaultScope === 'unlisted' },
	private: { selected: this.newDefaultScope === 'private' },
	direct: { selected: this.newDefaultScope === 'direct' }
	}
	},
	currentSaveStateNotice () {
	return this.$store.state.interface.settings.currentSaveStateNotice
	},
	oauthTokens () {
	return this.$store.state.oauthTokens.tokens.map(oauthToken => {
	return {
	id: oauthToken.id,
	appName: oauthToken.app_name,
	validUntil: new Date(oauthToken.valid_until).toLocaleDateString()
	}
	})
	}
	},
	methods: {
	updateProfile () {
	this.$store.state.api.backendInteractor
	.updateProfile({
	params: {
	note: this.newBio,
	locked: this.newLocked,
	// Backend notation.
	/* eslint-disable camelcase */
	display_name: this.newName,
	default_scope: this.newDefaultScope,
	no_rich_text: this.newNoRichText,
	hide_follows: this.hideFollows,
	hide_followers: this.hideFollowers,
	discoverable: this.discoverable,
	allow_following_move: this.allowFollowingMove,
	hide_follows_count: this.hideFollowsCount,
	hide_followers_count: this.hideFollowersCount,
	show_role: this.showRole
	/* eslint-enable camelcase */
	} }).then((user) => {
	this.$store.commit('addNewUsers', [user])
	this.$store.commit('setCurrentUser', user)
	})
	},
	updateNotificationSettings () {
	this.$store.state.api.backendInteractor
	.updateNotificationSettings({ settings: this.notificationSettings })
	},
	changeVis (visibility) {
	this.newDefaultScope = visibility
	},
	uploadFile (slot, e) {
	const file = e.target.files[0]
	if (!file) { return }
	if (file.size > this.$store.state.instance[slot + 'limit']) {
	const filesize = fileSizeFormatService.fileSizeFormat(file.size)
	const allowedsize = fileSizeFormatService.fileSizeFormat(this.$store.state.instance[slot + 'limit'])
	this[slot + 'UploadError'] = this.$t('upload.error.base') + ' ' + this.$t('upload.error.file_too_big', { filesize: filesize.num, filesizeunit: filesize.unit, allowedsize: allowedsize.num, allowedsizeunit: allowedsize.unit })
	return
	}
	// eslint-disable-next-line no-undef
	const reader = new FileReader()
	reader.onload = ({ target }) => {
	const img = target.result
	this[slot + 'Preview'] = img
	this[slot] = file
	}
	reader.readAsDataURL(file)
	},
	submitAvatar (cropper, file) {
	const that = this
	return new Promise((resolve, reject) => {
	function updateAvatar (avatar) {
	that.$store.state.api.backendInteractor.updateAvatar({ avatar })
	.then((user) => {
	that.$store.commit('addNewUsers', [user])
	that.$store.commit('setCurrentUser', user)
	resolve()
	})
	.catch((err) => {
	reject(new Error(that.$t('upload.error.base') + ' ' + err.message))
	})
	}

	if (cropper) {
	cropper.getCroppedCanvas().toBlob(updateAvatar, file.type)
	} else {
	updateAvatar(file)
	}
	})
	},
	clearUploadError (slot) {
	this[slot + 'UploadError'] = null
	},
	submitBanner () {
	if (!this.bannerPreview) { return }

	this.bannerUploading = true
	this.$store.state.api.backendInteractor.updateBanner({ banner: this.banner })
	.then((user) => {
	this.$store.commit('addNewUsers', [user])
	this.$store.commit('setCurrentUser', user)
	this.bannerPreview = null
	})
	.catch((err) => {
	this.bannerUploadError = this.$t('upload.error.base') + ' ' + err.message
	})
	.then(() => { this.bannerUploading = false })
	},
	submitBg () {
	if (!this.backgroundPreview) { return }
	let background = this.background
	this.backgroundUploading = true
	this.$store.state.api.backendInteractor.updateBg({ background }).then((data) => {
	if (!data.error) {
	this.$store.commit('addNewUsers', [data])
	this.$store.commit('setCurrentUser', data)
	this.backgroundPreview = null
	} else {
	this.backgroundUploadError = this.$t('upload.error.base') + data.error
	}
	this.backgroundUploading = false
	})
	},
	importFollows (file) {
	return this.$store.state.api.backendInteractor.importFollows({ file })
	.then((status) => {
	if (!status) {
	throw new Error('failed')
	}
	})
	},
	importBlocks (file) {
	return this.$store.state.api.backendInteractor.importBlocks({ file })
	.then((status) => {
	if (!status) {
	throw new Error('failed')
	}
	})
	},
	generateExportableUsersContent (users) {
	// Get addresses
	return users.map((user) => {
	// check is it's a local user
	if (user && user.is_local) {
	// append the instance address
	// eslint-disable-next-line no-undef
	return user.screen_name + '@' + location.hostname
	}
	return user.screen_name
	}).join('\n')
	},
	getFollowsContent () {
	return this.$store.state.api.backendInteractor.exportFriends({ id: this.$store.state.users.currentUser.id })
	.then(this.generateExportableUsersContent)
	},
	getBlocksContent () {
	return this.$store.state.api.backendInteractor.fetchBlocks()
	.then(this.generateExportableUsersContent)
	},
	confirmDelete () {
	this.deletingAccount = true
	},
	deleteAccount () {
	this.$store.state.api.backendInteractor.deleteAccount({ password: this.deleteAccountConfirmPasswordInput })
	.then((res) => {
	if (res.status === 'success') {
	this.$store.dispatch('logout')
	this.$router.push({ name: 'root' })
	} else {
	this.deleteAccountError = res.error
	}
	})
	},
	changePassword () {
	const params = {
	password: this.changePasswordInputs[0],
	newPassword: this.changePasswordInputs[1],
	newPasswordConfirmation: this.changePasswordInputs[2]
	}
	this.$store.state.api.backendInteractor.changePassword(params)
	.then((res) => {
	if (res.status === 'success') {
	this.changedPassword = true
	this.changePasswordError = false
	this.logout()
	} else {
	this.changedPassword = false
	this.changePasswordError = res.error
	}
	})
	},
	changeEmail () {
	const params = {
	email: this.newEmail,
	password: this.changeEmailPassword
	}
	this.$store.state.api.backendInteractor.changeEmail(params)
	.then((res) => {
	if (res.status === 'success') {
	this.changedEmail = true
	this.changeEmailError = false
	} else {
	this.changedEmail = false
	this.changeEmailError = res.error
	}
	})
	},
	activateTab (tabName) {
	this.activeTab = tabName
	},
	logout () {
	this.$store.dispatch('logout')
	this.$router.replace('/')
	},
	revokeToken (id) {
	if (window.confirm(`${this.$i18n.t('settings.revoke_token')}?`)) {
	this.$store.dispatch('revokeToken', id)
	}
	},
	filterUnblockedUsers (userIds) {
	return reject(userIds, (userId) => {
	- const relationship = this.$store.state.users.relationships[userId] \|\| {}
	+ const relationship = this.$store.getters.relationship(this.userId)
	return relationship.blocking \|\| userId === this.$store.state.users.currentUser.id
	})
	},
	filterUnMutedUsers (userIds) {
	return reject(userIds, (userId) => {
	- const relationship = this.$store.state.users.relationships[userId] \|\| {}
	+ const relationship = this.$store.getters.relationship(this.userId)
	return relationship.muting \|\| userId === this.$store.state.users.currentUser.id
	})
	},
	queryUserIds (query) {
	return this.$store.dispatch('searchUsers', query)
	.then((users) => map(users, 'id'))
	},
	blockUsers (ids) {
	return this.$store.dispatch('blockUsers', ids)
	},
	unblockUsers (ids) {
	return this.$store.dispatch('unblockUsers', ids)
	},
	muteUsers (ids) {
	return this.$store.dispatch('muteUsers', ids)
	},
	unmuteUsers (ids) {
	return this.$store.dispatch('unmuteUsers', ids)
	},
	unmuteDomains (domains) {
	return this.$store.dispatch('unmuteDomains', domains)
	},
	muteDomain () {
	return this.$store.dispatch('muteDomain', this.newDomainToMute)
	.then(() => { this.newDomainToMute = '' })
	},
	identity (value) {
	return value
	}
	}
	}

	export default UserSettings
	diff --git a/src/modules/users.js b/src/modules/users.js
	index 6b19fc97d7..fb04ebd3db 100644
	--- a/src/modules/users.js
	+++ b/src/modules/users.js
	@@ -1,557 +1,569 @@
	import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js'
	import oauthApi from '../services/new_api/oauth.js'
	import { compact, map, each, merge, last, concat, uniq } from 'lodash'
	import { set } from 'vue'
	import { registerPushNotifications, unregisterPushNotifications } from '../services/push/push.js'

	// TODO: Unify with mergeOrAdd in statuses.js
	export const mergeOrAdd = (arr, obj, item) => {
	if (!item) { return false }
	const oldItem = obj[item.id]
	if (oldItem) {
	// We already have this, so only merge the new info.
	merge(oldItem, item)
	return { item: oldItem, new: false }
	} else {
	// This is a new item, prepare it
	arr.push(item)
	set(obj, item.id, item)
	if (item.screen_name && !item.screen_name.includes('@')) {
	set(obj, item.screen_name.toLowerCase(), item)
	}
	return { item, new: true }
	}
	}

	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 })
	.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 })
	})
	}

	const unblockUser = (store, id) => {
	return store.rootState.api.backendInteractor.unblockUser({ 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 })
	.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]))
	}

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

	export const mutations = {
	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 }, deactivated }) {
	const user = state.usersObject[id]
	set(user, 'deactivated', deactivated)
	},
	setCurrentUser (state, user) {
	state.lastLoginName = user.screen_name
	state.currentUser = merge(state.currentUser \|\| {}, user)
	},
	clearCurrentUser (state) {
	state.currentUser = false
	state.lastLoginName = false
	},
	beginLogin (state) {
	state.loggingIn = true
	},
	endLogin (state) {
	state.loggingIn = false
	},
	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.
	clearFriends (state, userId) {
	const user = state.usersObject[userId]
	if (user) {
	set(user, 'friendIds', [])
	}
	},
	clearFollowers (state, userId) {
	const user = state.usersObject[userId]
	if (user) {
	set(user, 'followerIds', [])
	}
	},
	addNewUsers (state, users) {
	each(users, (user) => {
	if (user.relationship) {
	set(state.relationships, user.relationship.id, user.relationship)
	}
	mergeOrAdd(state.users, state.usersObject, user)
	})
	},
	updateUserRelationship (state, relationships) {
	relationships.forEach((relationship) => {
	set(state.relationships, relationship.id, relationship)
	})
	},
	saveBlockIds (state, blockIds) {
	state.currentUser.blockIds = blockIds
	},
	addBlockId (state, blockId) {
	if (state.currentUser.blockIds.indexOf(blockId) === -1) {
	state.currentUser.blockIds.push(blockId)
	}
	},
	saveMuteIds (state, muteIds) {
	state.currentUser.muteIds = muteIds
	},
	addMuteId (state, muteId) {
	if (state.currentUser.muteIds.indexOf(muteId) === -1) {
	state.currentUser.muteIds.push(muteId)
	}
	},
	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)
	}
	},
	setPinnedToUser (state, status) {
	const user = state.usersObject[status.user.id]
	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 (state, status) {
	status.user = state.usersObject[status.user.id]
	},
	setUserForNotification (state, notification) {
	if (notification.type !== 'follow') {
	notification.action.user = state.usersObject[notification.action.user.id]
	}
	notification.from_profile = state.usersObject[notification.from_profile.id]
	},
	setColor (state, { user: { id }, highlighted }) {
	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
	}
	}

	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
	+ },
	+ relationship: state => id => {
	+ return state.relationships[id] \|\| { id, loading: true }
	}
	}

	export const defaultState = {
	loggingIn: false,
	lastLoginName: false,
	currentUser: false,
	users: [],
	usersObject: {},
	signUpPending: false,
	signUpErrors: [],
	relationships: {}
	}

	const users = {
	state: defaultState,
	mutations,
	getters,
	actions: {
	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))
	}
	},
	fetchBlocks (store) {
	return store.rootState.api.backendInteractor.fetchBlocks()
	.then((blocks) => {
	store.commit('saveBlockIds', map(blocks, 'id'))
	store.commit('addNewUsers', blocks)
	return blocks
	})
	},
	blockUser (store, id) {
	return blockUser(store, id)
	},
	unblockUser (store, id) {
	return unblockUser(store, id)
	},
	blockUsers (store, ids = []) {
	return Promise.all(ids.map(id => blockUser(store, id)))
	},
	unblockUsers (store, ids = []) {
	return Promise.all(ids.map(id => unblockUser(store, id)))
	},
	fetchMutes (store) {
	return store.rootState.api.backendInteractor.fetchMutes()
	.then((mutes) => {
	store.commit('saveMuteIds', map(mutes, 'id'))
	store.commit('addNewUsers', mutes)
	return mutes
	})
	},
	muteUser (store, id) {
	return muteUser(store, id)
	},
	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)))
	},
	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)))
	},
	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 })
	.then((followers) => {
	commit('addNewUsers', followers)
	commit('saveFollowerIds', { id, followerIds: map(followers, 'id') })
	return followers
	})
	},
	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(({ deactivated }) => commit('updateActivationStatus', { user, deactivated }))
	},
	registerPushNotifications (store) {
	const token = store.state.currentUser.credentials
	const vapidPublicKey = store.rootState.instance.vapidPublicKey
	const isEnabled = store.rootState.config.webPushNotifications
	const notificationVisibility = store.rootState.config.notificationVisibility

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

	unregisterPushNotifications(token)
	},
	addNewUsers ({ commit }, users) {
	commit('addNewUsers', users)
	},
	addNewStatuses (store, { statuses }) {
	const users = map(statuses, 'user')
	const retweetedUsers = compact(map(statuses, 'retweeted_status.user'))
	store.commit('addNewUsers', users)
	store.commit('addNewUsers', retweetedUsers)

	each(statuses, (status) => {
	// Reconnect users to statuses
	store.commit('setUserForStatus', status)
	// Set pinned statuses to user
	store.commit('setPinnedToUser', status)
	})
	each(compact(map(statuses, 'retweeted_status')), (status) => {
	// Reconnect users to retweets
	store.commit('setUserForStatus', status)
	// Set pinned retweets to user
	store.commit('setPinnedToUser', status)
	})
	},
	addNewNotifications (store, { notifications }) {
	const users = map(notifications, 'from_profile')
	const targetUsers = map(notifications, 'target').filter(_ => _)
	const notificationIds = notifications.map(_ => _.id)
	store.commit('addNewUsers', users)
	store.commit('addNewUsers', targetUsers)

	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)
	})
	},
	searchUsers (store, query) {
	return store.rootState.api.backendInteractor.searchUsers({ query })
	.then((users) => {
	store.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) {
	return store.rootState.api.backendInteractor.getCaptcha()
	},

	logout (store) {
	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')
	store.commit('clearToken')
	store.dispatch('stopFetchingTimeline', 'friends')
	store.commit('setBackendInteractor', backendInteractorService(store.getters.getToken()))
	store.dispatch('stopFetchingNotifications')
	store.dispatch('stopFetchingFollowRequests')
	store.commit('clearNotifications')
	store.commit('resetStatuses')
	})
	},
	loginUser (store, accessToken) {
	return new Promise((resolve, reject) => {
	const commit = store.commit
	commit('beginLogin')
	store.rootState.api.backendInteractor.verifyCredentials(accessToken)
	.then((data) => {
	if (!data.error) {
	const user = data
	// user.credentials = userCredentials
	user.credentials = accessToken
	user.blockIds = []
	user.muteIds = []
	user.domainMutes = []
	commit('setCurrentUser', user)
	commit('addNewUsers', [user])

	store.dispatch('fetchEmoji')

	getNotificationPermission()
	.then(permission => commit('setNotificationPermission', permission))

	// Set our new backend interactor
	commit('setBackendInteractor', backendInteractorService(accessToken))

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

	// Initialize the chat socket.
	store.dispatch('initializeSocket')
	}

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

	// Start fetching notifications
	store.dispatch('startFetchingNotifications')
	}

	if (store.getters.mergedConfig.useStreamingApi) {
	store.dispatch('enableMastoSockets').catch((error) => {
	console.error('Failed initializing MastoAPI Streaming socket', error)
	startPolling()
	}).then(() => {
	setTimeout(() => store.dispatch('setNotificationsSilence', false), 10000)
	})
	} else {
	startPolling()
	}

	// Get user mutes
	store.dispatch('fetchMutes')

	// Fetch our friends
	store.rootState.api.backendInteractor.fetchFriends({ id: user.id })
	.then((friends) => commit('addNewUsers', friends))
	} else {
	const response = data.error
	// Authentication failed
	commit('endLogin')
	if (response.status === 401) {
	reject(new Error('Wrong username or password'))
	} else {
	reject(new Error('An error occurred, please try again'))
	}
	}
	commit('endLogin')
	resolve()
	})
	.catch((error) => {
	console.log(error)
	commit('endLogin')
	reject(new Error('Failed to connect to server, try again'))
	})
	})
	}
	}
	}

	export default users
	diff --git a/test/unit/specs/components/user_profile.spec.js b/test/unit/specs/components/user_profile.spec.js
	index 0a3f2d272c..dcf066f9a3 100644
	--- a/test/unit/specs/components/user_profile.spec.js
	+++ b/test/unit/specs/components/user_profile.spec.js
	@@ -1,206 +1,207 @@
	import { mount, createLocalVue } from '@vue/test-utils'
	import Vuex from 'vuex'
	import UserProfile from 'src/components/user_profile/user_profile.vue'
	import backendInteractorService from 'src/services/backend_interactor_service/backend_interactor_service.js'
	import { getters } from 'src/modules/users.js'

	const localVue = createLocalVue()
	localVue.use(Vuex)

	const mutations = {
	clearTimeline: () => {},
	setError: () => {}
	}

	const actions = {
	fetchUser: () => {},
	fetchUserByScreenName: () => {}
	}

	const testGetters = {
	findUser: state => getters.findUser(state.users),
	+ relationship: state => getters.relationship(state.users),
	mergedConfig: state => ({
	colors: '',
	highlight: {},
	customTheme: {
	colors: []
	}
	})
	}

	const localUser = {
	id: 100,
	is_local: true,
	screen_name: 'testUser'
	}

	const extUser = {
	id: 100,
	is_local: false,
	screen_name: 'testUser@test.instance'
	}

	const externalProfileStore = new Vuex.Store({
	mutations,
	actions,
	getters: testGetters,
	state: {
	api: {
	fetchers: {},
	backendInteractor: backendInteractorService('')
	},
	interface: {
	browserSupport: ''
	},
	instance: {
	hideUserStats: true
	},
	statuses: {
	timelines: {
	user: {
	statuses: [],
	statusesObject: {},
	faves: [],
	visibleStatuses: [],
	visibleStatusesObject: {},
	newStatusCount: 0,
	maxId: 0,
	minVisibleId: 0,
	loading: false,
	followers: [],
	friends: [],
	viewing: 'statuses',
	userId: 100,
	flushMarker: 0
	},
	media: {
	statuses: [],
	statusesObject: {},
	faves: [],
	visibleStatuses: [],
	visibleStatusesObject: {},
	newStatusCount: 0,
	maxId: 0,
	minVisibleId: 0,
	loading: false,
	followers: [],
	friends: [],
	viewing: 'statuses',
	userId: 100,
	flushMarker: 0
	}
	}
	},
	users: {
	currentUser: {
	credentials: ''
	},
	usersObject: { 100: extUser },
	users: [extUser],
	relationships: {}
	}
	}
	})

	const localProfileStore = new Vuex.Store({
	mutations,
	actions,
	getters: testGetters,
	state: {
	api: {
	fetchers: {},
	backendInteractor: backendInteractorService('')
	},
	interface: {
	browserSupport: ''
	},
	config: {
	colors: '',
	highlight: {},
	customTheme: {
	colors: []
	}
	},
	instance: {
	hideUserStats: true
	},
	statuses: {
	timelines: {
	user: {
	statuses: [],
	statusesObject: {},
	faves: [],
	visibleStatuses: [],
	visibleStatusesObject: {},
	newStatusCount: 0,
	maxId: 0,
	minVisibleId: 0,
	loading: false,
	followers: [],
	friends: [],
	viewing: 'statuses',
	userId: 100,
	flushMarker: 0
	},
	media: {
	statuses: [],
	statusesObject: {},
	faves: [],
	visibleStatuses: [],
	visibleStatusesObject: {},
	newStatusCount: 0,
	maxId: 0,
	minVisibleId: 0,
	loading: false,
	followers: [],
	friends: [],
	viewing: 'statuses',
	userId: 100,
	flushMarker: 0
	}
	}
	},
	users: {
	currentUser: {
	credentials: ''
	},
	usersObject: { 100: localUser, 'testuser': localUser },
	users: [localUser],
	relationships: {}
	}
	}
	})

	describe('UserProfile', () => {
	it('renders external profile', () => {
	const wrapper = mount(UserProfile, {
	localVue,
	store: externalProfileStore,
	mocks: {
	$route: {
	params: { id: 100 },
	name: 'external-user-profile'
	},
	$t: (msg) => msg
	}
	})

	expect(wrapper.find('.user-screen-name').text()).to.eql('@testUser@test.instance')
	})

	it('renders local profile', () => {
	const wrapper = mount(UserProfile, {
	localVue,
	store: localProfileStore,
	mocks: {
	$route: {
	params: { name: 'testUser' },
	name: 'user-profile'
	},
	$t: (msg) => msg
	}
	})

	expect(wrapper.find('.user-screen-name').text()).to.eql('@testUser')
	})
	})

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 29, 2:57 PM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1737134
Default Alt Text: (66 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions