pleroma-fe/src/services/api/api.service.js

1208 lines
32 KiB
JavaScript
Raw Normal View History

import { each, map, concat, last, get } from 'lodash'
2019-06-18 22:28:31 +02:00
import { parseStatus, parseUser, parseNotification, parseAttachment } from '../entity_normalizer/entity_normalizer.service.js'
import 'whatwg-fetch'
import { RegistrationError, StatusCodeError } from '../errors/errors'
2019-06-18 22:28:31 +02:00
2016-10-27 18:03:14 +02:00
/* eslint-env browser */
2019-03-30 12:27:53 +01:00
const BLOCKS_IMPORT_URL = '/api/pleroma/blocks_import'
2017-12-23 15:44:22 +01:00
const FOLLOW_IMPORT_URL = '/api/pleroma/follow_import'
const DELETE_ACCOUNT_URL = '/api/pleroma/delete_account'
2019-11-08 03:21:19 +01:00
const CHANGE_EMAIL_URL = '/api/pleroma/change_email'
2018-05-22 00:01:09 +02:00
const CHANGE_PASSWORD_URL = '/api/pleroma/change_password'
2019-02-18 15:49:32 +01:00
const TAG_USER_URL = '/api/pleroma/admin/users/tag'
2019-05-16 20:02:37 +02:00
const PERMISSION_GROUP_URL = (screenName, right) => `/api/pleroma/admin/users/${screenName}/permission_group/${right}`
const ACTIVATE_USER_URL = '/api/pleroma/admin/users/activate'
const DEACTIVATE_USER_URL = '/api/pleroma/admin/users/deactivate'
const ADMIN_USERS_URL = '/api/pleroma/admin/users'
2018-08-02 11:34:12 +02:00
const SUGGESTIONS_URL = '/api/v1/suggestions'
2019-05-25 09:01:02 +02:00
const NOTIFICATION_SETTINGS_URL = '/api/pleroma/notification_settings'
const NOTIFICATION_READ_URL = '/api/v1/pleroma/notifications/read'
2016-10-27 18:03:14 +02:00
const MFA_SETTINGS_URL = '/api/pleroma/accounts/mfa'
const MFA_BACKUP_CODES_URL = '/api/pleroma/accounts/mfa/backup_codes'
const MFA_SETUP_OTP_URL = '/api/pleroma/accounts/mfa/setup/totp'
const MFA_CONFIRM_OTP_URL = '/api/pleroma/accounts/mfa/confirm/totp'
2019-12-11 13:59:29 +01:00
const MFA_DISABLE_OTP_URL = '/api/pleroma/accounts/mfa/totp'
2019-05-21 22:35:40 +02:00
const MASTODON_LOGIN_URL = '/api/v1/accounts/verify_credentials'
const MASTODON_REGISTRATION_URL = '/api/v1/accounts'
const MASTODON_USER_FAVORITES_TIMELINE_URL = '/api/v1/favourites'
2019-03-12 22:16:57 +01:00
const MASTODON_USER_NOTIFICATIONS_URL = '/api/v1/notifications'
const MASTODON_DISMISS_NOTIFICATION_URL = id => `/api/v1/notifications/${id}/dismiss`
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`
2019-09-03 12:38:52 +02:00
const MASTODON_FOLLOW_REQUESTS_URL = '/api/v1/follow_requests'
const MASTODON_APPROVE_USER_URL = id => `/api/v1/follow_requests/${id}/authorize`
const MASTODON_DENY_USER_URL = id => `/api/v1/follow_requests/${id}/reject`
2019-03-07 19:21:07 +01:00
const MASTODON_DIRECT_MESSAGES_TIMELINE_URL = '/api/v1/timelines/direct'
2019-03-07 19:16:35 +01:00
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'
2019-03-07 23:50:58 +01:00
const MASTODON_USER_TIMELINE_URL = id => `/api/v1/accounts/${id}/statuses`
const MASTODON_TAG_TIMELINE_URL = tag => `/api/v1/timelines/tag/${tag}`
2019-03-22 02:27:10 +01:00
const MASTODON_USER_BLOCKS_URL = '/api/v1/blocks/'
const MASTODON_USER_MUTES_URL = '/api/v1/mutes/'
2019-03-22 02:44:59 +01:00
const MASTODON_BLOCK_USER_URL = id => `/api/v1/accounts/${id}/block`
const MASTODON_UNBLOCK_USER_URL = id => `/api/v1/accounts/${id}/unblock`
2019-03-22 02:53:24 +01:00
const MASTODON_MUTE_USER_URL = id => `/api/v1/accounts/${id}/mute`
const MASTODON_UNMUTE_USER_URL = id => `/api/v1/accounts/${id}/unmute`
const MASTODON_SUBSCRIBE_USER = id => `/api/v1/pleroma/accounts/${id}/subscribe`
const MASTODON_UNSUBSCRIBE_USER = id => `/api/v1/pleroma/accounts/${id}/unsubscribe`
const MASTODON_POST_STATUS_URL = '/api/v1/statuses'
const MASTODON_MEDIA_UPLOAD_URL = '/api/v1/media'
2019-06-18 22:28:31 +02:00
const MASTODON_VOTE_URL = id => `/api/v1/polls/${id}/votes`
const MASTODON_POLL_URL = id => `/api/v1/polls/${id}`
2019-04-02 18:13:55 +02:00
const MASTODON_STATUS_FAVORITEDBY_URL = id => `/api/v1/statuses/${id}/favourited_by`
2019-04-02 04:30:06 +02:00
const MASTODON_STATUS_REBLOGGEDBY_URL = id => `/api/v1/statuses/${id}/reblogged_by`
const MASTODON_PROFILE_UPDATE_URL = '/api/v1/accounts/update_credentials'
2019-04-25 04:40:37 +02:00
const MASTODON_REPORT_USER_URL = '/api/v1/reports'
2019-04-04 17:27:02 +02:00
const MASTODON_PIN_OWN_STATUS = id => `/api/v1/statuses/${id}/pin`
const MASTODON_UNPIN_OWN_STATUS = id => `/api/v1/statuses/${id}/unpin`
const MASTODON_MUTE_CONVERSATION = id => `/api/v1/statuses/${id}/mute`
const MASTODON_UNMUTE_CONVERSATION = id => `/api/v1/statuses/${id}/unmute`
2019-07-15 18:42:27 +02:00
const MASTODON_SEARCH_2 = `/api/v2/search`
const MASTODON_USER_SEARCH_URL = '/api/v1/accounts/search'
2020-01-15 21:22:54 +01:00
const MASTODON_DOMAIN_BLOCKS_URL = '/api/v1/domain_blocks'
2019-11-24 17:50:28 +01:00
const MASTODON_STREAMING = '/api/v1/streaming'
const MASTODON_KNOWN_DOMAIN_LIST_URL = '/api/v1/instance/peers'
const PLEROMA_EMOJI_REACTIONS_URL = id => `/api/v1/pleroma/statuses/${id}/reactions`
const PLEROMA_EMOJI_REACT_URL = (id, emoji) => `/api/v1/pleroma/statuses/${id}/reactions/${emoji}`
const PLEROMA_EMOJI_UNREACT_URL = (id, emoji) => `/api/v1/pleroma/statuses/${id}/reactions/${emoji}`
const oldfetch = window.fetch
2016-10-27 18:03:14 +02:00
2016-11-22 15:45:40 +01:00
let fetch = (url, options) => {
options = options || {}
2016-11-22 15:45:40 +01:00
const baseUrl = ''
const fullUrl = baseUrl + url
options.credentials = 'same-origin'
return oldfetch(fullUrl, options)
2016-11-22 15:45:40 +01:00
}
const promisedRequest = ({ method, url, params, payload, credentials, headers = {} }) => {
const options = {
method,
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json',
...headers
}
}
if (params) {
url += '?' + Object.entries(params)
.map(([key, value]) => encodeURIComponent(key) + '=' + encodeURIComponent(value))
.join('&')
}
if (payload) {
options.body = JSON.stringify(payload)
}
if (credentials) {
options.headers = {
...options.headers,
...authHeaders(credentials)
}
}
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)
}))
})
}
2019-06-18 22:28:31 +02:00
const updateNotificationSettings = ({ credentials, settings }) => {
2019-05-25 09:01:02 +02:00
const form = new FormData()
each(settings, (value, key) => {
form.append(key, value)
})
return fetch(NOTIFICATION_SETTINGS_URL, {
headers: authHeaders(credentials),
method: 'PUT',
body: form
2019-06-18 22:28:31 +02:00
}).then((data) => data.json())
2019-05-25 09:01:02 +02:00
}
2019-06-18 22:28:31 +02:00
const updateAvatar = ({ credentials, avatar }) => {
2017-04-16 13:44:11 +02:00
const form = new FormData()
form.append('avatar', avatar)
return fetch(MASTODON_PROFILE_UPDATE_URL, {
2017-04-16 13:44:11 +02:00
headers: authHeaders(credentials),
method: 'PATCH',
2017-04-16 13:44:11 +02:00
body: form
2019-06-18 22:28:31 +02:00
}).then((data) => data.json())
.then((data) => parseUser(data))
2017-04-16 13:44:11 +02:00
}
const updateBg = ({ credentials, background }) => {
const form = new FormData()
form.append('pleroma_background_image', background)
return fetch(MASTODON_PROFILE_UPDATE_URL, {
headers: authHeaders(credentials),
method: 'PATCH',
body: form
})
.then((data) => data.json())
.then((data) => parseUser(data))
}
2019-06-18 22:28:31 +02:00
const updateBanner = ({ credentials, banner }) => {
const form = new FormData()
2019-03-13 18:56:28 +01:00
form.append('header', banner)
return fetch(MASTODON_PROFILE_UPDATE_URL, {
headers: authHeaders(credentials),
2019-03-13 18:56:28 +01:00
method: 'PATCH',
body: form
2019-06-18 22:28:31 +02:00
}).then((data) => data.json())
.then((data) => parseUser(data))
}
2019-06-18 22:28:31 +02:00
const updateProfile = ({ credentials, params }) => {
2019-04-30 22:38:34 +02:00
return promisedRequest({
url: MASTODON_PROFILE_UPDATE_URL,
method: 'PATCH',
2019-04-30 22:38:34 +02:00
payload: params,
credentials
2019-06-18 22:28:31 +02:00
}).then((data) => parseUser(data))
}
2017-04-15 18:12:23 +02:00
// Params needed:
// nickname
// email
// fullname
// password
// password_confirm
//
// Optional
// bio
// homepage
// location
2018-08-05 09:01:38 +02:00
// token
const register = ({ params, credentials }) => {
const { nickname, ...rest } = params
return fetch(MASTODON_REGISTRATION_URL, {
2017-04-15 18:12:23 +02:00
method: 'POST',
headers: {
...authHeaders(credentials),
'Content-Type': 'application/json'
},
body: JSON.stringify({
nickname,
2019-06-12 23:47:06 +02:00
locale: 'en_US',
agreement: true,
...rest
})
2017-04-15 18:12:23 +02:00
})
.then((response) => {
if (response.ok) {
return response.json()
} else {
return response.json().then((error) => { throw new RegistrationError(error) })
}
})
2017-04-15 18:12:23 +02:00
}
const getCaptcha = () => fetch('/api/pleroma/captcha').then(resp => resp.json())
2018-10-26 15:16:23 +02:00
const authHeaders = (accessToken) => {
if (accessToken) {
return { 'Authorization': `Bearer ${accessToken}` }
} else {
return { }
}
}
2016-10-28 14:26:51 +02:00
2019-10-08 09:21:48 +02:00
const followUser = ({ id, credentials, ...options }) => {
let url = MASTODON_FOLLOW_URL(id)
2019-10-08 09:21:48 +02:00
const form = {}
if (options.reblogs !== undefined) { form['reblogs'] = options.reblogs }
2016-12-08 09:09:21 +01:00
return fetch(url, {
2019-10-08 09:21:48 +02:00
body: JSON.stringify(form),
headers: {
...authHeaders(credentials),
'Content-Type': 'application/json'
},
2016-12-08 09:09:21 +01:00
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const unfollowUser = ({ id, credentials }) => {
let url = MASTODON_UNFOLLOW_URL(id)
2016-12-23 16:45:57 +01:00
return fetch(url, {
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-04-04 17:27:02 +02:00
const pinOwnStatus = ({ id, credentials }) => {
2019-05-04 19:11:19 +02:00
return promisedRequest({ url: MASTODON_PIN_OWN_STATUS(id), credentials, method: 'POST' })
.then((data) => parseStatus(data))
2019-04-04 17:27:02 +02:00
}
const unpinOwnStatus = ({ id, credentials }) => {
2019-05-04 19:11:19 +02:00
return promisedRequest({ url: MASTODON_UNPIN_OWN_STATUS(id), credentials, method: 'POST' })
.then((data) => parseStatus(data))
2019-04-04 17:27:02 +02:00
}
const muteConversation = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_MUTE_CONVERSATION(id), credentials, method: 'POST' })
.then((data) => parseStatus(data))
}
const unmuteConversation = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_UNMUTE_CONVERSATION(id), credentials, method: 'POST' })
.then((data) => parseStatus(data))
}
2019-06-18 22:28:31 +02:00
const blockUser = ({ id, credentials }) => {
2019-03-22 02:44:59 +01:00
return fetch(MASTODON_BLOCK_USER_URL(id), {
2017-11-07 21:38:28 +01:00
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const unblockUser = ({ id, credentials }) => {
2019-03-22 02:44:59 +01:00
return fetch(MASTODON_UNBLOCK_USER_URL(id), {
2017-11-07 21:38:28 +01:00
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const approveUser = ({ id, credentials }) => {
2019-09-03 12:38:52 +02:00
let url = MASTODON_APPROVE_USER_URL(id)
return fetch(url, {
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const denyUser = ({ id, credentials }) => {
2019-09-03 12:38:52 +02:00
let url = MASTODON_DENY_USER_URL(id)
return fetch(url, {
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const fetchUser = ({ id, credentials }) => {
let url = `${MASTODON_USER_URL}/${id}`
return promisedRequest({ url, credentials })
2019-01-14 13:30:14 +01:00
.then((data) => parseUser(data))
}
2019-06-18 22:28:31 +02:00
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)
}))
})
}
2019-06-18 22:28:31 +02:00
const fetchFriends = ({ id, maxId, sinceId, limit = 20, credentials }) => {
let url = MASTODON_FOLLOWING_URL(id)
2019-03-25 20:04:52 +01:00
const args = [
maxId && `max_id=${maxId}`,
2019-03-27 21:02:46 +01:00
sinceId && `since_id=${sinceId}`,
2020-05-13 16:48:31 +02:00
limit && `limit=${limit}`,
`with_relationships=true`
2019-03-25 20:04:52 +01:00
].filter(_ => _).join('&')
url = url + (args ? '?' + args : '')
return fetch(url, { headers: authHeaders(credentials) })
.then((data) => data.json())
.then((data) => data.map(parseUser))
}
2019-06-18 22:28:31 +02:00
const exportFriends = ({ id, credentials }) => {
2019-04-19 06:27:06 +02:00
return new Promise(async (resolve, reject) => {
try {
let friends = []
let more = true
while (more) {
const maxId = friends.length > 0 ? last(friends).id : undefined
2019-07-05 09:02:14 +02:00
const users = await fetchFriends({ id, maxId, credentials })
2019-04-19 06:27:06 +02:00
friends = concat(friends, users)
if (users.length === 0) {
more = false
}
}
resolve(friends)
} catch (err) {
reject(err)
}
})
2017-08-21 19:25:01 +02:00
}
2019-06-18 22:28:31 +02:00
const fetchFollowers = ({ id, maxId, sinceId, limit = 20, credentials }) => {
let url = MASTODON_FOLLOWERS_URL(id)
2019-03-25 20:04:52 +01:00
const args = [
maxId && `max_id=${maxId}`,
2019-03-27 21:02:46 +01:00
sinceId && `since_id=${sinceId}`,
2020-05-13 16:48:31 +02:00
limit && `limit=${limit}`,
`with_relationships=true`
2019-03-25 20:04:52 +01:00
].filter(_ => _).join('&')
2019-03-27 21:02:46 +01:00
url += args ? '?' + args : ''
2017-08-21 19:25:01 +02:00
return fetch(url, { headers: authHeaders(credentials) })
2016-11-30 21:27:25 +01:00
.then((data) => data.json())
2019-01-14 13:30:14 +01:00
.then((data) => data.map(parseUser))
2016-11-30 21:27:25 +01:00
}
2019-06-18 22:28:31 +02:00
const fetchFollowRequests = ({ credentials }) => {
2019-09-03 12:38:52 +02:00
const url = MASTODON_FOLLOW_REQUESTS_URL
2018-06-07 00:26:24 +02:00
return fetch(url, { headers: authHeaders(credentials) })
.then((data) => data.json())
2019-09-03 12:38:52 +02:00
.then((data) => data.map(parseUser))
2018-06-07 00:26:24 +02:00
}
2019-06-18 22:28:31 +02:00
const fetchConversation = ({ id, credentials }) => {
let urlContext = MASTODON_STATUS_CONTEXT_URL(id)
return fetch(urlContext, { headers: authHeaders(credentials) })
2019-01-14 20:58:23 +01:00
.then((data) => {
if (data.ok) {
return data
}
2019-01-17 21:22:51 +01:00
throw new Error('Error fetching timeline', data)
2019-01-14 20:58:23 +01:00
})
2019-01-17 21:22:51 +01:00
.then((data) => data.json())
2019-06-18 22:28:31 +02:00
.then(({ ancestors, descendants }) => ({
ancestors: ancestors.map(parseStatus),
descendants: descendants.map(parseStatus)
}))
}
2019-06-18 22:28:31 +02:00
const fetchStatus = ({ id, credentials }) => {
let url = MASTODON_STATUS_URL(id)
return fetch(url, { headers: authHeaders(credentials) })
2019-01-14 20:58:23 +01:00
.then((data) => {
if (data.ok) {
return data
}
2019-01-17 21:22:51 +01:00
throw new Error('Error fetching timeline', data)
2019-01-14 20:58:23 +01:00
})
2019-01-17 21:22:51 +01:00
.then((data) => data.json())
2019-01-14 20:58:23 +01:00
.then((data) => parseStatus(data))
}
const tagUser = ({ tag, credentials, user }) => {
const screenName = user.screen_name
2019-02-18 15:49:32 +01:00
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, user }) => {
const screenName = user.screen_name
2019-02-18 15:49:32 +01:00
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 }) => {
2019-02-18 15:49:32 +01:00
const screenName = user.screen_name
return fetch(PERMISSION_GROUP_URL(screenName, right), {
2019-02-18 15:49:32 +01:00
method: 'POST',
headers: authHeaders(credentials),
body: {}
})
}
const deleteRight = ({ right, credentials, user }) => {
2019-02-18 15:49:32 +01:00
const screenName = user.screen_name
return fetch(PERMISSION_GROUP_URL(screenName, right), {
2019-02-18 15:49:32 +01:00
method: 'DELETE',
headers: authHeaders(credentials),
body: {}
})
}
const activateUser = ({ credentials, user: { screen_name: nickname } }) => {
return promisedRequest({
url: ACTIVATE_USER_URL,
method: 'PATCH',
credentials,
payload: {
nicknames: [nickname]
}
}).then(response => get(response, 'users.0'))
}
2019-02-18 15:49:32 +01:00
const deactivateUser = ({ credentials, user: { screen_name: nickname } }) => {
return promisedRequest({
url: DEACTIVATE_USER_URL,
method: 'PATCH',
credentials,
payload: {
nicknames: [nickname]
}
}).then(response => get(response, 'users.0'))
2019-02-18 15:49:32 +01:00
}
const deleteUser = ({ credentials, user }) => {
2019-02-18 15:49:32 +01:00
const screenName = user.screen_name
const headers = authHeaders(credentials)
return fetch(`${ADMIN_USERS_URL}?nickname=${screenName}`, {
2019-02-18 15:49:32 +01:00
method: 'DELETE',
headers: headers
})
}
2019-06-18 22:28:31 +02:00
const fetchTimeline = ({
timeline,
credentials,
since = false,
until = false,
userId = false,
tag = false,
2020-05-01 16:26:07 +02:00
withMuted = false
2019-06-18 22:28:31 +02:00
}) => {
2016-10-28 14:26:51 +02:00
const timelineUrls = {
2019-03-07 19:16:35 +01:00
public: MASTODON_PUBLIC_TIMELINE,
friends: MASTODON_USER_HOME_TIMELINE_URL,
2019-03-07 19:21:07 +01:00
dms: MASTODON_DIRECT_MESSAGES_TIMELINE_URL,
2019-03-12 22:16:57 +01:00
notifications: MASTODON_USER_NOTIFICATIONS_URL,
2019-03-07 19:16:35 +01:00
'publicAndExternal': MASTODON_PUBLIC_TIMELINE,
2019-03-07 23:50:58 +01:00
user: MASTODON_USER_TIMELINE_URL,
media: MASTODON_USER_TIMELINE_URL,
favorites: MASTODON_USER_FAVORITES_TIMELINE_URL,
tag: MASTODON_TAG_TIMELINE_URL
2016-10-28 14:26:51 +02:00
}
const isNotifications = timeline === 'notifications'
const params = []
2016-10-28 14:26:51 +02:00
let url = timelineUrls[timeline]
2017-06-12 16:00:46 +02:00
2019-03-07 23:50:58 +01:00
if (timeline === 'user' || timeline === 'media') {
url = url(userId)
}
2016-10-28 14:26:51 +02:00
if (since) {
2017-06-12 16:20:02 +02:00
params.push(['since_id', since])
2016-10-28 14:26:51 +02:00
}
if (until) {
2017-06-12 16:20:02 +02:00
params.push(['max_id', until])
2017-06-12 16:00:46 +02:00
}
2017-09-17 13:26:35 +02:00
if (tag) {
url = url(tag)
2017-09-17 13:26:35 +02:00
}
if (timeline === 'media') {
params.push(['only_media', 1])
}
2019-03-07 19:16:35 +01:00
if (timeline === 'public') {
params.push(['local', true])
}
if (timeline === 'public' || timeline === 'publicAndExternal') {
params.push(['only_media', false])
}
if (timeline !== 'favorites') {
params.push(['with_muted', withMuted])
}
2016-10-28 14:26:51 +02:00
2020-04-13 13:26:55 +02:00
params.push(['limit', 20])
2017-06-12 17:35:04 +02:00
const queryString = map(params, (param) => `${param[0]}=${param[1]}`).join('&')
2017-06-12 16:00:46 +02:00
url += `?${queryString}`
2019-12-09 02:31:57 +01:00
let status = ''
let statusText = ''
return fetch(url, { headers: authHeaders(credentials) })
.then((data) => {
2019-12-09 02:31:57 +01:00
status = data.status
statusText = data.statusText
2019-12-09 01:02:34 +01:00
return data
})
.then((data) => data.json())
2019-12-05 03:48:37 +01:00
.then((data) => {
if (!data.error) {
return data.map(isNotifications ? parseNotification : parseStatus)
} else {
2019-12-09 02:31:57 +01:00
data.status = status
data.statusText = statusText
return data
}
})
2016-10-28 14:26:51 +02:00
}
const fetchPinnedStatuses = ({ id, credentials }) => {
const url = MASTODON_USER_TIMELINE_URL(id) + '?pinned=true'
2019-05-04 19:11:19 +02:00
return promisedRequest({ url, credentials })
.then((data) => data.map(parseStatus))
}
2016-10-28 14:26:51 +02:00
const verifyCredentials = (user) => {
2019-05-21 22:35:40 +02:00
return fetch(MASTODON_LOGIN_URL, {
2016-10-28 14:26:51 +02:00
headers: authHeaders(user)
})
2019-01-17 20:11:51 +01:00
.then((response) => {
if (response.ok) {
return response.json()
} else {
return {
error: response
}
}
})
2019-01-17 21:01:38 +01:00
.then((data) => data.error ? data : parseUser(data))
2016-10-28 14:26:51 +02:00
}
2016-10-30 16:12:35 +01:00
const favorite = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_FAVORITE_URL(id), method: 'POST', credentials })
.then((data) => parseStatus(data))
2016-10-30 16:12:35 +01:00
}
const unfavorite = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_UNFAVORITE_URL(id), method: 'POST', credentials })
.then((data) => parseStatus(data))
2016-10-30 16:12:35 +01:00
}
const retweet = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_RETWEET_URL(id), method: 'POST', credentials })
.then((data) => parseStatus(data))
}
2018-06-14 11:00:11 +02:00
const unretweet = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_UNRETWEET_URL(id), method: 'POST', credentials })
.then((data) => parseStatus(data))
2018-06-14 11:00:11 +02:00
}
2019-06-18 22:28:31 +02:00
const postStatus = ({
credentials,
status,
spoilerText,
visibility,
sensitive,
poll,
mediaIds = [],
inReplyToStatusId,
contentType
}) => {
2016-10-30 16:53:58 +01:00
const form = new FormData()
2019-06-18 22:28:31 +02:00
const pollOptions = poll.options || []
2016-10-30 16:53:58 +01:00
form.append('status', status)
form.append('source', 'Pleroma FE')
2018-06-07 11:03:50 +02:00
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)
2019-03-18 04:22:54 +01:00
mediaIds.forEach(val => {
form.append('media_ids[]', val)
})
2019-06-18 22:28:31 +02:00
if (pollOptions.some(option => option !== '')) {
const normalizedPoll = {
expires_in: poll.expiresIn,
multiple: poll.multiple
}
Object.keys(normalizedPoll).forEach(key => {
form.append(`poll[${key}]`, normalizedPoll[key])
})
pollOptions.forEach(option => {
form.append('poll[options][]', option)
})
}
2016-10-30 16:53:58 +01:00
if (inReplyToStatusId) {
form.append('in_reply_to_id', inReplyToStatusId)
2016-10-30 16:53:58 +01:00
}
return fetch(MASTODON_POST_STATUS_URL, {
2016-10-30 16:53:58 +01:00
body: form,
method: 'POST',
headers: authHeaders(credentials)
})
2019-01-17 21:01:38 +01:00
.then((response) => {
if (response.ok) {
return response.json()
} else {
return {
error: response
}
}
})
.then((data) => data.error ? data : parseStatus(data))
2016-10-30 16:53:58 +01:00
}
const deleteStatus = ({ id, credentials }) => {
return fetch(MASTODON_DELETE_URL(id), {
headers: authHeaders(credentials),
method: 'DELETE'
})
}
2019-06-18 22:28:31 +02:00
const uploadMedia = ({ formData, credentials }) => {
return fetch(MASTODON_MEDIA_UPLOAD_URL, {
2016-11-06 19:29:41 +01:00
body: formData,
method: 'POST',
headers: authHeaders(credentials)
})
2019-03-18 04:22:54 +01:00
.then((data) => data.json())
.then((data) => parseAttachment(data))
2016-11-06 19:29:41 +01:00
}
2019-06-18 22:28:31 +02:00
const importBlocks = ({ file, credentials }) => {
2019-03-30 12:27:53 +01:00
const formData = new FormData()
formData.append('list', file)
return fetch(BLOCKS_IMPORT_URL, {
body: formData,
method: 'POST',
headers: authHeaders(credentials)
})
.then((response) => response.ok)
}
2019-06-18 22:28:31 +02:00
const importFollows = ({ file, credentials }) => {
const formData = new FormData()
formData.append('list', file)
2017-12-23 15:44:22 +01:00
return fetch(FOLLOW_IMPORT_URL, {
body: formData,
2017-12-23 15:44:22 +01:00
method: 'POST',
headers: authHeaders(credentials)
})
.then((response) => response.ok)
}
2019-06-18 22:28:31 +02:00
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())
}
2019-11-08 03:21:19 +01:00
const changeEmail = ({ credentials, email, password }) => {
const form = new FormData()
form.append('email', email)
form.append('password', password)
return fetch(CHANGE_EMAIL_URL, {
body: form,
method: 'POST',
headers: authHeaders(credentials)
})
.then((response) => response.json())
}
2019-06-18 22:28:31 +02:00
const changePassword = ({ credentials, password, newPassword, newPasswordConfirmation }) => {
2018-05-22 00:01:09 +02:00
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())
}
2019-06-18 22:28:31 +02:00
const settingsMFA = ({ credentials }) => {
return fetch(MFA_SETTINGS_URL, {
headers: authHeaders(credentials),
method: 'GET'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const mfaDisableOTP = ({ credentials, password }) => {
const form = new FormData()
form.append('password', password)
return fetch(MFA_DISABLE_OTP_URL, {
body: form,
method: 'DELETE',
headers: authHeaders(credentials)
})
.then((response) => response.json())
}
2019-06-18 22:28:31 +02:00
const mfaConfirmOTP = ({ credentials, password, token }) => {
const form = new FormData()
form.append('password', password)
form.append('code', token)
return fetch(MFA_CONFIRM_OTP_URL, {
body: form,
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const mfaSetupOTP = ({ credentials }) => {
return fetch(MFA_SETUP_OTP_URL, {
headers: authHeaders(credentials),
method: 'GET'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const generateMfaBackupCodes = ({ credentials }) => {
return fetch(MFA_BACKUP_CODES_URL, {
headers: authHeaders(credentials),
method: 'GET'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const fetchMutes = ({ credentials }) => {
return promisedRequest({ url: MASTODON_USER_MUTES_URL, credentials })
2019-03-22 02:27:10 +01:00
.then((users) => users.map(parseUser))
}
2019-06-18 22:28:31 +02:00
const muteUser = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_MUTE_USER_URL(id), credentials, method: 'POST' })
}
2019-06-18 22:28:31 +02:00
const unmuteUser = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_UNMUTE_USER_URL(id), credentials, method: 'POST' })
2019-02-13 18:05:23 +01:00
}
const subscribeUser = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_SUBSCRIBE_USER(id), credentials, method: 'POST' })
}
const unsubscribeUser = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_UNSUBSCRIBE_USER(id), credentials, method: 'POST' })
}
2019-06-18 22:28:31 +02:00
const fetchBlocks = ({ credentials }) => {
return promisedRequest({ url: MASTODON_USER_BLOCKS_URL, credentials })
2019-03-22 02:27:10 +01:00
.then((users) => users.map(parseUser))
2019-02-13 18:05:23 +01:00
}
2019-06-18 22:28:31 +02:00
const fetchOAuthTokens = ({ credentials }) => {
const url = '/api/oauth_tokens.json'
return fetch(url, {
headers: authHeaders(credentials)
2019-03-21 17:04:57 +01:00
}).then((data) => {
if (data.ok) {
return data.json()
}
throw new Error('Error fetching auth tokens', data)
})
}
2019-06-18 22:28:31 +02:00
const revokeOAuthToken = ({ id, credentials }) => {
const url = `/api/oauth_tokens/${id}`
return fetch(url, {
headers: authHeaders(credentials),
method: 'DELETE'
})
}
2019-06-18 22:28:31 +02:00
const suggestions = ({ credentials }) => {
2018-08-02 11:34:12 +02:00
return fetch(SUGGESTIONS_URL, {
headers: authHeaders(credentials)
}).then((data) => data.json())
}
const markNotificationsAsSeen = ({ id, credentials, single = false }) => {
const body = new FormData()
if (single) {
body.append('id', id)
} else {
body.append('max_id', id)
}
return fetch(NOTIFICATION_READ_URL, {
body,
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 22:28:31 +02:00
const vote = ({ pollId, choices, credentials }) => {
const form = new FormData()
form.append('choices', choices)
return promisedRequest({
url: MASTODON_VOTE_URL(encodeURIComponent(pollId)),
method: 'POST',
credentials,
payload: {
choices: choices
}
})
}
const fetchPoll = ({ pollId, credentials }) => {
return promisedRequest(
{
url: MASTODON_POLL_URL(encodeURIComponent(pollId)),
method: 'GET',
credentials
}
)
}
const fetchFavoritedByUsers = ({ id, credentials }) => {
return promisedRequest({
url: MASTODON_STATUS_FAVORITEDBY_URL(id),
method: 'GET',
credentials
}).then((users) => users.map(parseUser))
2019-04-02 04:29:45 +02:00
}
const fetchRebloggedByUsers = ({ id, credentials }) => {
return promisedRequest({
url: MASTODON_STATUS_REBLOGGEDBY_URL(id),
method: 'GET',
credentials
}).then((users) => users.map(parseUser))
2019-04-02 04:29:45 +02:00
}
const fetchEmojiReactions = ({ id, credentials }) => {
return promisedRequest({ url: PLEROMA_EMOJI_REACTIONS_URL(id), credentials })
.then((reactions) => reactions.map(r => {
r.accounts = r.accounts.map(parseUser)
return r
}))
}
const reactWithEmoji = ({ id, emoji, credentials }) => {
return promisedRequest({
url: PLEROMA_EMOJI_REACT_URL(id, emoji),
method: 'PUT',
credentials
2020-01-27 17:43:26 +01:00
}).then(parseStatus)
}
const unreactWithEmoji = ({ id, emoji, credentials }) => {
return promisedRequest({
url: PLEROMA_EMOJI_UNREACT_URL(id, emoji),
method: 'DELETE',
credentials
}).then(parseStatus)
}
2019-06-18 22:28:31 +02:00
const reportUser = ({ credentials, userId, statusIds, comment, forward }) => {
2019-03-20 16:54:16 +01:00
return promisedRequest({
url: MASTODON_REPORT_USER_URL,
2019-03-20 16:54:16 +01:00
method: 'POST',
payload: {
'account_id': userId,
'status_ids': statusIds,
comment,
forward
2019-03-20 16:45:19 +01:00
},
2019-03-20 16:54:16 +01:00
credentials
})
2019-03-20 16:45:19 +01:00
}
2020-05-13 17:04:30 +02:00
const searchUsers = ({ credentials, query }) => {
return promisedRequest({
url: MASTODON_USER_SEARCH_URL,
params: {
q: query,
2020-05-13 17:04:30 +02:00
resolve: true
},
credentials
})
.then((data) => data.map(parseUser))
}
2019-07-15 18:42:27 +02:00
const search2 = ({ credentials, q, resolve, limit, offset, following }) => {
let url = MASTODON_SEARCH_2
let params = []
if (q) {
params.push(['q', encodeURIComponent(q)])
}
if (resolve) {
params.push(['resolve', resolve])
}
if (limit) {
params.push(['limit', limit])
}
if (offset) {
params.push(['offset', offset])
}
if (following) {
params.push(['following', true])
}
2020-05-13 16:48:31 +02:00
params.push(['with_relationships', true])
2019-07-15 18:42:27 +02:00
let 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 search result', data)
})
.then((data) => { return data.json() })
.then((data) => {
data.accounts = data.accounts.slice(0, limit).map(u => parseUser(u))
data.statuses = data.statuses.slice(0, limit).map(s => parseStatus(s))
return data
})
}
const fetchKnownDomains = ({ credentials }) => {
return promisedRequest({ url: MASTODON_KNOWN_DOMAIN_LIST_URL, credentials })
}
2020-01-15 21:22:54 +01:00
const fetchDomainMutes = ({ credentials }) => {
return promisedRequest({ url: MASTODON_DOMAIN_BLOCKS_URL, credentials })
}
const muteDomain = ({ domain, credentials }) => {
return promisedRequest({
url: MASTODON_DOMAIN_BLOCKS_URL,
method: 'POST',
payload: { domain },
credentials
})
}
const unmuteDomain = ({ domain, credentials }) => {
return promisedRequest({
url: MASTODON_DOMAIN_BLOCKS_URL,
method: 'DELETE',
payload: { domain },
credentials
})
}
const dismissNotification = ({ credentials, id }) => {
return promisedRequest({
url: MASTODON_DISMISS_NOTIFICATION_URL(id),
method: 'POST',
payload: { id },
credentials
})
}
2019-11-24 17:50:28 +01:00
export const getMastodonSocketURI = ({ credentials, stream, args = {} }) => {
return Object.entries({
...(credentials
? { access_token: credentials }
: {}
),
stream,
...args
}).reduce((acc, [key, val]) => {
return acc + `${key}=${val}&`
}, MASTODON_STREAMING + '?')
}
const MASTODON_STREAMING_EVENTS = new Set([
'update',
'notification',
'delete',
'filters_changed'
])
2019-12-08 18:18:38 +01:00
// A thin wrapper around WebSocket API that allows adding a pre-processor to it
// Uses EventTarget and a CustomEvent to proxy events
export const ProcessedWS = ({
url,
preprocessor = handleMastoWS,
id = 'Unknown'
}) => {
const eventTarget = new EventTarget()
const socket = new WebSocket(url)
if (!socket) throw new Error(`Failed to create socket ${id}`)
const proxy = (original, eventName, processor = a => a) => {
original.addEventListener(eventName, (eventData) => {
eventTarget.dispatchEvent(new CustomEvent(
eventName,
{ detail: processor(eventData) }
))
})
}
socket.addEventListener('open', (wsEvent) => {
console.debug(`[WS][${id}] Socket connected`, wsEvent)
})
socket.addEventListener('error', (wsEvent) => {
console.debug(`[WS][${id}] Socket errored`, wsEvent)
})
socket.addEventListener('close', (wsEvent) => {
console.debug(
`[WS][${id}] Socket disconnected with code ${wsEvent.code}`,
wsEvent
)
})
2019-12-10 20:30:27 +01:00
// Commented code reason: very spammy, uncomment to enable message debug logging
/*
2019-12-08 18:18:38 +01:00
socket.addEventListener('message', (wsEvent) => {
console.debug(
`[WS][${id}] Message received`,
wsEvent
)
})
2019-12-10 20:30:27 +01:00
/**/
2019-12-08 18:18:38 +01:00
proxy(socket, 'open')
proxy(socket, 'close')
proxy(socket, 'message', preprocessor)
proxy(socket, 'error')
2019-12-10 20:30:27 +01:00
// 1000 = Normal Closure
eventTarget.close = () => { socket.close(1000, 'Shutting down socket') }
2019-12-08 18:18:38 +01:00
return eventTarget
}
2019-11-24 17:50:28 +01:00
export const handleMastoWS = (wsEvent) => {
const { data } = wsEvent
if (!data) return
const parsedEvent = JSON.parse(data)
const { event, payload } = parsedEvent
if (MASTODON_STREAMING_EVENTS.has(event)) {
2019-12-11 17:20:43 +01:00
// MastoBE and PleromaBE both send payload for delete as a PLAIN string
if (event === 'delete') {
return { event, id: payload }
}
2019-11-24 17:50:28 +01:00
const data = payload ? JSON.parse(payload) : null
if (event === 'update') {
return { event, status: parseStatus(data) }
} else if (event === 'notification') {
return { event, notification: parseNotification(data) }
}
} else {
console.warn('Unknown event', wsEvent)
return null
}
}
2016-10-28 14:26:51 +02:00
const apiService = {
verifyCredentials,
2016-10-30 16:12:35 +01:00
fetchTimeline,
fetchPinnedStatuses,
fetchConversation,
fetchStatus,
2016-11-30 21:27:25 +01:00
fetchFriends,
exportFriends,
2017-08-21 19:25:01 +02:00
fetchFollowers,
2016-12-08 09:09:21 +01:00
followUser,
2016-12-23 16:45:57 +01:00
unfollowUser,
2019-04-04 17:27:02 +02:00
pinOwnStatus,
unpinOwnStatus,
muteConversation,
unmuteConversation,
2017-11-07 21:38:28 +01:00
blockUser,
unblockUser,
fetchUser,
fetchUserRelationship,
2016-10-30 16:12:35 +01:00
favorite,
2016-10-30 16:53:58 +01:00
unfavorite,
retweet,
2018-06-14 11:00:11 +02:00
unretweet,
2016-11-06 19:29:41 +01:00
postStatus,
deleteStatus,
2017-02-13 22:55:38 +01:00
uploadMedia,
2017-04-15 18:12:23 +02:00
fetchMutes,
muteUser,
unmuteUser,
subscribeUser,
unsubscribeUser,
2019-02-13 18:05:23 +01:00
fetchBlocks,
fetchOAuthTokens,
revokeOAuthToken,
2019-02-18 15:49:32 +01:00
tagUser,
untagUser,
deleteUser,
addRight,
deleteRight,
activateUser,
deactivateUser,
2017-04-16 13:44:11 +02:00
register,
getCaptcha,
2017-06-19 10:32:40 +02:00
updateAvatar,
updateBg,
updateProfile,
updateBanner,
2019-03-30 12:27:53 +01:00
importBlocks,
2019-03-30 12:22:30 +01:00
importFollows,
2018-05-22 00:01:09 +02:00
deleteAccount,
2019-11-08 03:21:19 +01:00
changeEmail,
2018-06-07 00:26:24 +02:00
changePassword,
settingsMFA,
mfaDisableOTP,
generateMfaBackupCodes,
mfaSetupOTP,
mfaConfirmOTP,
fetchFollowRequests,
approveUser,
2018-08-02 11:34:12 +02:00
denyUser,
suggestions,
2019-04-02 04:30:06 +02:00
markNotificationsAsSeen,
dismissNotification,
2019-06-18 22:28:31 +02:00
vote,
fetchPoll,
2019-04-02 18:13:55 +02:00
fetchFavoritedByUsers,
2019-03-20 16:45:19 +01:00
fetchRebloggedByUsers,
fetchEmojiReactions,
reactWithEmoji,
unreactWithEmoji,
2019-05-25 09:01:02 +02:00
reportUser,
updateNotificationSettings,
search2,
2020-01-15 21:22:54 +01:00
searchUsers,
fetchKnownDomains,
2020-01-15 21:22:54 +01:00
fetchDomainMutes,
muteDomain,
unmuteDomain
2016-10-27 18:03:14 +02:00
}
export default apiService