No OneTemporary
Actions

Authored By

Unknown

Size

54 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/modules/statuses.js b/src/modules/statuses.js
	index fde019b780..2ece12baad 100644
	--- a/src/modules/statuses.js
	+++ b/src/modules/statuses.js
	@@ -1,424 +1,427 @@
	import { remove, slice, sortBy, toInteger, each, find, flatten, maxBy, minBy, merge, last, isArray } from 'lodash'
	import apiService from '../services/api/api.service.js'
	// import parse from '../services/status_parser/status_parser.js'

	export const emptyTl = (tl, userId = 0) => (Object.assign(tl, {
	statuses: [],
	statusesObject: {},
	faves: [],
	visibleStatuses: [],
	visibleStatusesObject: {},
	newStatusCount: 0,
	maxId: 0,
	minVisibleId: 0,
	loading: false,
	followers: [],
	friends: [],
	flushMarker: 0,
	userId
	}))

	export const defaultState = {
	allStatuses: [],
	allStatusesObject: {},
	maxId: 0,
	notifications: {
	desktopNotificationSilence: true,
	maxId: 0,
	minId: Number.POSITIVE_INFINITY,
	data: [],
	idStore: {},
	error: false
	},
	favorites: new Set(),
	error: false,
	timelines: {
	mentions: emptyTl({ type: 'mentions' }),
	public: emptyTl({ type: 'public' }),
	user: emptyTl({ type: 'user' }), // TODO: switch to unregistered
	publicAndExternal: emptyTl({ type: 'publicAndExternal' }),
	friends: emptyTl({ type: 'friends' }),
	tag: emptyTl({ type: 'tag' }),
	dms: emptyTl({ type: 'dms' })
	}
	}

	export const prepareStatus = (status) => {
	// Set deleted flag
	status.deleted = false

	// To make the array reactive
	status.attachments = status.attachments \|\| []

	return status
	}

	const visibleNotificationTypes = (rootState) => {
	return [
	rootState.config.notificationVisibility.likes && 'like',
	rootState.config.notificationVisibility.mentions && 'mention',
	rootState.config.notificationVisibility.repeats && 'repeat',
	rootState.config.notificationVisibility.follows && 'follow'
	].filter(_ => _)
	}

	export const findMaxId = (...args) => {
	return (maxBy(flatten(args), 'id') \|\| {}).id
	}

	const mergeOrAdd = (arr, obj, item) => {
	const oldItem = obj[item.id]

	if (oldItem) {
	// We already have this, so only merge the new info.
	merge(oldItem, item)
	// Reactivity fix.
	oldItem.attachments.splice(oldItem.attachments.length)
	return {item: oldItem, new: false}
	} else {
	// This is a new item, prepare it
	prepareStatus(item)
	arr.push(item)
	obj[item.id] = item
	return {item, new: true}
	}
	}

	const sortTimeline = (timeline) => {
	timeline.visibleStatuses = sortBy(timeline.visibleStatuses, ({id}) => -id)
	timeline.statuses = sortBy(timeline.statuses, ({id}) => -id)
	timeline.minVisibleId = (last(timeline.visibleStatuses) \|\| {}).id
	return timeline
	}

	const addNewStatuses = (state, { statuses, showImmediately = false, timeline, user = {}, noIdUpdate = false, userId }) => {
	// Sanity check
	if (!isArray(statuses)) {
	return false
	}

	const allStatuses = state.allStatuses
	const allStatusesObject = state.allStatusesObject
	const timelineObject = typeof timeline === 'object' ? timeline : state.timelines[timeline]

	const maxNew = statuses.length > 0 ? maxBy(statuses, 'id').id : 0
	const older = timeline && maxNew < timelineObject.maxId

	if (timeline && !noIdUpdate && statuses.length > 0 && !older) {
	timelineObject.maxId = maxNew
	}

	// This makes sure that user timeline won't get data meant for other
	// user. I.e. opening different user profiles makes request which could
	// return data late after user already viewing different user profile
	if (timeline === 'user' && timelineObject.userId !== userId) {
	return
	}

	const addStatus = (data, showImmediately, addToTimeline = true) => {
	const result = mergeOrAdd(allStatuses, allStatusesObject, data)
	const status = result.item

	if (result.new) {
	// We are mentioned in a post
	if (status.type === 'status' && find(status.attentions, { id: user.id })) {
	const mentions = state.timelines.mentions

	// Add the mention to the mentions timeline
	if (timelineObject !== mentions) {
	mergeOrAdd(mentions.statuses, mentions.statusesObject, status)
	mentions.newStatusCount += 1

	sortTimeline(mentions)
	}
	}
	if (status.visibility === 'direct') {
	const dms = state.timelines.dms

	mergeOrAdd(dms.statuses, dms.statusesObject, status)
	dms.newStatusCount += 1

	sortTimeline(dms)
	}
	}

	// Decide if we should treat the status as new for this timeline.
	let resultForCurrentTimeline
	// Some statuses should only be added to the global status repository.
	if (timeline && addToTimeline) {
	resultForCurrentTimeline = mergeOrAdd(timelineObject.statuses, timelineObject.statusesObject, status)
	}

	if (timeline && showImmediately) {
	// Add it directly to the visibleStatuses, don't change
	// newStatusCount
	mergeOrAdd(timelineObject.visibleStatuses, timelineObject.visibleStatusesObject, status)
	} else if (timeline && addToTimeline && resultForCurrentTimeline.new) {
	// Just change newStatuscount
	timelineObject.newStatusCount += 1
	}

	return status
	}

	const favoriteStatus = (favorite, counter) => {
	const status = find(allStatuses, { id: toInteger(favorite.in_reply_to_status_id) })
	if (status) {
	// This is our favorite, so the relevant bit.
	if (favorite.user.id === user.id) {
	status.favorited = true
	} else {
	status.fave_num += 1
	}
	}
	return status
	}

	const processors = {
	'status': (status) => {
	addStatus(status, showImmediately)
	},
	'retweet': (status) => {
	// RetweetedStatuses are never shown immediately
	const retweetedStatus = addStatus(status.retweeted_status, false, false)

	let retweet
	// If the retweeted status is already there, don't add the retweet
	// to the timeline.
	if (timeline && find(timelineObject.statuses, (s) => {
	if (s.retweeted_status) {
	return s.id === retweetedStatus.id \|\| s.retweeted_status.id === retweetedStatus.id
	} else {
	return s.id === retweetedStatus.id
	}
	})) {
	// Already have it visible (either as the original or another RT), don't add to timeline, don't show.
	retweet = addStatus(status, false, false)
	} else {
	retweet = addStatus(status, showImmediately)
	}

	retweet.retweeted_status = retweetedStatus
	},
	'favorite': (favorite) => {
	// Only update if this is a new favorite.
	// Ignore our own favorites because we get info about likes as response to like request
	if (!state.favorites.has(favorite.id)) {
	state.favorites.add(favorite.id)
	favoriteStatus(favorite)
	}
	},
	'deletion': (deletion) => {
	const uri = deletion.uri

	// Remove possible notification
	const status = find(allStatuses, {uri})
	if (!status) {
	return
	}

	remove(state.notifications.data, ({action: {id}}) => id === status.id)

	remove(allStatuses, { uri })
	if (timeline) {
	remove(timelineObject.statuses, { uri })
	remove(timelineObject.visibleStatuses, { uri })
	}
	},
	+ 'follow': (follow) => {
	+ // NOOP, it is known status but we don't do anything about it for now
	+ },
	'default': (unknown) => {
	console.log('unknown status type')
	console.log(unknown)
	}
	}

	each(statuses, (status) => {
	const type = status.type
	const processor = processors[type] \|\| processors['default']
	processor(status)
	})

	// Keep the visible statuses sorted
	if (timeline) {
	sortTimeline(timelineObject)
	if ((older \|\| timelineObject.minVisibleId <= 0) && statuses.length > 0) {
	timelineObject.minVisibleId = minBy(statuses, 'id').id
	}
	}
	}

	const addNewNotifications = (state, { dispatch, notifications, older, visibleNotificationTypes }) => {
	const allStatuses = state.allStatuses
	const allStatusesObject = state.allStatusesObject
	each(notifications, (notification) => {
	notification.action = mergeOrAdd(allStatuses, allStatusesObject, notification.action).item
	notification.status = notification.status && mergeOrAdd(allStatuses, allStatusesObject, notification.status).item

	// Only add a new notification if we don't have one for the same action
	if (!state.notifications.idStore.hasOwnProperty(notification.id)) {
	state.notifications.maxId = Math.max(notification.id, state.notifications.maxId)
	state.notifications.minId = Math.min(notification.id, state.notifications.minId)

	state.notifications.data.push(notification)
	state.notifications.idStore[notification.id] = notification

	if ('Notification' in window && window.Notification.permission === 'granted') {
	const notifObj = {}
	const action = notification.action
	const title = action.user.name
	notifObj.icon = action.user.profile_image_url
	notifObj.body = action.text // there's a problem that it doesn't put a space before links tho

	// Shows first attached non-nsfw image, if any. Should add configuration for this somehow...
	if (action.attachments && action.attachments.length > 0 && !action.nsfw &&
	action.attachments[0].mimetype.startsWith('image/')) {
	notifObj.image = action.attachments[0].url
	}

	if (notification.fresh && !state.notifications.desktopNotificationSilence && visibleNotificationTypes.includes(notification.ntype)) {
	let notification = new window.Notification(title, notifObj)
	// Chrome is known for not closing notifications automatically
	// according to MDN, anyway.
	setTimeout(notification.close.bind(notification), 5000)
	}
	}
	}
	})
	}

	export const mutations = {
	addNewStatuses,
	addNewNotifications,
	showNewStatuses (state, { timeline }) {
	const oldTimeline = (typeof timeline === 'object' ? timeline : state.timelines[timeline])

	oldTimeline.newStatusCount = 0
	oldTimeline.visibleStatuses = slice(oldTimeline.statuses, 0, 50)
	oldTimeline.minVisibleId = last(oldTimeline.visibleStatuses).id
	oldTimeline.visibleStatusesObject = {}
	each(oldTimeline.visibleStatuses, (status) => { oldTimeline.visibleStatusesObject[status.id] = status })
	},
	clearTimeline (state, { timeline }) {
	const timelineObject = typeof timeline === 'object' ? timeline : state.timelines[timeline]
	emptyTl(timelineObject, timeline.userId)
	},
	setFavorited (state, { status, value }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.favorited = value
	},
	setFavoritedConfirm (state, { status }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.favorited = status.favorited
	newStatus.fave_num = status.fave_num
	},
	setRetweeted (state, { status, value }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.repeated = value
	},
	setDeleted (state, { status }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.deleted = true
	},
	setLoading (state, { timeline, value }) {
	const timelineObject = typeof timeline === 'object' ? timeline : state.timelines[timeline]
	timelineObject.loading = value
	},
	setNsfw (state, { id, nsfw }) {
	const newStatus = state.allStatusesObject[id]
	newStatus.nsfw = nsfw
	},
	setError (state, { value }) {
	state.error = value
	},
	setNotificationsError (state, { value }) {
	state.notifications.error = value
	},
	setNotificationsSilence (state, { value }) {
	state.notifications.desktopNotificationSilence = value
	},
	markNotificationsAsSeen (state) {
	each(state.notifications.data, (notification) => {
	notification.seen = true
	})
	},
	queueFlush (state, { timeline, id }) {
	const timelineObject = typeof timeline === 'object' ? timeline : state.timelines[timeline]
	timelineObject.flushMarker = id
	}
	}

	const statuses = {
	state: defaultState,
	actions: {
	addNewStatuses ({ rootState, commit }, { statuses, showImmediately = false, timeline = false, noIdUpdate = false, userId }) {
	commit('addNewStatuses', { statuses, showImmediately, timeline, noIdUpdate, user: rootState.users.currentUser, userId })
	},
	addNewNotifications ({ rootState, commit, dispatch }, { notifications, older }) {
	commit('addNewNotifications', { visibleNotificationTypes: visibleNotificationTypes(rootState), dispatch, notifications, older })
	},
	setError ({ rootState, commit }, { value }) {
	commit('setError', { value })
	},
	setNotificationsError ({ rootState, commit }, { value }) {
	commit('setNotificationsError', { value })
	},
	setNotificationsSilence ({ rootState, commit }, { value }) {
	commit('setNotificationsSilence', { value })
	},
	deleteStatus ({ rootState, commit }, status) {
	commit('setDeleted', { status })
	apiService.deleteStatus({ id: status.id, credentials: rootState.users.currentUser.credentials })
	},
	favorite ({ rootState, commit }, status) {
	// Optimistic favoriting...
	commit('setFavorited', { status, value: true })
	apiService.favorite({ id: status.id, credentials: rootState.users.currentUser.credentials })
	.then(response => {
	if (response.ok) {
	return response.json()
	} else {
	return {}
	}
	})
	.then(status => {
	commit('setFavoritedConfirm', { status })
	})
	},
	unfavorite ({ rootState, commit }, status) {
	// Optimistic favoriting...
	commit('setFavorited', { status, value: false })
	apiService.unfavorite({ id: status.id, credentials: rootState.users.currentUser.credentials })
	.then(response => {
	if (response.ok) {
	return response.json()
	} else {
	return {}
	}
	})
	.then(status => {
	commit('setFavoritedConfirm', { status })
	})
	},
	retweet ({ rootState, commit }, status) {
	// Optimistic retweeting...
	commit('setRetweeted', { status, value: true })
	apiService.retweet({ id: status.id, credentials: rootState.users.currentUser.credentials })
	},
	unretweet ({ rootState, commit }, status) {
	commit('setRetweeted', { status, value: false })
	apiService.unretweet({ id: status.id, credentials: rootState.users.currentUser.credentials })
	},
	queueFlush ({ rootState, commit }, { timeline, id }) {
	commit('queueFlush', { timeline, id })
	},
	markNotificationsAsSeen ({ rootState, commit }) {
	commit('markNotificationsAsSeen')
	apiService.markNotificationsAsSeen({
	id: rootState.statuses.notifications.maxId,
	credentials: rootState.users.currentUser.credentials
	})
	}
	},
	mutations
	}

	export default statuses
	diff --git a/src/services/api/api.service.js b/src/services/api/api.service.js
	index e82f4f81f3..14a526ef10 100644
	--- a/src/services/api/api.service.js
	+++ b/src/services/api/api.service.js
	@@ -1,542 +1,542 @@
	/* eslint-env browser */
	const LOGIN_URL = '/api/account/verify_credentials.json'
	const FRIENDS_TIMELINE_URL = '/api/statuses/friends_timeline.json'
	const ALL_FOLLOWING_URL = '/api/qvitter/allfollowing'
	const PUBLIC_TIMELINE_URL = '/api/statuses/public_timeline.json'
	const PUBLIC_AND_EXTERNAL_TIMELINE_URL = '/api/statuses/public_and_external_timeline.json'
	const TAG_TIMELINE_URL = '/api/statusnet/tags/timeline'
	const FAVORITE_URL = '/api/favorites/create'
	const UNFAVORITE_URL = '/api/favorites/destroy'
	const RETWEET_URL = '/api/statuses/retweet'
	const UNRETWEET_URL = '/api/statuses/unretweet'
	const STATUS_UPDATE_URL = '/api/statuses/update.json'
	const STATUS_DELETE_URL = '/api/statuses/destroy'
	const STATUS_URL = '/api/statuses/show'
	const MEDIA_UPLOAD_URL = '/api/statusnet/media/upload'
	const CONVERSATION_URL = '/api/statusnet/conversation'
	const MENTIONS_URL = '/api/statuses/mentions.json'
	const DM_TIMELINE_URL = '/api/statuses/dm_timeline.json'
	const FOLLOWERS_URL = '/api/statuses/followers.json'
	const FRIENDS_URL = '/api/statuses/friends.json'
	const FOLLOWING_URL = '/api/friendships/create.json'
	const UNFOLLOWING_URL = '/api/friendships/destroy.json'
	const QVITTER_USER_PREF_URL = '/api/qvitter/set_profile_pref.json'
	const REGISTRATION_URL = '/api/account/register.json'
	const AVATAR_UPDATE_URL = '/api/qvitter/update_avatar.json'
	const BG_UPDATE_URL = '/api/qvitter/update_background_image.json'
	const BANNER_UPDATE_URL = '/api/account/update_profile_banner.json'
	const PROFILE_UPDATE_URL = '/api/account/update_profile.json'
	const EXTERNAL_PROFILE_URL = '/api/externalprofile/show.json'
	const QVITTER_USER_TIMELINE_URL = '/api/qvitter/statuses/user_timeline.json'
	const QVITTER_USER_NOTIFICATIONS_URL = '/api/qvitter/statuses/notifications.json'
	const QVITTER_USER_NOTIFICATIONS_READ_URL = '/api/qvitter/statuses/notifications/read.json'
	const BLOCKING_URL = '/api/blocks/create.json'
	const UNBLOCKING_URL = '/api/blocks/destroy.json'
	const USER_URL = '/api/users/show.json'
	const FOLLOW_IMPORT_URL = '/api/pleroma/follow_import'
	const DELETE_ACCOUNT_URL = '/api/pleroma/delete_account'
	const CHANGE_PASSWORD_URL = '/api/pleroma/change_password'
	const FOLLOW_REQUESTS_URL = '/api/pleroma/friend_requests'
	const APPROVE_USER_URL = '/api/pleroma/friendships/approve'
	const DENY_USER_URL = '/api/pleroma/friendships/deny'
	const SUGGESTIONS_URL = '/api/v1/suggestions'

	const MASTODON_USER_FAVORITES_TIMELINE_URL = '/api/v1/favourites'

	import { each, map } from 'lodash'
	-import { parseStatus, parseUser, parseNotification } from '../status_normalizer/status_normalizer.service.js'
	+import { parseStatus, parseUser, parseNotification } from '../entity_normalizer/entity_normalizer.service.js'
	import 'whatwg-fetch'

	const oldfetch = window.fetch

	let fetch = (url, options) => {
	options = options \|\| {}
	const baseUrl = ''
	const fullUrl = baseUrl + url
	options.credentials = 'same-origin'
	return oldfetch(fullUrl, options)
	}

	// Params
	// cropH
	// cropW
	// cropX
	// cropY
	// img (base 64 encodend data url)
	const updateAvatar = ({credentials, params}) => {
	let url = AVATAR_UPDATE_URL

	const form = new FormData()

	each(params, (value, key) => {
	if (value) {
	form.append(key, value)
	}
	})

	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST',
	body: form
	}).then((data) => data.json())
	}

	const updateBg = ({credentials, params}) => {
	let url = BG_UPDATE_URL

	const form = new FormData()

	each(params, (value, key) => {
	if (value) {
	form.append(key, value)
	}
	})

	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST',
	body: form
	}).then((data) => data.json())
	}

	// Params
	// height
	// width
	// offset_left
	// offset_top
	// banner (base 64 encodend data url)
	const updateBanner = ({credentials, params}) => {
	let url = BANNER_UPDATE_URL

	const form = new FormData()

	each(params, (value, key) => {
	if (value) {
	form.append(key, value)
	}
	})

	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST',
	body: form
	}).then((data) => data.json())
	}

	// Params
	// name
	// url
	// location
	// description
	const updateProfile = ({credentials, params}) => {
	let url = PROFILE_UPDATE_URL

	const form = new FormData()

	each(params, (value, key) => {
	/* Always include description, no_rich_text and locked, because it might be empty or false */
	if (key === 'description' \|\| key === 'locked' \|\| key === 'no_rich_text' \|\| value) {
	form.append(key, value)
	}
	})
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST',
	body: form
	}).then((data) => data.json())
	}

	// Params needed:
	// nickname
	// email
	// fullname
	// password
	// password_confirm
	//
	// Optional
	// bio
	// homepage
	// location
	// token
	const register = (params) => {
	const form = new FormData()

	each(params, (value, key) => {
	if (value) {
	form.append(key, value)
	}
	})

	return fetch(REGISTRATION_URL, {
	method: 'POST',
	body: form
	})
	}

	const getCaptcha = () => fetch('/api/pleroma/captcha').then(resp => resp.json())

	const authHeaders = (accessToken) => {
	if (accessToken) {
	return { 'Authorization': `Bearer ${accessToken}` }
	} else {
	return { }
	}
	}

	const externalProfile = ({profileUrl, credentials}) => {
	let url = `${EXTERNAL_PROFILE_URL}?profileurl=${profileUrl}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'GET'
	}).then((data) => data.json())
	}

	const followUser = ({id, credentials}) => {
	let url = `${FOLLOWING_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const unfollowUser = ({id, credentials}) => {
	let url = `${UNFOLLOWING_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const blockUser = ({id, credentials}) => {
	let url = `${BLOCKING_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const unblockUser = ({id, credentials}) => {
	let url = `${UNBLOCKING_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const approveUser = ({id, credentials}) => {
	let url = `${APPROVE_USER_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const denyUser = ({id, credentials}) => {
	let url = `${DENY_USER_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const fetchUser = ({id, credentials}) => {
	let url = `${USER_URL}?user_id=${id}`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => parseUser(data))
	}

	const fetchFriends = ({id, credentials}) => {
	let url = `${FRIENDS_URL}?user_id=${id}`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const fetchFollowers = ({id, credentials}) => {
	let url = `${FOLLOWERS_URL}?user_id=${id}`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const fetchAllFollowing = ({username, credentials}) => {
	const url = `${ALL_FOLLOWING_URL}/${username}.json`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const fetchFollowRequests = ({credentials}) => {
	const url = FOLLOW_REQUESTS_URL
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	}

	const fetchConversation = ({id, credentials}) => {
	let url = `${CONVERSATION_URL}/${id}.json?count=100`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching timeline')
	})
	.then((data) => data.map(parseStatus))
	}

	const fetchStatus = ({id, credentials}) => {
	let url = `${STATUS_URL}/${id}.json`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching timeline')
	})
	.then((data) => parseStatus(data))
	}

	const setUserMute = ({id, credentials, muted = true}) => {
	const form = new FormData()

	const muteInteger = muted ? 1 : 0

	form.append('namespace', 'qvitter')
	form.append('data', muteInteger)
	form.append('topic', `mute:${id}`)

	return fetch(QVITTER_USER_PREF_URL, {
	method: 'POST',
	headers: authHeaders(credentials),
	body: form
	})
	}

	const fetchTimeline = ({timeline, credentials, since = false, until = false, userId = false, tag = false}) => {
	const timelineUrls = {
	public: PUBLIC_TIMELINE_URL,
	friends: FRIENDS_TIMELINE_URL,
	mentions: MENTIONS_URL,
	dms: DM_TIMELINE_URL,
	notifications: QVITTER_USER_NOTIFICATIONS_URL,
	'publicAndExternal': PUBLIC_AND_EXTERNAL_TIMELINE_URL,
	user: QVITTER_USER_TIMELINE_URL,
	favorites: MASTODON_USER_FAVORITES_TIMELINE_URL,
	tag: TAG_TIMELINE_URL
	}
	const type = timeline.type \|\| timeline
	const isNotifications = type === 'notifications'
	const params = []

	let url = timelineUrls[type]

	if (since) {
	params.push(['since_id', since])
	}
	if (until) {
	params.push(['max_id', until])
	}
	if (userId) {
	params.push(['user_id', userId])
	}
	if (tag) {
	url += `/${tag}.json`
	}

	params.push(['count', 20])

	const queryString = map(params, (param) => `${param[0]}=${param[1]}`).join('&')
	url += `?${queryString}`

	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching timeline')
	})
	.then((data) => data.json())
	.then((data) => data.map(isNotifications ? parseNotification : parseStatus))
	}

	const verifyCredentials = (user) => {
	return fetch(LOGIN_URL, {
	method: 'POST',
	headers: authHeaders(user)
	})
	}

	const favorite = ({ id, credentials }) => {
	return fetch(`${FAVORITE_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const unfavorite = ({ id, credentials }) => {
	return fetch(`${UNFAVORITE_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const retweet = ({ id, credentials }) => {
	return fetch(`${RETWEET_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const unretweet = ({ id, credentials }) => {
	return fetch(`${UNRETWEET_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const postStatus = ({credentials, status, spoilerText, visibility, sensitive, mediaIds, inReplyToStatusId, contentType, noAttachmentLinks}) => {
	const idsText = mediaIds.join(',')
	const form = new FormData()

	form.append('status', status)
	form.append('source', 'Pleroma FE')
	if (noAttachmentLinks) form.append('no_attachment_links', noAttachmentLinks)
	if (spoilerText) form.append('spoiler_text', spoilerText)
	if (visibility) form.append('visibility', visibility)
	if (sensitive) form.append('sensitive', sensitive)
	if (contentType) form.append('content_type', contentType)
	form.append('media_ids', idsText)
	if (inReplyToStatusId) {
	form.append('in_reply_to_status_id', inReplyToStatusId)
	}

	return fetch(STATUS_UPDATE_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	}

	const deleteStatus = ({ id, credentials }) => {
	return fetch(`${STATUS_DELETE_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const uploadMedia = ({formData, credentials}) => {
	return fetch(MEDIA_UPLOAD_URL, {
	body: formData,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.text())
	.then((text) => (new DOMParser()).parseFromString(text, 'application/xml'))
	}

	const followImport = ({params, credentials}) => {
	return fetch(FOLLOW_IMPORT_URL, {
	body: params,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.ok)
	}

	const deleteAccount = ({credentials, password}) => {
	const form = new FormData()

	form.append('password', password)

	return fetch(DELETE_ACCOUNT_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.json())
	}

	const changePassword = ({credentials, password, newPassword, newPasswordConfirmation}) => {
	const form = new FormData()

	form.append('password', password)
	form.append('new_password', newPassword)
	form.append('new_password_confirmation', newPasswordConfirmation)

	return fetch(CHANGE_PASSWORD_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.json())
	}

	const fetchMutes = ({credentials}) => {
	const url = '/api/qvitter/mutes.json'

	return fetch(url, {
	headers: authHeaders(credentials)
	}).then((data) => data.json())
	}

	const suggestions = ({credentials}) => {
	return fetch(SUGGESTIONS_URL, {
	headers: authHeaders(credentials)
	}).then((data) => data.json())
	}

	const markNotificationsAsSeen = ({id, credentials}) => {
	const body = new FormData()

	body.append('latest_id', id)

	return fetch(QVITTER_USER_NOTIFICATIONS_READ_URL, {
	body,
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const apiService = {
	verifyCredentials,
	fetchTimeline,
	fetchConversation,
	fetchStatus,
	fetchFriends,
	fetchFollowers,
	followUser,
	unfollowUser,
	blockUser,
	unblockUser,
	fetchUser,
	favorite,
	unfavorite,
	retweet,
	unretweet,
	postStatus,
	deleteStatus,
	uploadMedia,
	fetchAllFollowing,
	setUserMute,
	fetchMutes,
	register,
	getCaptcha,
	updateAvatar,
	updateBg,
	updateProfile,
	updateBanner,
	externalProfile,
	followImport,
	deleteAccount,
	changePassword,
	fetchFollowRequests,
	approveUser,
	denyUser,
	suggestions,
	markNotificationsAsSeen
	}

	export default apiService
	diff --git a/src/services/status_normalizer/status_normalizer.service.js b/src/services/entity_normalizer/entity_normalizer.service.js
	similarity index 99%
	rename from src/services/status_normalizer/status_normalizer.service.js
	rename to src/services/entity_normalizer/entity_normalizer.service.js
	index 784c7f20ca..adc7f04751 100644
	--- a/src/services/status_normalizer/status_normalizer.service.js
	+++ b/src/services/entity_normalizer/entity_normalizer.service.js
	@@ -1,209 +1,212 @@
	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 = data.hasOwnProperty('acct')
	// case for users in "mentions" property for statuses in MastoAPI
	const mastoShort = masto && !data.hasOwnProperty('avatar')

	output.id = data.id

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

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

	output.name = null // missing
	output.name_html = data.display_name

	output.description = null // missing
	output.description_html = data.note

	// 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

	output.statusnet_profile_url = data.url

	// Missing, trying to recover
	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 = null // missing

	output.statusnet_profile_url = data.statusnet_profile_url
	output.is_local = data.is_local
	}

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

	return output
	}

	const parseAttachment = (data) => {
	// TODO A little bit messy ATM but works with both APIs
	return {
	...data,
	mimetype: data.mimetype \|\| data.type
	}
	}

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

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

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

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

	output.statusnet_html = data.content

	// Not exactly the same but works?
	output.text = data.content

	output.in_reply_to_status_id = data.in_reply_to_id
	output.in_reply_to_user_id = data.in_reply_to_user_id

	// Not exactly the same but works
	output.statusnet_conversation_id = data.id
	} 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.statusnet_html = data.statusnet_html
	output.text = data.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.statusnet_conversation_id = data.statusnet_conversation_id
	}

	output.id = Number(data.id)
	output.visibility = data.visibility
	output.created_at = new Date(data.created_at)

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

	output.attentions = ((masto ? data.mentions : data.attentions) \|\| [])
	.map(_ => ({
	id: _.id,
	following: _.following // FIXME: MastoAPI doesn't have this
	}))

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

	return output
	}

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

	if (masto) {
	output.type = mastoDict[data.type] \|\| data.type
	output.seen = null // missing
	output.status = parseStatus(data.status)
	output.action = null // missing
	output.from_profile = parseUser(data.account)
	} else {
	const parsedNotice = parseStatus(data.notice)
	output.type = data.ntype
	output.seen = data.is_seen
	output.status = output.type === 'like'
	? parseStatus(data.notice.favorited_status)
	: parsedNotice
	output.action = parsedNotice
	output.from_profile = parseUser(data.from_profile)
	}

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

	return output
	}

	const isNsfw = (status) => {
	const nsfwRegex = /#nsfw/i
	return (status.tags \|\| []).includes('nsfw') \|\| !!status.text.match(nsfwRegex)
	}
	diff --git a/test/unit/specs/modules/statuses.spec.js b/test/unit/specs/modules/statuses.spec.js
	index 7d403312a1..0b511b8047 100644
	--- a/test/unit/specs/modules/statuses.spec.js
	+++ b/test/unit/specs/modules/statuses.spec.js
	@@ -1,339 +1,313 @@
	import { cloneDeep } from 'lodash'
	-import { defaultState, mutations, findMaxId, prepareStatus, statusType } from '../../../../src/modules/statuses.js'
	+import { defaultState, mutations, findMaxId, prepareStatus } from '../../../../src/modules/statuses.js'

	// eslint-disable-next-line camelcase
	-const makeMockStatus = ({id, text, is_post_verb = true}) => {
	+const makeMockStatus = ({id, text, type = 'status'}) => {
	return {
	id,
	user: {id: 0},
	name: 'status',
	text: text \|\| `Text number ${id}`,
	fave_num: 0,
	uri: '',
	- is_post_verb,
	+ type,
	attentions: []
	}
	}

	-describe('Statuses.statusType', () => {
	- it('identifies favorites', () => {
	- const fav = {
	- uri: 'tag:soykaf.com,2016-08-21:fave:2558:note:339495:2016-08-21T16:54:04+00:00'
	- }
	-
	- const mastoFav = {
	- uri: 'tag:mastodon.social,2016-11-27:objectId=73903:objectType=Favourite'
	- }
	-
	- expect(statusType(fav)).to.eql('favorite')
	- expect(statusType(mastoFav)).to.eql('favorite')
	- })
	-})
	-
	describe('Statuses.prepareStatus', () => {
	- it('sets nsfw for statuses with the #nsfw tag', () => {
	- const safe = makeMockStatus({id: 1, text: 'Hello oniichan'})
	- const nsfw = makeMockStatus({id: 1, text: 'Hello oniichan #nsfw'})
	-
	- expect(prepareStatus(safe).nsfw).to.eq(false)
	- expect(prepareStatus(nsfw).nsfw).to.eq(true)
	- })
	-
	- it('leaves existing nsfw settings alone', () => {
	- const nsfw = makeMockStatus({id: 1, text: 'Hello oniichan #nsfw'})
	- nsfw.nsfw = false
	-
	- expect(prepareStatus(nsfw).nsfw).to.eq(false)
	- })
	-
	it('sets deleted flag to false', () => {
	const aStatus = makeMockStatus({id: 1, text: 'Hello oniichan'})
	expect(prepareStatus(aStatus).deleted).to.eq(false)
	})
	})

	describe('Statuses.findMaxId', () => {
	it('returns the largest id in any of the given arrays', () => {
	const statusesOne = [{ id: 100 }, { id: 2 }]
	const statusesTwo = [{ id: 3 }]

	const maxId = findMaxId(statusesOne, statusesTwo)
	expect(maxId).to.eq(100)
	})

	it('returns undefined for empty arrays', () => {
	const maxId = findMaxId([], [])
	expect(maxId).to.eq(undefined)
	})
	})

	describe('The Statuses module', () => {
	it('adds the status to allStatuses and to the given timeline', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})

	mutations.addNewStatuses(state, { statuses: [status], timeline: 'public' })

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.public.statuses).to.eql([status])
	expect(state.timelines.public.visibleStatuses).to.eql([])
	expect(state.timelines.public.newStatusCount).to.equal(1)
	})

	it('counts the status as new if it has not been seen on this timeline', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})

	mutations.addNewStatuses(state, { statuses: [status], timeline: 'public' })
	mutations.addNewStatuses(state, { statuses: [status], timeline: 'friends' })

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.public.statuses).to.eql([status])
	expect(state.timelines.public.visibleStatuses).to.eql([])
	expect(state.timelines.public.newStatusCount).to.equal(1)

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.friends.statuses).to.eql([status])
	expect(state.timelines.friends.visibleStatuses).to.eql([])
	expect(state.timelines.friends.newStatusCount).to.equal(1)
	})

	it('add the statuses to allStatuses if no timeline is given', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})

	mutations.addNewStatuses(state, { statuses: [status] })

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.public.statuses).to.eql([])
	expect(state.timelines.public.visibleStatuses).to.eql([])
	expect(state.timelines.public.newStatusCount).to.equal(0)
	})

	it('adds the status to allStatuses and to the given timeline, directly visible', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})

	mutations.addNewStatuses(state, { statuses: [status], showImmediately: true, timeline: 'public' })

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.public.statuses).to.eql([status])
	expect(state.timelines.public.visibleStatuses).to.eql([status])
	expect(state.timelines.public.newStatusCount).to.equal(0)
	})

	it('removes statuses by tag on deletion', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})
	const otherStatus = makeMockStatus({id: 3})
	status.uri = 'xxx'
	- const deletion = makeMockStatus({id: 2, is_post_verb: false})
	+ const deletion = makeMockStatus({id: 2, type: 'deletion'})
	deletion.text = 'Dolus deleted notice {{tag:gs.smuglo.li,2016-11-18:noticeId=1038007:objectType=note}}.'
	deletion.uri = 'xxx'

	mutations.addNewStatuses(state, { statuses: [status, otherStatus], showImmediately: true, timeline: 'public' })
	mutations.addNewStatuses(state, { statuses: [deletion], showImmediately: true, timeline: 'public' })

	expect(state.allStatuses).to.eql([otherStatus])
	expect(state.timelines.public.statuses).to.eql([otherStatus])
	expect(state.timelines.public.visibleStatuses).to.eql([otherStatus])
	expect(state.timelines.public.maxId).to.eql(3)
	})

	it('does not update the maxId when the noIdUpdate flag is set', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})
	const secondStatus = makeMockStatus({id: 2})

	mutations.addNewStatuses(state, { statuses: [status], showImmediately: true, timeline: 'public' })
	expect(state.timelines.public.maxId).to.eql(1)

	mutations.addNewStatuses(state, { statuses: [secondStatus], showImmediately: true, timeline: 'public', noIdUpdate: true })
	expect(state.timelines.public.statuses).to.eql([secondStatus, status])
	expect(state.timelines.public.visibleStatuses).to.eql([secondStatus, status])
	expect(state.timelines.public.maxId).to.eql(1)
	})

	it('keeps a descending by id order in timeline.visibleStatuses and timeline.statuses', () => {
	const state = cloneDeep(defaultState)
	const nonVisibleStatus = makeMockStatus({id: 1})
	const status = makeMockStatus({id: 3})
	const statusTwo = makeMockStatus({id: 2})
	const statusThree = makeMockStatus({id: 4})

	mutations.addNewStatuses(state, { statuses: [nonVisibleStatus], showImmediately: false, timeline: 'public' })

	mutations.addNewStatuses(state, { statuses: [status], showImmediately: true, timeline: 'public' })
	mutations.addNewStatuses(state, { statuses: [statusTwo], showImmediately: true, timeline: 'public' })

	expect(state.timelines.public.minVisibleId).to.equal(2)

	mutations.addNewStatuses(state, { statuses: [statusThree], showImmediately: true, timeline: 'public' })

	expect(state.timelines.public.statuses).to.eql([statusThree, status, statusTwo, nonVisibleStatus])
	expect(state.timelines.public.visibleStatuses).to.eql([statusThree, status, statusTwo])
	})

	it('splits retweets from their status and links them', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})
	- const retweet = makeMockStatus({id: 2, is_post_verb: false})
	+ const retweet = makeMockStatus({id: 2, type: 'retweet'})
	const modStatus = makeMockStatus({id: 1, text: 'something else'})

	retweet.retweeted_status = status

	// It adds both statuses, but only the retweet to visible.
	mutations.addNewStatuses(state, { statuses: [retweet], timeline: 'public', showImmediately: true })
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	expect(state.timelines.public.statuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(2)
	expect(state.allStatuses[0].id).to.equal(1)
	expect(state.allStatuses[1].id).to.equal(2)

	// It refers to the modified status.
	mutations.addNewStatuses(state, { statuses: [modStatus], timeline: 'public' })
	expect(state.allStatuses).to.have.length(2)
	expect(state.allStatuses[0].id).to.equal(1)
	expect(state.allStatuses[0].text).to.equal(modStatus.text)
	expect(state.allStatuses[1].id).to.equal(2)
	expect(retweet.retweeted_status.text).to.eql(modStatus.text)
	})

	it('replaces existing statuses with the same id', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})
	const modStatus = makeMockStatus({id: 1, text: 'something else'})

	// Add original status
	mutations.addNewStatuses(state, { statuses: [status], showImmediately: true, timeline: 'public' })
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(1)

	// Add new version of status
	mutations.addNewStatuses(state, { statuses: [modStatus], showImmediately: true, timeline: 'public' })
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(1)
	expect(state.allStatuses[0].text).to.eql(modStatus.text)
	})

	it('replaces existing statuses with the same id, coming from a retweet', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})
	const modStatus = makeMockStatus({id: 1, text: 'something else'})
	- const retweet = makeMockStatus({id: 2, is_post_verb: false})
	+ const retweet = makeMockStatus({id: 2, type: 'retweet'})
	retweet.retweeted_status = modStatus

	// Add original status
	mutations.addNewStatuses(state, { statuses: [status], showImmediately: true, timeline: 'public' })
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(1)

	// Add new version of status
	mutations.addNewStatuses(state, { statuses: [retweet], showImmediately: false, timeline: 'public' })
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	// Don't add the retweet itself if the tweet is visible
	expect(state.timelines.public.statuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(2)
	expect(state.allStatuses[0].text).to.eql(modStatus.text)
	})

	it('handles favorite actions', () => {
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})

	const favorite = {
	id: 2,
	- is_post_verb: false,
	+ type: 'favorite',
	in_reply_to_status_id: '1', // The API uses strings here...
	uri: 'tag:shitposter.club,2016-08-21:fave:3895:note:773501:2016-08-21T16:52:15+00:00',
	text: 'a favorited something by b',
	user: { id: 99 }
	}

	mutations.addNewStatuses(state, { statuses: [status], showImmediately: true, timeline: 'public' })
	mutations.addNewStatuses(state, { statuses: [favorite], showImmediately: true, timeline: 'public' })

	expect(state.timelines.public.visibleStatuses.length).to.eql(1)
	expect(state.timelines.public.visibleStatuses[0].fave_num).to.eql(1)
	expect(state.timelines.public.maxId).to.eq(favorite.id)

	// Adding it again does nothing
	mutations.addNewStatuses(state, { statuses: [favorite], showImmediately: true, timeline: 'public' })

	expect(state.timelines.public.visibleStatuses.length).to.eql(1)
	expect(state.timelines.public.visibleStatuses[0].fave_num).to.eql(1)
	expect(state.timelines.public.maxId).to.eq(favorite.id)

	// If something is favorited by the current user, it also sets the 'favorited' property but does not increment counter to avoid over-counting. Counter is incremented (updated, really) via response to the favorite request.
	const user = {
	id: 1
	}

	const ownFavorite = {
	id: 3,
	- is_post_verb: false,
	+ type: 'favorite',
	in_reply_to_status_id: '1', // The API uses strings here...
	uri: 'tag:shitposter.club,2016-08-21:fave:3895:note:773501:2016-08-21T16:52:15+00:00',
	text: 'a favorited something by b',
	user
	}

	mutations.addNewStatuses(state, { statuses: [ownFavorite], showImmediately: true, timeline: 'public', user })

	expect(state.timelines.public.visibleStatuses.length).to.eql(1)
	expect(state.timelines.public.visibleStatuses[0].fave_num).to.eql(1)
	expect(state.timelines.public.visibleStatuses[0].favorited).to.eql(true)
	})

	describe('notifications', () => {
	it('removes a notification when the notice gets removed', () => {
	const user = { id: 1 }
	const state = cloneDeep(defaultState)
	const status = makeMockStatus({id: 1})
	const otherStatus = makeMockStatus({id: 3})
	const mentionedStatus = makeMockStatus({id: 2})
	mentionedStatus.attentions = [user]
	mentionedStatus.uri = 'xxx'
	otherStatus.attentions = [user]

	- const deletion = makeMockStatus({id: 4, is_post_verb: false})
	+ const deletion = makeMockStatus({id: 4, type: 'deletion'})
	deletion.text = 'Dolus deleted notice {{tag:gs.smuglo.li,2016-11-18:noticeId=1038007:objectType=note}}.'
	deletion.uri = 'xxx'

	mutations.addNewStatuses(state, { statuses: [status, otherStatus], user })
	mutations.addNewNotifications(
	state,
	{
	notifications: [{
	- ntype: 'mention',
	+ from_profile: { id: 2 },
	+ id: 998,
	+ type: 'mention',
	status: otherStatus,
	- notice: otherStatus,
	- is_seen: false
	+ action: otherStatus,
	+ seen: false
	}]
	})

	expect(state.notifications.data.length).to.eql(1)
	mutations.addNewNotifications(
	state,
	{
	notifications: [{
	- ntype: 'mention',
	+ from_profile: { id: 2 },
	+ id: 999,
	+ type: 'mention',
	status: mentionedStatus,
	- notice: mentionedStatus,
	- is_seen: false
	+ action: mentionedStatus,
	+ seen: false
	}]
	})

	mutations.addNewStatuses(state, { statuses: [mentionedStatus], user })
	expect(state.allStatuses.length).to.eql(3)
	expect(state.notifications.data.length).to.eql(2)
	expect(state.notifications.data[1].status).to.eql(mentionedStatus)
	expect(state.notifications.data[1].action).to.eql(mentionedStatus)
	expect(state.notifications.data[1].type).to.eql('mention')

	mutations.addNewStatuses(state, { statuses: [deletion], user })
	expect(state.allStatuses.length).to.eql(2)
	expect(state.notifications.data.length).to.eql(1)
	})
	})
	})
	diff --git a/test/unit/specs/services/entity_normalizer/entity_normalizer.spec.js b/test/unit/specs/services/entity_normalizer/entity_normalizer.spec.js
	new file mode 100644
	index 0000000000..e58827252c
	--- /dev/null
	+++ b/test/unit/specs/services/entity_normalizer/entity_normalizer.spec.js
	@@ -0,0 +1,102 @@
	+import { parseStatus, parseUser, parseNotification } from '../../../../../src/services/entity_normalizer/entity_normalizer.service.js'
	+
	+const makeMockStatusQvitter = (overrides = {}) => {
	+ return Object.assign({
	+ activity_type: 'post',
	+ attachments: [],
	+ attentions: [],
	+ created_at: 'Tue Jan 15 13:57:56 +0000 2019',
	+ external_url: 'https://ap.example/whatever',
	+ fave_num: 1,
	+ favorited: false,
	+ id: 10335970,
	+ in_reply_to_ostatus_uri: null,
	+ in_reply_to_profileurl: null,
	+ in_reply_to_screen_name: null,
	+ in_reply_to_status_id: null,
	+ in_reply_to_user_id: null,
	+ is_local: false,
	+ is_post_verb: true,
	+ possibly_sensitive: false,
	+ repeat_num: 0,
	+ repeated: false,
	+ statusnet_conversation_id: 16300488,
	+ statusnet_html: '<p>haha benis</p>',
	+ summary: null,
	+ tags: [],
	+ text: 'haha benis',
	+ uri: 'https://ap.example/whatever',
	+ user: makeMockUserQvitter(),
	+ visibility: 'public'
	+ }, overrides)
	+}
	+
	+const makeMockUserQvitter = (overrides = {}) => {
	+ return Object.assign({
	+ background_image: null,
	+ cover_photo: '',
	+ created_at: 'Mon Jan 14 13:56:51 +0000 2019',
	+ default_scope: 'public',
	+ description: 'ebin',
	+ description_html: '<p>ebin</p>',
	+ favourites_count: 0,
	+ fields: [],
	+ followers_count: 1,
	+ following: true,
	+ follows_you: true,
	+ friends_count: 1,
	+ id: 60717,
	+ is_local: false,
	+ locked: false,
	+ name: 'Spurdo :ebin:',
	+ name_html: 'Spurdo <img src="whatever">',
	+ no_rich_text: false,
	+ pleroma: { confirmation_pending: false, tags: [] },
	+ profile_image_url: 'https://ap.example/whatever',
	+ profile_image_url_https: 'https://ap.example/whatever',
	+ profile_image_url_original: 'https://ap.example/whatever',
	+ profile_image_url_profile_size: 'https://ap.example/whatever',
	+ rights: { delete_others_notice: false },
	+ screen_name: 'spurdo@ap.example',
	+ statuses_count: 46,
	+ statusnet_blocking: false,
	+ statusnet_profile_url: ''
	+ }, overrides)
	+}
	+
	+parseNotification
	+parseUser
	+parseStatus
	+makeMockStatusQvitter
	+makeMockUserQvitter
	+
	+describe('QVitter preprocessing', () => {
	+ it('identifies favorites', () => {
	+ const fav = {
	+ uri: 'tag:soykaf.com,2016-08-21:fave:2558:note:339495:2016-08-21T16:54:04+00:00',
	+ is_post_verb: false
	+ }
	+
	+ const mastoFav = {
	+ uri: 'tag:mastodon.social,2016-11-27:objectId=73903:objectType=Favourite',
	+ is_post_verb: false
	+ }
	+
	+ expect(parseStatus(makeMockStatusQvitter(fav))).to.have.property('type', 'favorite')
	+ expect(parseStatus(makeMockStatusQvitter(mastoFav))).to.have.property('type', 'favorite')
	+ })
	+
	+ it('sets nsfw for statuses with the #nsfw tag', () => {
	+ const safe = makeMockStatusQvitter({id: 1, text: 'Hello oniichan'})
	+ const nsfw = makeMockStatusQvitter({id: 1, text: 'Hello oniichan #nsfw'})
	+
	+ expect(parseStatus(safe).nsfw).to.eq(false)
	+ expect(parseStatus(nsfw).nsfw).to.eq(true)
	+ })
	+
	+ it('leaves existing nsfw settings alone', () => {
	+ const nsfw = makeMockStatusQvitter({id: 1, text: 'Hello oniichan #nsfw', nsfw: false})
	+
	+ expect(parseStatus(nsfw).nsfw).to.eq(false)
	+ })
	+})

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 2, 8:23 AM (13 h, 1 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803812
Default Alt Text: (54 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions