No OneTemporary
Actions

Authored By

Unknown

Size

21 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/services/api/api.service.js b/src/services/api/api.service.js
	index 2dd52cb52a..6b255e9f49 100644
	--- a/src/services/api/api.service.js
	+++ b/src/services/api/api.service.js
	@@ -1,776 +1,789 @@
	/* eslint-env browser */
	const LOGIN_URL = '/api/account/verify_credentials.json'
	const ALL_FOLLOWING_URL = '/api/qvitter/allfollowing'
	const MENTIONS_URL = '/api/statuses/mentions.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_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 TAG_USER_URL = '/api/pleroma/admin/users/tag'
	const PERMISSION_GROUP_URL = '/api/pleroma/admin/permission_group'
	const ACTIVATION_STATUS_URL = '/api/pleroma/admin/activation_status'
	const ADMIN_USER_URL = '/api/pleroma/admin/user'
	const SUGGESTIONS_URL = '/api/v1/suggestions'

	const MASTODON_USER_FAVORITES_TIMELINE_URL = '/api/v1/favourites'
	const MASTODON_USER_NOTIFICATIONS_URL = '/api/v1/notifications'
	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_TAG_TIMELINE_URL = tag => `/api/v1/timelines/tag/${tag}`
	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 { each, map, concat, last } 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 = MASTODON_FOLLOW_URL(id)
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const unfollowUser = ({id, credentials}) => {
	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))
	+ return new Promise(async (resolve, reject) => {
	+ try {
	+ let friends = []
	+ let more = true
	+ while (more) {
	+ const maxId = friends.length > 0 ? last(friends).id : undefined
	+ const users = await fetchFriends({id, maxId, credentials})
	+ friends = concat(friends, users)
	+ if (users.length === 0) {
	+ more = false
	+ }
	+ }
	+ resolve(friends)
	+ } catch (err) {
	+ reject(err)
	+ }
	+ })
	}

	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 tagUser = ({tag, credentials, ...options}) => {
	const screenName = options.screen_name
	const form = {
	nicknames: [screenName],
	tags: [tag]
	}

	const headers = authHeaders(credentials)
	headers['Content-Type'] = 'application/json'

	return fetch(TAG_USER_URL, {
	method: 'PUT',
	headers: headers,
	body: JSON.stringify(form)
	})
	}

	const untagUser = ({tag, credentials, ...options}) => {
	const screenName = options.screen_name
	const body = {
	nicknames: [screenName],
	tags: [tag]
	}

	const headers = authHeaders(credentials)
	headers['Content-Type'] = 'application/json'

	return fetch(TAG_USER_URL, {
	method: 'DELETE',
	headers: headers,
	body: JSON.stringify(body)
	})
	}

	const addRight = ({right, credentials, ...user}) => {
	const screenName = user.screen_name

	return fetch(`${PERMISSION_GROUP_URL}/${screenName}/${right}`, {
	method: 'POST',
	headers: authHeaders(credentials),
	body: {}
	})
	}

	const deleteRight = ({right, credentials, ...user}) => {
	const screenName = user.screen_name

	return fetch(`${PERMISSION_GROUP_URL}/${screenName}/${right}`, {
	method: 'DELETE',
	headers: authHeaders(credentials),
	body: {}
	})
	}

	const setActivationStatus = ({status, credentials, ...user}) => {
	const screenName = user.screen_name
	const body = {
	status: status
	}

	const headers = authHeaders(credentials)
	headers['Content-Type'] = 'application/json'

	return fetch(`${ACTIVATION_STATUS_URL}/${screenName}.json`, {
	method: 'PUT',
	headers: headers,
	body: JSON.stringify(body)
	})
	}

	const deleteUser = ({credentials, ...user}) => {
	const screenName = user.screen_name
	const headers = authHeaders(credentials)

	return fetch(`${ADMIN_USER_URL}.json?nickname=${screenName}`, {
	method: 'DELETE',
	headers: headers
	})
	}

	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: MASTODON_USER_NOTIFICATIONS_URL,
	'publicAndExternal': MASTODON_PUBLIC_TIMELINE,
	user: MASTODON_USER_TIMELINE_URL,
	media: MASTODON_USER_TIMELINE_URL,
	favorites: MASTODON_USER_FAVORITES_TIMELINE_URL,
	tag: MASTODON_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 = url(tag)
	}
	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(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(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(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(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(MASTODON_DELETE_URL(id), {
	headers: authHeaders(credentials),
	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,
	tagUser,
	untagUser,
	deleteUser,
	addRight,
	deleteRight,
	setActivationStatus,
	register,
	getCaptcha,
	updateAvatar,
	updateBg,
	updateProfile,
	updateBanner,
	externalProfile,
	followImport,
	deleteAccount,
	changePassword,
	fetchFollowRequests,
	approveUser,
	denyUser,
	suggestions,
	markNotificationsAsSeen
	}

	export default apiService

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 5:01 AM (1 d, 2 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799508
Default Alt Text: (21 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions