No OneTemporary
Actions

Size

55 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/components/update_notification/update_notification.js b/src/components/update_notification/update_notification.js
	index 6b8665dd8f..1dd771ebc8 100644
	--- a/src/components/update_notification/update_notification.js
	+++ b/src/components/update_notification/update_notification.js
	@@ -1,24 +1,58 @@
	import Modal from 'src/components/modal/modal.vue'
	import { library } from '@fortawesome/fontawesome-svg-core'
	import pleromaTan from 'src/assets/pleromatan_apology.png'
	import pleromaTanFox from 'src/assets/pleromatan_apology_fox.png'

	import {
	faTimes
	} from '@fortawesome/free-solid-svg-icons'
	library.add(
	faTimes
	)

	-const SettingsModal = {
	+const CURRENT_UPDATE_COUNTER = 1
	+
	+const UpdateNotification = {
	data () {
	return {
	- pleromaTanVariant: Math.random() > 0.5 ? pleromaTan : pleromaTanFox
	+ pleromaTanVariant: Math.random() > 0.5 ? pleromaTan : pleromaTanFox,
	+ showingMore: true,
	+ contentHeight: 0
	}
	},
	components: {
	Modal
	+ },
	+ computed: {
	+ pleromaTanStyles () {
	+ return {
	+ 'shape-outside': 'url(' + this.pleromaTanVariant + ')'
	+ }
	+ },
	+ shouldShow () {
	+ return this.$store.state.serverSideStorage.flagStorage.updateCounter < CURRENT_UPDATE_COUNTER &&
	+ !this.$store.state.serverSideStorage.flagStorage.dontShowUpdateNotifs
	+ }
	+ },
	+ methods: {
	+ toggleShow () {
	+ this.showingMore = !this.showingMore
	+ },
	+ neverShowAgain () {
	+ this.$store.commit('setFlag', { flag: 'updateCounter', value: CURRENT_UPDATE_COUNTER })
	+ this.$store.commit('setFlag', { flag: 'dontShowUpdateNotifs', value: 1 })
	+ this.$store.dispatch('pushServerSideStorage')
	+ },
	+ dismiss () {
	+ this.$store.commit('setFlag', { flag: 'updateCounter', value: CURRENT_UPDATE_COUNTER })
	+ this.$store.dispatch('pushServerSideStorage')
	+ }
	+ },
	+ mounted () {
	+ setTimeout(() => {
	+ this.contentHeight = this.$refs.content.offsetHeight
	+ }, 10)
	}
	}

	-export default SettingsModal
	+export default UpdateNotification
	diff --git a/src/components/update_notification/update_notification.scss b/src/components/update_notification/update_notification.scss
	index 5fd9eb9bfe..594f4c6b0e 100644
	--- a/src/components/update_notification/update_notification.scss
	+++ b/src/components/update_notification/update_notification.scss
	@@ -1,34 +1,105 @@
	@import 'src/_variables.scss';
	+.UpdateNotification {
	+ overflow: hidden;
	+}
	.UpdateNotificationModal {
	+ --__top-fringe: 18em; // how much pleroma-tan should stick her head above
	+ --__bottom-fringe: 80em; // just reserving as much as we can, number is mostly irrelevant
	+ --__right-fringe: 8em;
	+
	+ font-size: 15px;
	/* Explanation:
	* Modal is positioned vertically centered.
	* 100vh - 100% = Distance between modal's top+bottom boundaries and screen
	* (100vh - 100%) / 2 = Distance between bottom (or top) boundary and screen
	* + 10% - we move modal completely off-screen, it's top boundary touches
	* bottom of the screen
	* - 50px - leaving tiny amount of space so that titlebar + tiny amount of modal is visible
	*/
	- transform: translateY(calc(((100vh - 100%) / 2 + 5%)));
	- max-width: 90vh;
	- width: 30em;
	position: relative;
	+ transition: transform;
	+ transition-timing-function: ease-in-out;
	+ transition-duration: 500ms;
	+
	+ .text {
	+ width: 40em;
	+ padding-left: 1em;
	+ }

	@media all and (max-width: 800px) {
	/* For mobile, the modal takes 100% of the available screen.
	This ensures the minimized modal is always 50px above the browser bottom bar regardless of whether or not it is visible.
	*/
	- transform: translateY(calc(100% - 50px));
	+ width: 100vw;
	+ }
	+
	+ @media all and (max-height: 600px) {
	+ display: none;
	}
	- .panel-body > p {
	- width: calc(100% - 10em)
	+
	+ .content {
	+ overflow: hidden;
	+ margin-top: calc(-1 * var(--__top-fringe));
	+ margin-bottom: calc(-1 * var(--__bottom-fringe));
	+ margin-right: calc(-1 * var(--__right-fringe));
	+ }
	+
	+ .panel-body {
	+ border-width: 0 0 1px 0;
	+ border-style: solid;
	+ border-color: var(--border, $fallback--border);
	+ }
	+
	+ .panel-footer {
	+ z-index: 22;
	+ position: relative;
	+ border-width: 0;
	+ grid-template-columns: auto;
	}

	.pleroma-tan {
	- max-width: 20em;
	- max-height: 40em;
	- position: absolute;
	- right: -5em;
	- top: -10em;
	- z-index: 10;
	+ object-fit: cover;
	+ object-position: top;
	+ transition: position, left, right, top, bottom, max-width, max-height;
	+ transition-timing-function: ease-in-out;
	+ transition-duration: 500ms;
	+ width: 25em;
	+ float: right;
	+ z-index: 20;
	+ position: relative;
	+ shape-margin: 0.5em;
	+ }
	+
	+ .spacer-top {
	+ min-height: var(--__top-fringe);
	+ }
	+
	+ .spacer-bottom {
	+ min-height: var(--__bottom-fringe);
	+ }
	+
	+ .extra-info {
	+ transition: max-height, padding, height;
	+ transition-timing-function: ease-in-out;
	+ transition-duration: 500ms;
	+ max-height: auto;
	+ height: auto;
	+ }
	+
	+ &.-peek {
	+ transform: translateY(calc(((100vh - 100%) / 2)));
	+
	+ .pleroma-tan {
	+ float: right;
	+ z-index: 10;
	+ shape-image-threshold: 0.7;
	+ }
	+
	+ .extra-info {
	+ max-height: 0;
	+ height: 0;
	+ display: none;
	+ overflow: hidden;
	+ }
	}
	}
	diff --git a/src/components/update_notification/update_notification.vue b/src/components/update_notification/update_notification.vue
	index e7118d8137..793966eba3 100644
	--- a/src/components/update_notification/update_notification.vue
	+++ b/src/components/update_notification/update_notification.vue
	@@ -1,41 +1,61 @@
	<template>
	<Modal
	- :is-open="true"
	+ :is-open="shouldShow"
	class="UpdateNotification"
	- :class="{ peek: modalPeeked }"
	:no-background="true"
	>
	- <div class="UpdateNotificationModal panel">
	+ <div
	+ class="UpdateNotificationModal panel"
	+ :class="{ '-peek': !showingMore }"
	+ >
	<div class="panel-heading">
	<span class="title">
	{{ $t('update.big_update_title') }}
	</span>
	</div>
	<div class="panel-body">
	- <p>
	- {{ $t('update.big_update_content') }}
	- </p>
	- <p>
	+ <div class="content" ref="content">
	+ <img class="pleroma-tan" :src="pleromaTanVariant" :style="pleromaTanStyles"/>
	+ <div class="spacer-top"/>
	+ <div class="text">
	+ <p>
	+ {{ $t('update.big_update_content') }}
	+ </p>
	+ <p class="extra-info">
	+ {{ $t('update.update_bugs') }}
	+ </p>
	+ <p class="extra-info">
	+ {{ $t('update.update_changelog') }}
	+ </p>
	+ </div>
	+ <div class="spacer-bottom"/>
	+ </div>
	+ </div>
	+ <div class="panel-footer">
	+ <button
	+ class="button-default"
	+ @click.prevent="neverShowAgain"
	+ >
	+ {{ $t("general.never_show_again") }}
	+ </button>
	<button
	- class="button-unstyled -link tall-status-hider"
	+ class="button-default"
	@click.prevent="toggleShowMore"
	- >
	+ v-if="!showingMore"
	+ >
	{{ $t("general.show_more") }}
	</button>
	- {{ ' ' }}
	<button
	- class="button-unstyled -link tall-status-hider"
	- @click.prevent="toggleShowMore"
	- >
	- {{ $t("general.never_show_again") }}
	+ class="button-default"
	+ @click.prevent="dismiss"
	+ >
	+ {{ $t("general.dismiss") }}
	</button>
	- </p>
	- <img class="pleroma-tan" :src="pleromaTanVariant"/>
	</div>
	</div>
	</Modal>
	</template>

	<script src="./update_notification.js"></script>

	<style src="./update_notification.scss" lang="scss"></style>
	diff --git a/src/lib/persisted_state.js b/src/lib/persisted_state.js
	index c73a38ecf7..6d59c59552 100644
	--- a/src/lib/persisted_state.js
	+++ b/src/lib/persisted_state.js
	@@ -1,94 +1,95 @@
	import merge from 'lodash.merge'
	import localforage from 'localforage'
	import { each, get, set, cloneDeep } from 'lodash'

	let loaded = false

	const defaultReducer = (state, paths) => (
	paths.length === 0
	? state
	: paths.reduce((substate, path) => {
	set(substate, path, get(state, path))
	return substate
	}, {})
	)

	const saveImmedeatelyActions = [
	'markNotificationsAsSeen',
	'clearCurrentUser',
	'setCurrentUser',
	+ 'setServerSideStorage',
	'setHighlight',
	'setOption',
	'setClientData',
	'setToken',
	'clearToken'
	]

	const defaultStorage = (() => {
	return localforage
	})()

	export default function createPersistedState ({
	key = 'vuex-lz',
	paths = [],
	getState = (key, storage) => {
	const value = storage.getItem(key)
	return value
	},
	setState = (key, state, storage) => {
	if (!loaded) {
	console.log('waiting for old state to be loaded...')
	return Promise.resolve()
	} else {
	return storage.setItem(key, state)
	}
	},
	reducer = defaultReducer,
	storage = defaultStorage,
	subscriber = store => handler => store.subscribe(handler)
	} = {}) {
	return getState(key, storage).then((savedState) => {
	return store => {
	try {
	if (savedState !== null && typeof savedState === 'object') {
	// build user cache
	const usersState = savedState.users \|\| {}
	usersState.usersObject = {}
	const users = usersState.users \|\| []
	each(users, (user) => { usersState.usersObject[user.id] = user })
	savedState.users = usersState

	store.replaceState(
	merge({}, store.state, savedState)
	)
	}
	loaded = true
	} catch (e) {
	console.log("Couldn't load state")
	console.error(e)
	loaded = true
	}
	subscriber(store)((mutation, state) => {
	try {
	if (saveImmedeatelyActions.includes(mutation.type)) {
	setState(key, reducer(cloneDeep(state), paths), storage)
	.then(success => {
	if (typeof success !== 'undefined') {
	if (mutation.type === 'setOption' \|\| mutation.type === 'setCurrentUser') {
	store.dispatch('settingsSaved', { success })
	}
	}
	}, error => {
	if (mutation.type === 'setOption' \|\| mutation.type === 'setCurrentUser') {
	store.dispatch('settingsSaved', { error })
	}
	})
	}
	} catch (e) {
	console.log("Couldn't persist state:")
	console.log(e)
	}
	})
	}
	})
	}
	diff --git a/src/main.js b/src/main.js
	index eacd554cfd..fc798ed60e 100644
	--- a/src/main.js
	+++ b/src/main.js
	@@ -1,100 +1,103 @@
	import { createStore } from 'vuex'

	import 'custom-event-polyfill'
	import './lib/event_target_polyfill.js'

	import interfaceModule from './modules/interface.js'
	import instanceModule from './modules/instance.js'
	import statusesModule from './modules/statuses.js'
	import usersModule from './modules/users.js'
	import apiModule from './modules/api.js'
	import configModule from './modules/config.js'
	import serverSideConfigModule from './modules/serverSideConfig.js'
	+import serverSideStorageModule from './modules/serverSideStorage.js'
	import shoutModule from './modules/shout.js'
	import oauthModule from './modules/oauth.js'
	import authFlowModule from './modules/auth_flow.js'
	import mediaViewerModule from './modules/media_viewer.js'
	import oauthTokensModule from './modules/oauth_tokens.js'
	import reportsModule from './modules/reports.js'
	import pollsModule from './modules/polls.js'
	import postStatusModule from './modules/postStatus.js'
	import chatsModule from './modules/chats.js'

	import { createI18n } from 'vue-i18n'

	import createPersistedState from './lib/persisted_state.js'
	import pushNotifications from './lib/push_notifications_plugin.js'

	import messages from './i18n/messages.js'

	import afterStoreSetup from './boot/after_store.js'

	const currentLocale = (window.navigator.language \|\| 'en').split('-')[0]

	const i18n = createI18n({
	// By default, use the browser locale, we will update it if neccessary
	locale: 'en',
	fallbackLocale: 'en',
	messages: messages.default
	})

	messages.setLanguage(i18n, currentLocale)

	const persistedStateOptions = {
	paths: [
	+ 'serverSideStorage.cache',
	'config',
	'users.lastLoginName',
	'oauth'
	]
	};

	(async () => {
	let storageError = false
	const plugins = [pushNotifications]
	try {
	const persistedState = await createPersistedState(persistedStateOptions)
	plugins.push(persistedState)
	} catch (e) {
	console.error(e)
	storageError = true
	}
	const store = createStore({
	modules: {
	i18n: {
	getters: {
	i18n: () => i18n.global
	}
	},
	interface: interfaceModule,
	instance: instanceModule,
	// TODO refactor users/statuses modules, they depend on each other
	users: usersModule,
	statuses: statusesModule,
	api: apiModule,
	config: configModule,
	serverSideConfig: serverSideConfigModule,
	+ serverSideStorage: serverSideStorageModule,
	shout: shoutModule,
	oauth: oauthModule,
	authFlow: authFlowModule,
	mediaViewer: mediaViewerModule,
	oauthTokens: oauthTokensModule,
	reports: reportsModule,
	polls: pollsModule,
	postStatus: postStatusModule,
	chats: chatsModule
	},
	plugins,
	strict: false // Socket modifies itself, let's ignore this for now.
	// strict: process.env.NODE_ENV !== 'production'
	})
	if (storageError) {
	store.dispatch('pushGlobalNotice', { messageKey: 'errors.storage_unavailable', level: 'error' })
	}
	afterStoreSetup({ store, i18n })
	})()

	// These are inlined by webpack's DefinePlugin
	/* eslint-disable */
	window.___pleromafe_mode = process.env
	window.___pleromafe_commit_hash = COMMIT_HASH
	window.___pleromafe_dev_overrides = DEV_OVERRIDES
	diff --git a/src/modules/serverSideStorage.js b/src/modules/serverSideStorage.js
	new file mode 100644
	index 0000000000..5ebe17fd5e
	--- /dev/null
	+++ b/src/modules/serverSideStorage.js
	@@ -0,0 +1,158 @@
	+import { toRaw } from 'vue'
	+
	+const VERSION = 1
	+const NEW_USER_DATE = new Date('04-08-2022') // date of writing this, basically
	+
	+const COMMAND_TRIM_FLAGS = 1000
	+const COMMAND_TRIM_FLAGS_AND_RESET = 1001
	+
	+const defaultState = {
	+ // last timestamp
	+ timestamp: 0,
	+ // need to update server
	+ dirty: false,
	+ // storage of flags - stuff that can only be set and incremented
	+ flagStorage: {
	+ updateCounter: 0, // Counter for most recent update notification seen
	+ // TODO move to prefsStorage when that becomes a thing since only way
	+ // this can be reset is by complete reset of all flags
	+ dontShowUpdateNotifs: 0, // if user chose to not show update notifications ever again
	+ reset: 0 // special flag that can be used to force-reset all flags, debug purposes only
	+ // special reset codes:
	+ // 1000: trim keys to those known by currently running FE
	+ // 1001: same as above + reset everything to 0
	+ },
	+ // raw data
	+ raw: null,
	+ // local cache
	+ cache: null
	+}
	+
	+const newUserFlags = {
	+ ...defaultState.flagStorage,
	+ updateCounter: 1 // new users don't need to see update notification
	+}
	+
	+const serverSideStorage = {
	+ state: {
	+ ...defaultState
	+ },
	+ mutations: {
	+ setServerSideStorage (state, userData) {
	+ const live = userData.storage
	+ const userNew = userData.created_at > NEW_USER_DATE
	+ const flagsTemplate = userNew ? newUserFlags : defaultState.defaultState
	+ state.raw = live
	+ console.log(1111, live._timestamp)
	+ let recent = null
	+ const cache = state.cache \|\| {}
	+ const cacheValid = cache._timestamp > 0 && cache._version > 0
	+ const liveValid = live._timestamp > 0 && live._version > 0
	+ if (!liveValid) {
	+ state.dirty = true
	+ console.debug('Nothing valid stored on server, assuming cache to be source of truth')
	+ if (cacheValid) {
	+ recent = cache
	+ } else {
	+ console.debug(`Local cache is empty, initializing for ${userNew ? 'new' : 'existing'} user`)
	+
	+ recent = {
	+ _timestamp: Date.now(),
	+ _version: VERSION,
	+ flagStorage: { ...flagsTemplate }
	+ }
	+ }
	+ } else if (!cacheValid) {
	+ console.debug('Valid storage on server found, no local cache found, using live as source of truth')
	+ recent = live
	+ } else {
	+ console.debug('Both sources have valid data, figuring things out...')
	+ console.log(live._timestamp, cache._timestamp)
	+ if (live._timestamp === cache._timestamp && live._version === cache._version) {
	+ console.debug('Same version/timestamp on both source, source of truth irrelevant')
	+ recent = cache
	+ } else {
	+ state.dirty = true
	+ console.debug('Different timestamp, figuring out which one is more recent')
	+ let stale
	+ if (live._timestamp < cache._timestamp) {
	+ recent = cache
	+ stale = live
	+ } else {
	+ recent = live
	+ stale = cache
	+ }
	+
	+ // Merge the flags
	+ console.debug('Merging the flags...')
	+ recent.flagStorage = recent.flagStorage \|\| { ...flagsTemplate }
	+ stale.flagStorage = stale.flagStorage \|\| { ...flagsTemplate }
	+ const allFlags = Array.from(new Set([
	+ ...Object.keys(toRaw(recent.flagStorage)),
	+ ...Object.keys(toRaw(stale.flagStorage))
	+ ]))
	+
	+ const totalFlags = Object.fromEntries(allFlags.map(flag => {
	+ const recentFlag = recent.flagStorage[flag]
	+ const staleFlag = stale.flagStorage[flag]
	+ // use flag that is of higher value
	+ return [flag, recentFlag > staleFlag ? recentFlag : staleFlag]
	+ }))
	+
	+ console.debug('AAA', totalFlags)
	+ // flag reset functionality
	+ if (totalFlags.reset >= COMMAND_TRIM_FLAGS && totalFlags.reset <= COMMAND_TRIM_FLAGS_AND_RESET) {
	+ console.debug('Received command to trim the flags')
	+ const knownKeys = new Set(Object.keys(defaultState.flagStorage))
	+ allFlags.forEach(flag => {
	+ if (!knownKeys.has(flag)) {
	+ delete totalFlags[flag]
	+ }
	+ })
	+ if (totalFlags.reset === COMMAND_TRIM_FLAGS_AND_RESET) {
	+ // 1001 - and reset everything to 0
	+ console.debug('Received command to reset the flags')
	+ allFlags.forEach(flag => { totalFlags[flag] = 0 })
	+ } else {
	+ // reset the reset 0
	+ totalFlags.reset = 0
	+ }
	+ } else if (totalFlags.reset > 0 && totalFlags.reset < 9000) {
	+ console.debug('Received command to reset the flags')
	+ allFlags.forEach(flag => { totalFlags[flag] = 0 })
	+ // for good luck
	+ totalFlags.reset = 0
	+ }
	+ console.log('AAAA', totalFlags)
	+ state.cache.flagStorage = totalFlags
	+ }
	+ }
	+ state.cache = recent
	+ state.flagStorage = state.cache.flagStorage
	+ },
	+ setFlag (state, { flag, value }) {
	+ state.flagStorage[flag] = value
	+ state.dirty = true
	+ }
	+ },
	+ actions: {
	+ pushServerSideStorage ({ state, rootState, commit }, { force = false } = {}) {
	+ console.log('PUSH')
	+ const needPush = state.dirty \|\| force
	+ if (!needPush) return
	+ state.cache = {
	+ _timestamp: Date.now(),
	+ _version: VERSION,
	+ flagStorage: toRaw(state.flagStorage)
	+ }
	+ console.log('YES')
	+ const params = { pleroma_settings_store: { 'pleroma-fe': state.cache } }
	+ rootState.api.backendInteractor
	+ .updateProfile({ params })
	+ .then((user) => commit('setServerSideStorage', user))
	+ state.dirty = false
	+ }
	+ }
	+}
	+
	+export default serverSideStorage
	diff --git a/src/modules/users.js b/src/modules/users.js
	index 13d4e318e5..b6fb9746a8 100644
	--- a/src/modules/users.js
	+++ b/src/modules/users.js
	@@ -1,601 +1,603 @@
	import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js'
	import { windowWidth, windowHeight } from '../services/window_utils/window_utils'
	import oauthApi from '../services/new_api/oauth.js'
	import { compact, map, each, mergeWith, last, concat, uniq, isArray } from 'lodash'
	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.
	mergeWith(oldItem, item, mergeArrayLength)
	return { item: oldItem, new: false }
	} else {
	// This is a new item, prepare it
	arr.push(item)
	obj[item.id] = item
	if (item.screen_name && !item.screen_name.includes('@')) {
	obj[item.screen_name.toLowerCase()] = item
	}
	return { item, new: true }
	}
	}

	const mergeArrayLength = (oldValue, newValue) => {
	if (isArray(oldValue) && isArray(newValue)) {
	oldValue.length = newValue.length
	return mergeWith(oldValue, newValue, mergeArrayLength)
	}
	}

	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])
	user.tags = newTags
	},
	untagUser (state, { user: { id }, tag }) {
	const user = state.usersObject[id]
	const tags = user.tags \|\| []
	const newTags = tags.filter(t => t !== tag)
	user.tags = newTags
	},
	updateRight (state, { user: { id }, right, value }) {
	const user = state.usersObject[id]
	const newRights = user.rights
	newRights[right] = value
	user.rights = newRights
	},
	updateActivationStatus (state, { user: { id }, deactivated }) {
	const user = state.usersObject[id]
	user.deactivated = deactivated
	},
	setCurrentUser (state, user) {
	state.lastLoginName = user.screen_name
	state.currentUser = mergeWith(state.currentUser \|\| {}, user, mergeArrayLength)
	},
	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) {
	user.friendIds = []
	}
	},
	clearFollowers (state, userId) {
	const user = state.usersObject[userId]
	if (user) {
	user.followerIds = []
	}
	},
	addNewUsers (state, users) {
	each(users, (user) => {
	if (user.relationship) {
	state.relationships[user.relationship.id] = user.relationship
	}
	mergeOrAdd(state.users, state.usersObject, user)
	})
	},
	updateUserRelationship (state, relationships) {
	relationships.forEach((relationship) => {
	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]
	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 (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]
	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
	},
	findUserByUrl: state => query => {
	return state.users
	.find(u => u.statusnet_profile_url &&
	u.statusnet_profile_url.toLowerCase() === query.toLowerCase())
	},
	relationship: state => id => {
	const rel = id && state.relationships[id]
	return rel \|\| { 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: {
	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))
	}
	},
	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((user) => { const deactivated = !user.is_active; 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 ({ rootState, commit }, { query }) {
	return rootState.api.backendInteractor.searchUsers({ query })
	.then((users) => {
	commit('addNewUsers', users)
	return users
	})
	},
	async signUp (store, userInfo) {
	store.commit('signUpPending')

	const rootState = store.rootState

	try {
	const 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) {
	const 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')
	store.dispatch('resetChats')
	store.dispatch('setLastTimeline', 'public-timeline')
	store.dispatch('setLayoutWidth', windowWidth())
	store.dispatch('setLayoutHeight', windowHeight())
	})
	},
	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('setServerSideStorage', user)
	commit('addNewUsers', [user])

	store.dispatch('fetchEmoji')

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

	// Set our new backend interactor
	commit('setBackendInteractor', backendInteractorService(accessToken))
	+ store.dispatch('pushServerSideStorage')

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

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

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

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

	// Start fetching chats
	store.dispatch('startFetchingChats')
	}

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

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

	store.dispatch('setLayoutWidth', windowWidth())
	store.dispatch('setLayoutHeight', windowHeight())

	// 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/src/services/entity_normalizer/entity_normalizer.service.js b/src/services/entity_normalizer/entity_normalizer.service.js
	index 7f831ed905..e6a87b63f1 100644
	--- a/src/services/entity_normalizer/entity_normalizer.service.js
	+++ b/src/services/entity_normalizer/entity_normalizer.service.js
	@@ -1,454 +1,457 @@
	import escape from 'escape-html'
	import parseLinkHeader from 'parse-link-header'
	import { isStatusNotification } from '../notification_utils/notification_utils.js'
	import punycode from 'punycode.js'

	/ NOTICE!
	* Do not initialize UI-generated data here.
	* It will override existing data.
	*
	* i.e. user.pinnedStatusIds was set to [] here
	* UI code would update it with data but upon next user fetch
	* it would be reverted back to []
	*/

	const qvitterStatusType = (status) => {
	if (status.is_post_verb) {
	return 'status'
	}

	if (status.retweeted_status) {
	return 'retweet'
	}

	if ((typeof status.uri === 'string' && status.uri.match(/(fave\|objectType=Favourite)/)) \|\|
	(typeof status.text === 'string' && status.text.match(/favorited/))) {
	return 'favorite'
	}

	if (status.text.match(/deleted notice {{tag/) \|\| status.qvitter_delete_notice) {
	return 'deletion'
	}

	if (status.text.match(/started following/) \|\| status.activity_type === 'follow') {
	return 'follow'
	}

	return 'unknown'
	}

	export const parseUser = (data) => {
	const output = {}
	const masto = Object.prototype.hasOwnProperty.call(data, 'acct')
	// case for users in "mentions" property for statuses in MastoAPI
	const mastoShort = masto && !Object.prototype.hasOwnProperty.call(data, 'avatar')

	output.id = String(data.id)
	output._original = data // used for server-side settings

	if (masto) {
	output.screen_name = data.acct
	output.statusnet_profile_url = data.url

	// There's nothing else to get
	if (mastoShort) {
	return output
	}

	output.emoji = data.emojis
	output.name = escape(data.display_name)
	output.name_html = output.name
	output.name_unescaped = data.display_name

	output.description = data.note
	// TODO cleanup this shit, output.description is overriden with source data
	output.description_html = data.note

	output.fields = data.fields
	output.fields_html = data.fields.map(field => {
	return {
	name: escape(field.name),
	value: field.value
	}
	})
	output.fields_text = data.fields.map(field => {
	return {
	name: unescape(field.name.replace(/<[^>]*>/g, '')),
	value: unescape(field.value.replace(/<[^>]*>/g, ''))
	}
	})

	// Utilize avatar_static for gif avatars?
	output.profile_image_url = data.avatar
	output.profile_image_url_original = data.avatar

	// Same, utilize header_static?
	output.cover_photo = data.header

	output.friends_count = data.following_count

	output.bot = data.bot

	if (data.pleroma) {
	+ if (data.pleroma.settings_store) {
	+ output.storage = data.pleroma.settings_store['pleroma-fe']
	+ }
	const relationship = data.pleroma.relationship

	output.background_image = data.pleroma.background_image
	output.favicon = data.pleroma.favicon
	output.token = data.pleroma.chat_token

	if (relationship) {
	output.relationship = relationship
	}

	output.allow_following_move = data.pleroma.allow_following_move

	output.hide_follows = data.pleroma.hide_follows
	output.hide_followers = data.pleroma.hide_followers
	output.hide_follows_count = data.pleroma.hide_follows_count
	output.hide_followers_count = data.pleroma.hide_followers_count

	output.rights = {
	moderator: data.pleroma.is_moderator,
	admin: data.pleroma.is_admin
	}
	// TODO: Clean up in UI? This is duplication from what BE does for qvitterapi
	if (output.rights.admin) {
	output.role = 'admin'
	} else if (output.rights.moderator) {
	output.role = 'moderator'
	} else {
	output.role = 'member'
	}
	}

	if (data.source) {
	output.description = data.source.note
	output.default_scope = data.source.privacy
	output.fields = data.source.fields
	if (data.source.pleroma) {
	output.no_rich_text = data.source.pleroma.no_rich_text
	output.show_role = data.source.pleroma.show_role
	output.discoverable = data.source.pleroma.discoverable
	}
	}

	// TODO: handle is_local
	output.is_local = !output.screen_name.includes('@')
	} else {
	output.screen_name = data.screen_name

	output.name = data.name
	output.name_html = data.name_html

	output.description = data.description
	output.description_html = data.description_html

	output.profile_image_url = data.profile_image_url
	output.profile_image_url_original = data.profile_image_url_original

	output.cover_photo = data.cover_photo

	output.friends_count = data.friends_count

	// output.bot = ??? missing

	output.statusnet_profile_url = data.statusnet_profile_url

	output.is_local = data.is_local
	output.role = data.role
	output.show_role = data.show_role

	if (data.rights) {
	output.rights = {
	moderator: data.rights.delete_others_notice,
	admin: data.rights.admin
	}
	}
	output.no_rich_text = data.no_rich_text
	output.default_scope = data.default_scope
	output.hide_follows = data.hide_follows
	output.hide_followers = data.hide_followers
	output.hide_follows_count = data.hide_follows_count
	output.hide_followers_count = data.hide_followers_count
	output.background_image = data.background_image
	// Websocket token
	output.token = data.token

	// Convert relationsip data to expected format
	output.relationship = {
	muting: data.muted,
	blocking: data.statusnet_blocking,
	followed_by: data.follows_you,
	following: data.following
	}
	}

	output.created_at = new Date(data.created_at)
	output.locked = data.locked
	output.followers_count = data.followers_count
	output.statuses_count = data.statuses_count

	if (data.pleroma) {
	output.follow_request_count = data.pleroma.follow_request_count

	output.tags = data.pleroma.tags

	// deactivated was changed to is_active in Pleroma 2.3.0
	// so check if is_active is present
	output.deactivated = typeof data.pleroma.is_active !== 'undefined'
	? !data.pleroma.is_active // new backend
	: data.pleroma.deactivated // old backend

	output.notification_settings = data.pleroma.notification_settings
	output.unread_chat_count = data.pleroma.unread_chat_count
	}

	output.tags = output.tags \|\| []
	output.rights = output.rights \|\| {}
	output.notification_settings = output.notification_settings \|\| {}

	// Convert punycode to unicode for UI
	output.screen_name_ui = output.screen_name
	if (output.screen_name && output.screen_name.includes('@')) {
	const parts = output.screen_name.split('@')
	let unicodeDomain = punycode.toUnicode(parts[1])
	if (unicodeDomain !== parts[1]) {
	// Add some identifier so users can potentially spot spoofing attempts:
	// lain.com and xn--lin-6cd.com would appear identical otherwise.
	unicodeDomain = '🌏' + unicodeDomain
	output.screen_name_ui = [parts[0], unicodeDomain].join('@')
	}
	}

	return output
	}

	export const parseAttachment = (data) => {
	const output = {}
	const masto = !Object.prototype.hasOwnProperty.call(data, 'oembed')

	if (masto) {
	// Not exactly same...
	output.mimetype = data.pleroma ? data.pleroma.mime_type : data.type
	output.meta = data.meta // not present in BE yet
	output.id = data.id
	} else {
	output.mimetype = data.mimetype
	// output.meta = ??? missing
	}

	output.url = data.url
	output.large_thumb_url = data.preview_url
	output.description = data.description

	return output
	}

	export const parseStatus = (data) => {
	const output = {}
	const masto = Object.prototype.hasOwnProperty.call(data, 'account')

	if (masto) {
	output.favorited = data.favourited
	output.fave_num = data.favourites_count

	output.repeated = data.reblogged
	output.repeat_num = data.reblogs_count

	output.bookmarked = data.bookmarked

	output.type = data.reblog ? 'retweet' : 'status'
	output.nsfw = data.sensitive

	output.raw_html = data.content
	output.emojis = data.emojis

	output.tags = data.tags

	if (data.pleroma) {
	const { pleroma } = data
	output.text = pleroma.content ? data.pleroma.content['text/plain'] : data.content
	output.summary = pleroma.spoiler_text ? data.pleroma.spoiler_text['text/plain'] : data.spoiler_text
	output.statusnet_conversation_id = data.pleroma.conversation_id
	output.is_local = pleroma.local
	output.in_reply_to_screen_name = data.pleroma.in_reply_to_account_acct
	output.thread_muted = pleroma.thread_muted
	output.emoji_reactions = pleroma.emoji_reactions
	output.parent_visible = pleroma.parent_visible === undefined ? true : pleroma.parent_visible
	} else {
	output.text = data.content
	output.summary = data.spoiler_text
	}

	output.in_reply_to_status_id = data.in_reply_to_id
	output.in_reply_to_user_id = data.in_reply_to_account_id
	output.replies_count = data.replies_count

	if (output.type === 'retweet') {
	output.retweeted_status = parseStatus(data.reblog)
	}

	output.summary_raw_html = escape(data.spoiler_text)
	output.external_url = data.url
	output.poll = data.poll
	if (output.poll) {
	output.poll.options = (output.poll.options \|\| []).map(field => ({
	...field,
	title_html: escape(field.title)
	}))
	}
	output.pinned = data.pinned
	output.muted = data.muted
	} else {
	output.favorited = data.favorited
	output.fave_num = data.fave_num

	output.repeated = data.repeated
	output.repeat_num = data.repeat_num

	// catchall, temporary
	// Object.assign(output, data)

	output.type = qvitterStatusType(data)

	if (data.nsfw === undefined) {
	output.nsfw = isNsfw(data)
	if (data.retweeted_status) {
	output.nsfw = data.retweeted_status.nsfw
	}
	} else {
	output.nsfw = data.nsfw
	}

	output.raw_html = data.statusnet_html
	output.text = data.text

	output.in_reply_to_status_id = data.in_reply_to_status_id
	output.in_reply_to_user_id = data.in_reply_to_user_id
	output.in_reply_to_screen_name = data.in_reply_to_screen_name
	output.statusnet_conversation_id = data.statusnet_conversation_id

	if (output.type === 'retweet') {
	output.retweeted_status = parseStatus(data.retweeted_status)
	}

	output.summary = data.summary
	output.summary_html = data.summary_html
	output.external_url = data.external_url
	output.is_local = data.is_local
	}

	output.id = String(data.id)
	output.visibility = data.visibility
	output.card = data.card
	output.created_at = new Date(data.created_at)

	// Converting to string, the right way.
	output.in_reply_to_status_id = output.in_reply_to_status_id
	? String(output.in_reply_to_status_id)
	: null
	output.in_reply_to_user_id = output.in_reply_to_user_id
	? String(output.in_reply_to_user_id)
	: null

	output.user = parseUser(masto ? data.account : data.user)

	output.attentions = ((masto ? data.mentions : data.attentions) \|\| []).map(parseUser)

	output.attachments = ((masto ? data.media_attachments : data.attachments) \|\| [])
	.map(parseAttachment)

	const retweetedStatus = masto ? data.reblog : data.retweeted_status
	if (retweetedStatus) {
	output.retweeted_status = parseStatus(retweetedStatus)
	}

	output.favoritedBy = []
	output.rebloggedBy = []

	return output
	}

	export const parseNotification = (data) => {
	const mastoDict = {
	favourite: 'like',
	reblog: 'repeat'
	}
	const masto = !Object.prototype.hasOwnProperty.call(data, 'ntype')
	const output = {}

	if (masto) {
	output.type = mastoDict[data.type] \|\| data.type
	output.seen = data.pleroma.is_seen
	output.status = isStatusNotification(output.type) ? parseStatus(data.status) : null
	output.action = output.status // TODO: Refactor, this is unneeded
	output.target = output.type !== 'move'
	? null
	: parseUser(data.target)
	output.from_profile = parseUser(data.account)
	output.emoji = data.emoji
	} else {
	const parsedNotice = parseStatus(data.notice)
	output.type = data.ntype
	output.seen = Boolean(data.is_seen)
	output.status = output.type === 'like'
	? parseStatus(data.notice.favorited_status)
	: parsedNotice
	output.action = parsedNotice
	output.from_profile = output.type === 'pleroma:chat_mention' ? parseUser(data.account) : parseUser(data.from_profile)
	}

	output.created_at = new Date(data.created_at)
	output.id = parseInt(data.id)

	return output
	}

	const isNsfw = (status) => {
	const nsfwRegex = /#nsfw/i
	return (status.tags \|\| []).includes('nsfw') \|\| !!(status.text \|\| '').match(nsfwRegex)
	}

	export const parseLinkHeaderPagination = (linkHeader, opts = {}) => {
	const flakeId = opts.flakeId
	const parsedLinkHeader = parseLinkHeader(linkHeader)
	if (!parsedLinkHeader) return
	const maxId = parsedLinkHeader.next.max_id
	const minId = parsedLinkHeader.prev.min_id

	return {
	maxId: flakeId ? maxId : parseInt(maxId, 10),
	minId: flakeId ? minId : parseInt(minId, 10)
	}
	}

	export const parseChat = (chat) => {
	const output = {}
	output.id = chat.id
	output.account = parseUser(chat.account)
	output.unread = chat.unread
	output.lastMessage = parseChatMessage(chat.last_message)
	output.updated_at = new Date(chat.updated_at)
	return output
	}

	export const parseChatMessage = (message) => {
	if (!message) { return }
	if (message.isNormalized) { return message }
	const output = message
	output.id = message.id
	output.created_at = new Date(message.created_at)
	output.chat_id = message.chat_id
	output.emojis = message.emojis
	output.content = message.content
	if (message.attachment) {
	output.attachments = [parseAttachment(message.attachment)]
	} else {
	output.attachments = []
	}
	output.pending = !!message.pending
	output.error = false
	output.idempotency_key = message.idempotency_key
	output.isNormalized = true
	return output
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 29, 8:54 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1736250
Default Alt Text: (55 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions