No OneTemporary
Actions

Authored By

Unknown

Size

39 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/modules/statuses.js b/src/modules/statuses.js
	index a16342e0e2..944b45c1ea 100644
	--- a/src/modules/statuses.js
	+++ b/src/modules/statuses.js
	@@ -1,485 +1,471 @@
	import { remove, slice, each, find, maxBy, minBy, merge, first, last, isArray, omitBy } from 'lodash'
	import { set } from 'vue'
	import apiService from '../services/api/api.service.js'
	// import parse from '../services/status_parser/status_parser.js'

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

	export const defaultState = () => ({
	allStatuses: [],
	allStatusesObject: {},
	maxId: 0,
	notifications: {
	desktopNotificationSilence: true,
	maxId: 0,
	minId: Number.POSITIVE_INFINITY,
	data: [],
	idStore: {},
	loading: false,
	error: false,
	fetcherId: null
	},
	favorites: new Set(),
	error: false,
	timelines: {
	mentions: emptyTl(),
	public: emptyTl(),
	user: emptyTl(),
	favorites: emptyTl(),
	media: emptyTl(),
	publicAndExternal: emptyTl(),
	friends: emptyTl(),
	tag: emptyTl(),
	dms: emptyTl()
	}
	})

	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(_ => _)
	}

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

	if (oldItem) {
	// We already have this, so only merge the new info.
	// We ignore null values to avoid overwriting existing properties with missing data
	// we also skip 'user' because that is handled by users module
	merge(oldItem, omitBy(item, (v, k) => v === null \|\| k === 'user'))
	// 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)
	set(obj, item.id, item)
	return {item, new: true}
	}
	}

	const sortById = (a, b) => {
	const seqA = Number(a.id)
	const seqB = Number(b.id)
	const isSeqA = !Number.isNaN(seqA)
	const isSeqB = !Number.isNaN(seqB)
	if (isSeqA && isSeqB) {
	return seqA > seqB ? -1 : 1
	} else if (isSeqA && !isSeqB) {
	return 1
	} else if (!isSeqA && isSeqB) {
	return -1
	} else {
	return a.id > b.id ? -1 : 1
	}
	}

	const sortTimeline = (timeline) => {
	timeline.visibleStatuses = timeline.visibleStatuses.sort(sortById)
	timeline.statuses = timeline.statuses.sort(sortById)
	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 = state.timelines[timeline]

	const maxNew = statuses.length > 0 ? maxBy(statuses, 'id').id : 0
	const minNew = statuses.length > 0 ? minBy(statuses, 'id').id : 0
	const newer = timeline && maxNew > timelineObject.maxId && statuses.length > 0
	const older = timeline && (minNew < timelineObject.minId \|\| timelineObject.minId === 0) && statuses.length > 0

	if (!noIdUpdate && newer) {
	timelineObject.maxId = maxNew
	}
	if (!noIdUpdate && older) {
	timelineObject.minId = minNew
	}

	// 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' \|\| timeline === 'media') && 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: 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)
	}
	}

	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 = notification.id > state.notifications.maxId
	? notification.id
	: state.notifications.maxId
	state.notifications.minId = notification.id < state.notifications.minId
	? 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.seen && !state.notifications.desktopNotificationSilence && visibleNotificationTypes.includes(notification.type)) {
	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)
	}
	}
	} else if (notification.seen) {
	state.notifications.idStore[notification.id].seen = true
	}
	})
	}

	const removeStatus = (state, { timeline, userId }) => {
	const timelineObject = state.timelines[timeline]
	if (userId) {
	remove(timelineObject.statuses, { user: { id: userId } })
	remove(timelineObject.visibleStatuses, { user: { id: userId } })
	timelineObject.minVisibleId = timelineObject.visibleStatuses.length > 0 ? last(timelineObject.visibleStatuses).id : 0
	timelineObject.maxId = timelineObject.statuses.length > 0 ? first(timelineObject.statuses).id : 0
	}
	}

	export const mutations = {
	addNewStatuses,
	addNewNotifications,
	removeStatus,
	showNewStatuses (state, { timeline }) {
	const oldTimeline = (state.timelines[timeline])

	oldTimeline.newStatusCount = 0
	oldTimeline.visibleStatuses = slice(oldTimeline.statuses, 0, 50)
	oldTimeline.minVisibleId = last(oldTimeline.visibleStatuses).id
	oldTimeline.minId = oldTimeline.minVisibleId
	oldTimeline.visibleStatusesObject = {}
	each(oldTimeline.visibleStatuses, (status) => { oldTimeline.visibleStatusesObject[status.id] = status })
	},
	setNotificationFetcher (state, { fetcherId }) {
	state.notifications.fetcherId = fetcherId
	},
	resetStatuses (state) {
	const emptyState = defaultState()
	Object.entries(emptyState).forEach(([key, value]) => {
	state[key] = value
	})
	},
	clearTimeline (state, { timeline }) {
	state.timelines[timeline] = emptyTl(state.timelines[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 }) {
	state.timelines[timeline].loading = value
	},
	setNsfw (state, { id, nsfw }) {
	const newStatus = state.allStatusesObject[id]
	newStatus.nsfw = nsfw
	},
	setError (state, { value }) {
	state.error = value
	},
	setNotificationsLoading (state, { value }) {
	state.notifications.loading = 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 }) {
	state.timelines[timeline].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 })
	},
	setNotificationsLoading ({ rootState, commit }, { value }) {
	commit('setNotificationsLoading', { value })
	},
	setNotificationsError ({ rootState, commit }, { value }) {
	commit('setNotificationsError', { value })
	},
	setNotificationsSilence ({ rootState, commit }, { value }) {
	commit('setNotificationsSilence', { value })
	},
	stopFetchingNotifications ({ rootState, commit }) {
	if (rootState.statuses.notifications.fetcherId) {
	window.clearInterval(rootState.statuses.notifications.fetcherId)
	}
	commit('setNotificationFetcher', { fetcherId: null })
	},
	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 183334cf8e..a6484b3cd7 100644
	--- a/src/services/api/api.service.js
	+++ b/src/services/api/api.service.js
	@@ -1,654 +1,686 @@
	/* eslint-env browser */
	const LOGIN_URL = '/api/account/verify_credentials.json'
	const ALL_FOLLOWING_URL = '/api/qvitter/allfollowing'
	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_DELETE_URL = '/api/statuses/destroy'
	const MENTIONS_URL = '/api/statuses/mentions.json'
	-const FOLLOWING_URL = '/api/friendships/create.json'
	-const UNFOLLOWING_URL = '/api/friendships/destroy.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_NOTIFICATIONS_URL = '/api/qvitter/statuses/notifications.json'
	const QVITTER_USER_NOTIFICATIONS_READ_URL = '/api/qvitter/statuses/notifications/read.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'
	+const MASTODON_FAVORITE_URL = id => `/api/v1/statuses/${id}/favourite`
	+const MASTODON_UNFAVORITE_URL = id => `/api/v1/statuses/${id}/unfavourite`
	+const MASTODON_RETWEET_URL = id => `/api/v1/statuses/${id}/reblog`
	+const MASTODON_UNRETWEET_URL = id => `/api/v1/statuses/${id}/unreblog`
	+const MASTODON_DELETE_URL = id => `/api/v1/statuses/${id}`
	+const MASTODON_FOLLOW_URL = id => `/api/v1/accounts/${id}/follow`
	+const MASTODON_UNFOLLOW_URL = id => `/api/v1/accounts/${id}/unfollow`
	const MASTODON_FOLLOWING_URL = id => `/api/v1/accounts/${id}/following`
	const MASTODON_FOLLOWERS_URL = id => `/api/v1/accounts/${id}/followers`
	const MASTODON_DIRECT_MESSAGES_TIMELINE_URL = '/api/v1/timelines/direct'
	const MASTODON_PUBLIC_TIMELINE = '/api/v1/timelines/public'
	const MASTODON_USER_HOME_TIMELINE_URL = '/api/v1/timelines/home'
	const MASTODON_STATUS_URL = id => `/api/v1/statuses/${id}`
	const MASTODON_STATUS_CONTEXT_URL = id => `/api/v1/statuses/${id}/context`
	const MASTODON_USER_URL = '/api/v1/accounts'
	const MASTODON_USER_RELATIONSHIPS_URL = '/api/v1/accounts/relationships'
	const MASTODON_USER_TIMELINE_URL = id => `/api/v1/accounts/${id}/statuses`
	const MASTODON_USER_BLOCKS_URL = '/api/v1/blocks/'
	const MASTODON_USER_MUTES_URL = '/api/v1/mutes/'
	const MASTODON_BLOCK_USER_URL = id => `/api/v1/accounts/${id}/block`
	const MASTODON_UNBLOCK_USER_URL = id => `/api/v1/accounts/${id}/unblock`
	const MASTODON_MUTE_USER_URL = id => `/api/v1/accounts/${id}/mute`
	const MASTODON_UNMUTE_USER_URL = id => `/api/v1/accounts/${id}/unmute`
	const MASTODON_POST_STATUS_URL = '/api/v1/statuses'
	const MASTODON_MEDIA_UPLOAD_URL = '/api/v1/media'

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

	const oldfetch = window.fetch

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

	const promisedRequest = (url, options) => {
	return fetch(url, options)
	.then((response) => {
	return new Promise((resolve, reject) => response.json()
	.then((json) => {
	if (!response.ok) {
	return reject(new StatusCodeError(response.status, json, { url, options }, response))
	}
	return resolve(json)
	}))
	})
	}

	// 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}) => {
	// Always include these fields, because they might be empty or false
	const fields = ['description', 'locked', 'no_rich_text', 'hide_follows', 'hide_followers', 'show_role']
	let url = PROFILE_UPDATE_URL

	const form = new FormData()

	each(params, (value, key) => {
	if (fields.includes(key) \|\| 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}`
	+ let url = MASTODON_FOLLOW_URL(id)
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

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

	const blockUser = ({id, credentials}) => {
	return fetch(MASTODON_BLOCK_USER_URL(id), {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const unblockUser = ({id, credentials}) => {
	return fetch(MASTODON_UNBLOCK_USER_URL(id), {
	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 = `${MASTODON_USER_URL}/${id}`
	return promisedRequest(url, { headers: authHeaders(credentials) })
	.then((data) => parseUser(data))
	}

	const fetchUserRelationship = ({id, credentials}) => {
	let url = `${MASTODON_USER_RELATIONSHIPS_URL}/?id=${id}`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((response) => {
	return new Promise((resolve, reject) => response.json()
	.then((json) => {
	if (!response.ok) {
	return reject(new StatusCodeError(response.status, json, { url }, response))
	}
	return resolve(json)
	}))
	})
	}

	const fetchFriends = ({id, maxId, sinceId, limit = 20, credentials}) => {
	let url = MASTODON_FOLLOWING_URL(id)
	const args = [
	maxId && `max_id=${maxId}`,
	sinceId && `since_id=${sinceId}`,
	limit && `limit=${limit}`
	].filter(_ => _).join('&')

	url = url + (args ? '?' + args : '')
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const exportFriends = ({id, credentials}) => {
	let url = MASTODON_FOLLOWING_URL(id) + `?all=true`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const fetchFollowers = ({id, maxId, sinceId, limit = 20, credentials}) => {
	let url = MASTODON_FOLLOWERS_URL(id)
	const args = [
	maxId && `max_id=${maxId}`,
	sinceId && `since_id=${sinceId}`,
	limit && `limit=${limit}`
	].filter(_ => _).join('&')

	url += args ? '?' + args : ''
	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 urlContext = MASTODON_STATUS_CONTEXT_URL(id)
	return fetch(urlContext, { headers: authHeaders(credentials) })
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching timeline', data)
	})
	.then((data) => data.json())
	.then(({ancestors, descendants}) => ({
	ancestors: ancestors.map(parseStatus),
	descendants: descendants.map(parseStatus)
	}))
	}

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

	const fetchTimeline = ({timeline, credentials, since = false, until = false, userId = false, tag = false, withMuted = false}) => {
	const timelineUrls = {
	public: MASTODON_PUBLIC_TIMELINE,
	friends: MASTODON_USER_HOME_TIMELINE_URL,
	mentions: MENTIONS_URL,
	dms: MASTODON_DIRECT_MESSAGES_TIMELINE_URL,
	notifications: QVITTER_USER_NOTIFICATIONS_URL,
	'publicAndExternal': MASTODON_PUBLIC_TIMELINE,
	user: MASTODON_USER_TIMELINE_URL,
	media: MASTODON_USER_TIMELINE_URL,
	favorites: MASTODON_USER_FAVORITES_TIMELINE_URL,
	tag: TAG_TIMELINE_URL
	}
	const isNotifications = timeline === 'notifications'
	const params = []

	let url = timelineUrls[timeline]

	if (timeline === 'user' \|\| timeline === 'media') {
	url = url(userId)
	}

	if (since) {
	params.push(['since_id', since])
	}
	if (until) {
	params.push(['max_id', until])
	}
	if (tag) {
	url += `/${tag}.json`
	}
	if (timeline === 'media') {
	params.push(['only_media', 1])
	}
	if (timeline === 'public') {
	params.push(['local', true])
	}
	if (timeline === 'public' \|\| timeline === 'publicAndExternal') {
	params.push(['only_media', false])
	}

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

	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', data)
	})
	.then((data) => data.json())
	.then((data) => data.map(isNotifications ? parseNotification : parseStatus))
	}

	const verifyCredentials = (user) => {
	return fetch(LOGIN_URL, {
	method: 'POST',
	headers: authHeaders(user)
	})
	.then((response) => {
	if (response.ok) {
	return response.json()
	} else {
	return {
	error: response
	}
	}
	})
	.then((data) => data.error ? data : parseUser(data))
	}

	const favorite = ({ id, credentials }) => {
	- return fetch(`${FAVORITE_URL}/${id}.json`, {
	+ return fetch(MASTODON_FAVORITE_URL(id), {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	+ .then(response => {
	+ if (response.ok) {
	+ return response.json()
	+ } else {
	+ throw new Error('Error favoriting post')
	+ }
	+ })
	+ .then((data) => parseStatus(data))
	}

	const unfavorite = ({ id, credentials }) => {
	- return fetch(`${UNFAVORITE_URL}/${id}.json`, {
	+ return fetch(MASTODON_UNFAVORITE_URL(id), {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	+ .then(response => {
	+ if (response.ok) {
	+ return response.json()
	+ } else {
	+ throw new Error('Error removing favorite')
	+ }
	+ })
	+ .then((data) => parseStatus(data))
	}

	const retweet = ({ id, credentials }) => {
	- return fetch(`${RETWEET_URL}/${id}.json`, {
	+ return fetch(MASTODON_RETWEET_URL(id), {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	+ .then(response => {
	+ if (response.ok) {
	+ return response.json()
	+ } else {
	+ throw new Error('Error repeating post')
	+ }
	+ })
	+ .then((data) => parseStatus(data))
	}

	const unretweet = ({ id, credentials }) => {
	- return fetch(`${UNRETWEET_URL}/${id}.json`, {
	+ return fetch(MASTODON_UNRETWEET_URL(id), {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	+ .then(response => {
	+ if (response.ok) {
	+ return response.json()
	+ } else {
	+ throw new Error('Error removing repeat')
	+ }
	+ })
	+ .then((data) => parseStatus(data))
	}

	const postStatus = ({credentials, status, spoilerText, visibility, sensitive, mediaIds = [], inReplyToStatusId, contentType}) => {
	const form = new FormData()

	form.append('status', status)
	form.append('source', 'Pleroma FE')
	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)
	mediaIds.forEach(val => {
	form.append('media_ids[]', val)
	})
	if (inReplyToStatusId) {
	form.append('in_reply_to_id', inReplyToStatusId)
	}

	return fetch(MASTODON_POST_STATUS_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => {
	if (response.ok) {
	return response.json()
	} else {
	return {
	error: response
	}
	}
	})
	.then((data) => data.error ? data : parseStatus(data))
	}

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

	const uploadMedia = ({formData, credentials}) => {
	return fetch(MASTODON_MEDIA_UPLOAD_URL, {
	body: formData,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((data) => data.json())
	.then((data) => parseAttachment(data))
	}

	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}) => {
	return promisedRequest(MASTODON_USER_MUTES_URL, { headers: authHeaders(credentials) })
	.then((users) => users.map(parseUser))
	}

	const muteUser = ({id, credentials}) => {
	return promisedRequest(MASTODON_MUTE_USER_URL(id), {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const unmuteUser = ({id, credentials}) => {
	return promisedRequest(MASTODON_UNMUTE_USER_URL(id), {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const fetchBlocks = ({credentials}) => {
	return promisedRequest(MASTODON_USER_BLOCKS_URL, { headers: authHeaders(credentials) })
	.then((users) => users.map(parseUser))
	}

	const fetchOAuthTokens = ({credentials}) => {
	const url = '/api/oauth_tokens.json'

	return fetch(url, {
	headers: authHeaders(credentials)
	}).then((data) => {
	if (data.ok) {
	return data.json()
	}
	throw new Error('Error fetching auth tokens', data)
	})
	}

	const revokeOAuthToken = ({id, credentials}) => {
	const url = `/api/oauth_tokens/${id}`

	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'DELETE'
	})
	}

	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,
	exportFriends,
	fetchFollowers,
	followUser,
	unfollowUser,
	blockUser,
	unblockUser,
	fetchUser,
	fetchUserRelationship,
	favorite,
	unfavorite,
	retweet,
	unretweet,
	postStatus,
	deleteStatus,
	uploadMedia,
	fetchAllFollowing,
	fetchMutes,
	muteUser,
	unmuteUser,
	fetchBlocks,
	fetchOAuthTokens,
	revokeOAuthToken,
	register,
	getCaptcha,
	updateAvatar,
	updateBg,
	updateProfile,
	updateBanner,
	externalProfile,
	followImport,
	deleteAccount,
	changePassword,
	fetchFollowRequests,
	approveUser,
	denyUser,
	suggestions,
	markNotificationsAsSeen
	}

	export default apiService
	diff --git a/src/services/follow_manipulate/follow_manipulate.js b/src/services/follow_manipulate/follow_manipulate.js
	index 1e9bd67916..51dafe84ee 100644
	--- a/src/services/follow_manipulate/follow_manipulate.js
	+++ b/src/services/follow_manipulate/follow_manipulate.js
	@@ -1,74 +1,74 @@
	const fetchUser = (attempt, user, store) => new Promise((resolve, reject) => {
	setTimeout(() => {
	store.state.api.backendInteractor.fetchUser({ id: user.id })
	.then((user) => store.commit('addNewUsers', [user]))
	.then(() => resolve([user.following, attempt]))
	.catch((e) => reject(e))
	}, 500)
	}).then(([following, attempt]) => {
	if (!following && attempt <= 3) {
	// If we BE reports that we still not following that user - retry,
	// increment attempts by one
	return fetchUser(++attempt, user, store)
	} else {
	// If we run out of attempts, just return whatever status is.
	return following
	}
	})

	export const requestFollow = (user, store) => new Promise((resolve, reject) => {
	store.state.api.backendInteractor.followUser(user.id)
	.then((updated) => {
	- store.commit('addNewUsers', [updated])
	+ store.commit('updateUserRelationship', [updated])

	// For locked users we just mark it that we sent the follow request
	if (updated.locked) {
	resolve({
	sent: true,
	updated
	})
	}

	if (updated.following) {
	// If we get result immediately, just stop.
	resolve({
	sent: false,
	updated
	})
	}

	// But usually we don't get result immediately, so we ask server
	// for updated user profile to confirm if we are following them
	// Sometimes it takes several tries. Sometimes we end up not following
	// user anyway, probably because they locked themselves and we
	// don't know that yet.
	// Recursive Promise, it will call itself up to 3 times.

	return fetchUser(1, user, store)
	.then((following) => {
	if (following) {
	// We confirmed and everything's good.
	resolve({
	sent: false,
	updated
	})
	} else {
	// If after all the tries, just treat it as if user is locked
	resolve({
	sent: false,
	updated
	})
	}
	})
	})
	})

	export const requestUnfollow = (user, store) => new Promise((resolve, reject) => {
	store.state.api.backendInteractor.unfollowUser(user.id)
	.then((updated) => {
	- store.commit('addNewUsers', [updated])
	+ store.commit('updateUserRelationship', [updated])
	resolve({
	updated
	})
	})
	})

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 10:55 PM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798792
Default Alt Text: (39 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions