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

1563 lines
41 KiB
JavaScript
Raw Normal View History

import { each, map, concat, last, get } from 'lodash'
2020-05-07 13:10:53 +00:00
import { parseStatus, parseUser, parseNotification, parseAttachment, parseChat, parseLinkHeaderPagination } from '../entity_normalizer/entity_normalizer.service.js'
import { RegistrationError, StatusCodeError } from '../errors/errors'
2019-06-18 20:28:31 +00:00
2016-10-27 16:03:14 +00:00
/* eslint-env browser */
2020-09-07 11:27:37 +00:00
const MUTES_IMPORT_URL = '/api/pleroma/mutes_import'
2019-03-30 11:27:53 +00:00
const BLOCKS_IMPORT_URL = '/api/pleroma/blocks_import'
2017-12-23 14:44:22 +00:00
const FOLLOW_IMPORT_URL = '/api/pleroma/follow_import'
const DELETE_ACCOUNT_URL = '/api/pleroma/delete_account'
2019-11-08 02:21:19 +00:00
const CHANGE_EMAIL_URL = '/api/pleroma/change_email'
2018-05-21 22:01:09 +00:00
const CHANGE_PASSWORD_URL = '/api/pleroma/change_password'
const MOVE_ACCOUNT_URL = '/api/pleroma/move_account'
const ALIASES_URL = '/api/pleroma/aliases'
2019-02-18 14:49:32 +00:00
const TAG_USER_URL = '/api/pleroma/admin/users/tag'
2019-05-16 18:02:37 +00: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 09:34:12 +00:00
const SUGGESTIONS_URL = '/api/v1/suggestions'
2019-05-25 07:01:02 +00:00
const NOTIFICATION_SETTINGS_URL = '/api/pleroma/notification_settings'
const NOTIFICATION_READ_URL = '/api/v1/pleroma/notifications/read'
2016-10-27 16:03:14 +00: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 12:59:29 +00:00
const MFA_DISABLE_OTP_URL = '/api/pleroma/accounts/mfa/totp'
2019-05-21 20:35:40 +00: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 21:16:57 +00: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 10:38:52 +00: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 18:21:07 +00:00
const MASTODON_DIRECT_MESSAGES_TIMELINE_URL = '/api/v1/timelines/direct'
2019-03-07 18:16:35 +00: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 = id => `/api/v1/accounts/${id}?with_relationships=true`
const MASTODON_USER_RELATIONSHIPS_URL = '/api/v1/accounts/relationships'
2019-03-07 22:50:58 +00:00
const MASTODON_USER_TIMELINE_URL = id => `/api/v1/accounts/${id}/statuses`
2022-06-16 02:41:43 +00:00
const MASTODON_LIST_URL = id => `/api/v1/lists/${id}`
const MASTODON_LIST_TIMELINE_URL = id => `/api/v1/timelines/list/${id}`
2022-06-15 22:52:24 +00:00
const MASTODON_LIST_ACCOUNTS_URL = id => `/api/v1/lists/${id}/accounts`
const MASTODON_TAG_TIMELINE_URL = tag => `/api/v1/timelines/tag/${tag}`
const MASTODON_BOOKMARK_TIMELINE_URL = '/api/v1/bookmarks'
2019-03-22 01:27:10 +00:00
const MASTODON_USER_BLOCKS_URL = '/api/v1/blocks/'
const MASTODON_USER_MUTES_URL = '/api/v1/mutes/'
2019-03-22 01:44:59 +00: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 01:53:24 +00: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`
2022-06-22 15:46:47 +00:00
const MASTODON_SET_NOTE_URL = id => `/api/v1/accounts/${id}/note`
const MASTODON_BOOKMARK_STATUS_URL = id => `/api/v1/statuses/${id}/bookmark`
const MASTODON_UNBOOKMARK_STATUS_URL = id => `/api/v1/statuses/${id}/unbookmark`
const MASTODON_POST_STATUS_URL = '/api/v1/statuses'
const MASTODON_MEDIA_UPLOAD_URL = '/api/v1/media'
2019-06-18 20:28:31 +00:00
const MASTODON_VOTE_URL = id => `/api/v1/polls/${id}/votes`
const MASTODON_POLL_URL = id => `/api/v1/polls/${id}`
2019-04-02 16:13:55 +00:00
const MASTODON_STATUS_FAVORITEDBY_URL = id => `/api/v1/statuses/${id}/favourited_by`
2019-04-02 02:30:06 +00: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 02:40:37 +00:00
const MASTODON_REPORT_USER_URL = '/api/v1/reports'
2019-04-04 15:27:02 +00: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 16:42:27 +00:00
const MASTODON_SEARCH_2 = `/api/v2/search`
const MASTODON_USER_SEARCH_URL = '/api/v1/accounts/search'
2020-05-08 13:38:46 +00:00
const MASTODON_MASCOT_URL = '/api/v1/pleroma/mascot'
2020-01-15 20:22:54 +00:00
const MASTODON_DOMAIN_BLOCKS_URL = '/api/v1/domain_blocks'
2022-06-15 15:34:11 +00:00
const MASTODON_LISTS_URL = '/api/v1/lists'
2019-11-24 16:50:28 +00: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}`
2020-05-07 13:10:53 +00:00
const PLEROMA_CHATS_URL = `/api/v1/pleroma/chats`
const PLEROMA_CHAT_URL = id => `/api/v1/pleroma/chats/by-account-id/${id}`
const PLEROMA_CHAT_MESSAGES_URL = id => `/api/v1/pleroma/chats/${id}/messages`
const PLEROMA_CHAT_READ_URL = id => `/api/v1/pleroma/chats/${id}/read`
const PLEROMA_DELETE_CHAT_MESSAGE_URL = (chatId, messageId) => `/api/v1/pleroma/chats/${chatId}/messages/${messageId}`
const oldfetch = window.fetch
2016-10-27 16:03:14 +00:00
2016-11-22 14:45:40 +00:00
let fetch = (url, options) => {
options = options || {}
2016-11-22 14:45:40 +00:00
const baseUrl = ''
const fullUrl = baseUrl + url
options.credentials = 'same-origin'
return oldfetch(fullUrl, options)
2016-11-22 14:45:40 +00: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)
2020-10-29 10:33:06 +00:00
})
.catch((error) => {
return reject(new StatusCodeError(response.status, error, { url, options }, response))
})
)
})
}
2019-06-18 20:28:31 +00:00
const updateNotificationSettings = ({ credentials, settings }) => {
2019-05-25 07:01:02 +00: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 20:28:31 +00:00
}).then((data) => data.json())
2019-05-25 07:01:02 +00:00
}
const updateProfileImages = ({ credentials, avatar = null, avatarName = null, banner = null, background = null }) => {
2017-04-16 11:44:11 +00:00
const form = new FormData()
if (avatar !== null) {
if (avatarName !== null) {
form.append('avatar', avatar, avatarName)
} else {
form.append('avatar', avatar)
}
}
if (banner !== null) form.append('header', banner)
if (background !== null) form.append('pleroma_background_image', background)
return fetch(MASTODON_PROFILE_UPDATE_URL, {
headers: authHeaders(credentials),
method: 'PATCH',
body: form
})
.then((data) => data.json())
2020-12-02 10:46:31 +00:00
.then((data) => {
if (data.error) {
throw new Error(data.error)
}
return parseUser(data)
})
}
2019-06-18 20:28:31 +00:00
const updateProfile = ({ credentials, params }) => {
2019-04-30 20:38:34 +00:00
return promisedRequest({
url: MASTODON_PROFILE_UPDATE_URL,
method: 'PATCH',
2019-04-30 20:38:34 +00:00
payload: params,
credentials
2019-06-18 20:28:31 +00:00
}).then((data) => parseUser(data))
}
2017-04-15 16:12:23 +00:00
// Params needed:
// nickname
// email
// fullname
// password
// password_confirm
//
// Optional
// bio
// homepage
// location
2018-08-05 07:01:38 +00:00
// token
// language
const register = ({ params, credentials }) => {
const { nickname, ...rest } = params
return fetch(MASTODON_REGISTRATION_URL, {
2017-04-15 16:12:23 +00:00
method: 'POST',
headers: {
...authHeaders(credentials),
'Content-Type': 'application/json'
},
body: JSON.stringify({
nickname,
2019-06-12 21:47:06 +00:00
locale: 'en_US',
agreement: true,
...rest
})
2017-04-15 16:12:23 +00:00
})
.then((response) => {
if (response.ok) {
return response.json()
} else {
return response.json().then((error) => { throw new RegistrationError(error) })
}
})
2017-04-15 16:12:23 +00:00
}
const getCaptcha = () => fetch('/api/pleroma/captcha').then(resp => resp.json())
2018-10-26 13:16:23 +00:00
const authHeaders = (accessToken) => {
if (accessToken) {
return { 'Authorization': `Bearer ${accessToken}` }
} else {
return { }
}
}
2016-10-28 12:26:51 +00:00
2019-10-08 07:21:48 +00:00
const followUser = ({ id, credentials, ...options }) => {
let url = MASTODON_FOLLOW_URL(id)
2019-10-08 07:21:48 +00:00
const form = {}
if (options.reblogs !== undefined) { form['reblogs'] = options.reblogs }
2016-12-08 08:09:21 +00:00
return fetch(url, {
2019-10-08 07:21:48 +00:00
body: JSON.stringify(form),
headers: {
...authHeaders(credentials),
'Content-Type': 'application/json'
},
2016-12-08 08:09:21 +00:00
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 20:28:31 +00:00
const unfollowUser = ({ id, credentials }) => {
let url = MASTODON_UNFOLLOW_URL(id)
2016-12-23 15:45:57 +00:00
return fetch(url, {
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-04-04 15:27:02 +00:00
const pinOwnStatus = ({ id, credentials }) => {
2019-05-04 17:11:19 +00:00
return promisedRequest({ url: MASTODON_PIN_OWN_STATUS(id), credentials, method: 'POST' })
.then((data) => parseStatus(data))
2019-04-04 15:27:02 +00:00
}
const unpinOwnStatus = ({ id, credentials }) => {
2019-05-04 17:11:19 +00:00
return promisedRequest({ url: MASTODON_UNPIN_OWN_STATUS(id), credentials, method: 'POST' })
.then((data) => parseStatus(data))
2019-04-04 15:27:02 +00: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 20:28:31 +00:00
const blockUser = ({ id, credentials }) => {
2019-03-22 01:44:59 +00:00
return fetch(MASTODON_BLOCK_USER_URL(id), {
2017-11-07 20:38:28 +00:00
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 20:28:31 +00:00
const unblockUser = ({ id, credentials }) => {
2019-03-22 01:44:59 +00:00
return fetch(MASTODON_UNBLOCK_USER_URL(id), {
2017-11-07 20:38:28 +00:00
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 20:28:31 +00:00
const approveUser = ({ id, credentials }) => {
2019-09-03 10:38:52 +00:00
let url = MASTODON_APPROVE_USER_URL(id)
return fetch(url, {
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 20:28:31 +00:00
const denyUser = ({ id, credentials }) => {
2019-09-03 10:38:52 +00:00
let url = MASTODON_DENY_USER_URL(id)
return fetch(url, {
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2019-06-18 20:28:31 +00:00
const fetchUser = ({ id, credentials }) => {
const url = MASTODON_USER_URL(id)
return promisedRequest({ url, credentials })
2019-01-14 12:30:14 +00:00
.then((data) => parseUser(data))
}
2019-06-18 20:28:31 +00: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 20:28:31 +00:00
const fetchFriends = ({ id, maxId, sinceId, limit = 20, credentials }) => {
let url = MASTODON_FOLLOWING_URL(id)
2019-03-25 19:04:52 +00:00
const args = [
maxId && `max_id=${maxId}`,
2019-03-27 20:02:46 +00:00
sinceId && `since_id=${sinceId}`,
2020-05-13 14:48:31 +00:00
limit && `limit=${limit}`,
`with_relationships=true`
2019-03-25 19:04:52 +00: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 20:28:31 +00:00
const exportFriends = ({ id, credentials }) => {
2019-04-19 04:27:06 +00: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 07:02:14 +00:00
const users = await fetchFriends({ id, maxId, credentials })
2019-04-19 04:27:06 +00:00
friends = concat(friends, users)
if (users.length === 0) {
more = false
}
}
resolve(friends)
} catch (err) {
reject(err)
}
})
2017-08-21 17:25:01 +00:00
}
2019-06-18 20:28:31 +00:00
const fetchFollowers = ({ id, maxId, sinceId, limit = 20, credentials }) => {
let url = MASTODON_FOLLOWERS_URL(id)
2019-03-25 19:04:52 +00:00
const args = [
maxId && `max_id=${maxId}`,
2019-03-27 20:02:46 +00:00
sinceId && `since_id=${sinceId}`,
2020-05-13 14:48:31 +00:00
limit && `limit=${limit}`,
`with_relationships=true`
2019-03-25 19:04:52 +00:00
].filter(_ => _).join('&')
2019-03-27 20:02:46 +00:00
url += args ? '?' + args : ''
2017-08-21 17:25:01 +00:00
return fetch(url, { headers: authHeaders(credentials) })
2016-11-30 20:27:25 +00:00
.then((data) => data.json())
2019-01-14 12:30:14 +00:00
.then((data) => data.map(parseUser))
2016-11-30 20:27:25 +00:00
}
2019-06-18 20:28:31 +00:00
const fetchFollowRequests = ({ credentials }) => {
2019-09-03 10:38:52 +00:00
const url = MASTODON_FOLLOW_REQUESTS_URL
2018-06-06 22:26:24 +00:00
return fetch(url, { headers: authHeaders(credentials) })
.then((data) => data.json())
2019-09-03 10:38:52 +00:00
.then((data) => data.map(parseUser))
2018-06-06 22:26:24 +00:00
}
2022-06-15 15:34:11 +00:00
const fetchLists = ({ credentials }) => {
const url = MASTODON_LISTS_URL
return fetch(url, { headers: authHeaders(credentials) })
.then((data) => data.json())
}
2022-06-15 22:52:24 +00:00
const createList = ({ title, credentials }) => {
const url = MASTODON_LISTS_URL
const headers = authHeaders(credentials)
headers['Content-Type'] = 'application/json'
return fetch(url, {
method: 'POST',
headers: headers,
body: JSON.stringify({ title })
}).then((data) => data.json())
}
2022-06-16 02:41:43 +00:00
const getList = ({ id, credentials }) => {
const url = MASTODON_LIST_URL(id)
return fetch(url, { headers: authHeaders(credentials) })
.then((data) => data.json())
}
const updateList = ({ id, title, credentials }) => {
const url = MASTODON_LIST_URL(id)
const headers = authHeaders(credentials)
headers['Content-Type'] = 'application/json'
return fetch(url, {
method: 'PUT',
headers: headers,
body: JSON.stringify({ title })
})
}
const getListAccounts = ({ id, credentials }) => {
const url = MASTODON_LIST_ACCOUNTS_URL(id)
return fetch(url, { headers: authHeaders(credentials) })
.then((data) => data.json())
.then((data) => data.map(({ id }) => id))
}
2022-06-15 22:52:24 +00:00
const addAccountsToList = ({ id, accountIds, credentials }) => {
const url = MASTODON_LIST_ACCOUNTS_URL(id)
const headers = authHeaders(credentials)
headers['Content-Type'] = 'application/json'
return fetch(url, {
method: 'POST',
headers: headers,
body: JSON.stringify({ account_ids: accountIds })
})
}
2022-06-16 07:04:33 +00:00
const removeAccountsFromList = ({ id, accountIds, credentials }) => {
const url = MASTODON_LIST_ACCOUNTS_URL(id)
const headers = authHeaders(credentials)
headers['Content-Type'] = 'application/json'
return fetch(url, {
method: 'DELETE',
headers: headers,
body: JSON.stringify({ account_ids: accountIds })
})
}
2022-06-16 02:41:43 +00:00
const deleteList = ({ id, credentials }) => {
const url = MASTODON_LIST_URL(id)
return fetch(url, {
method: 'DELETE',
headers: authHeaders(credentials)
})
}
const errorStatusMapper = (response) => {
console.log(response)
switch (response.status) {
case 429:
return 'You are rate limited'
case 500:
return 'Internal Server Error'
case 503:
return 'The backend is not available'
default:
return `Unexpected status: ${response.status}`
}
}
2019-06-18 20:28:31 +00:00
const fetchConversation = ({ id, credentials }) => {
let urlContext = MASTODON_STATUS_CONTEXT_URL(id)
return fetch(urlContext, { headers: authHeaders(credentials) })
2019-01-14 19:58:23 +00:00
.then((data) => {
if (data.ok) {
return data
}
throw new Error('Error fetching timeline', errorStatusMapper(data))
2019-01-14 19:58:23 +00:00
})
2019-01-17 20:22:51 +00:00
.then((data) => data.json())
2019-06-18 20:28:31 +00:00
.then(({ ancestors, descendants }) => ({
ancestors: ancestors.map(parseStatus),
descendants: descendants.map(parseStatus)
}))
}
2019-06-18 20:28:31 +00:00
const fetchStatus = ({ id, credentials }) => {
let url = MASTODON_STATUS_URL(id)
return fetch(url, { headers: authHeaders(credentials) })
2019-01-14 19:58:23 +00:00
.then((data) => {
if (data.ok) {
return data
}
throw new Error('Error fetching timeline', errorStatusMapper(data))
2019-01-14 19:58:23 +00:00
})
2019-01-17 20:22:51 +00:00
.then((data) => data.json())
2019-01-14 19:58:23 +00:00
.then((data) => parseStatus(data))
}
const tagUser = ({ tag, credentials, user }) => {
const screenName = user.screen_name
2019-02-18 14:49:32 +00: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 14:49:32 +00: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 14:49:32 +00:00
const screenName = user.screen_name
return fetch(PERMISSION_GROUP_URL(screenName, right), {
2019-02-18 14:49:32 +00:00
method: 'POST',
headers: authHeaders(credentials),
body: {}
})
}
const deleteRight = ({ right, credentials, user }) => {
2019-02-18 14:49:32 +00:00
const screenName = user.screen_name
return fetch(PERMISSION_GROUP_URL(screenName, right), {
2019-02-18 14:49:32 +00: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 14:49:32 +00: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 14:49:32 +00:00
}
const deleteUser = ({ credentials, user }) => {
2019-02-18 14:49:32 +00:00
const screenName = user.screen_name
const headers = authHeaders(credentials)
return fetch(`${ADMIN_USERS_URL}?nickname=${screenName}`, {
2019-02-18 14:49:32 +00:00
method: 'DELETE',
headers: headers
})
}
2019-06-18 20:28:31 +00:00
const fetchTimeline = ({
timeline,
credentials,
since = false,
until = false,
userId = false,
listId = false,
2019-06-18 20:28:31 +00:00
tag = false,
2020-06-30 14:02:38 +00:00
withMuted = false,
replyVisibility = 'all'
2019-06-18 20:28:31 +00:00
}) => {
2016-10-28 12:26:51 +00:00
const timelineUrls = {
2019-03-07 18:16:35 +00:00
public: MASTODON_PUBLIC_TIMELINE,
friends: MASTODON_USER_HOME_TIMELINE_URL,
2019-03-07 18:21:07 +00:00
dms: MASTODON_DIRECT_MESSAGES_TIMELINE_URL,
2019-03-12 21:16:57 +00:00
notifications: MASTODON_USER_NOTIFICATIONS_URL,
2019-03-07 18:16:35 +00:00
'publicAndExternal': MASTODON_PUBLIC_TIMELINE,
2019-03-07 22:50:58 +00:00
user: MASTODON_USER_TIMELINE_URL,
media: MASTODON_USER_TIMELINE_URL,
list: MASTODON_LIST_TIMELINE_URL,
favorites: MASTODON_USER_FAVORITES_TIMELINE_URL,
tag: MASTODON_TAG_TIMELINE_URL,
bookmarks: MASTODON_BOOKMARK_TIMELINE_URL
2016-10-28 12:26:51 +00:00
}
const isNotifications = timeline === 'notifications'
const params = []
2016-10-28 12:26:51 +00:00
let url = timelineUrls[timeline]
2017-06-12 14:00:46 +00:00
2019-03-07 22:50:58 +00:00
if (timeline === 'user' || timeline === 'media') {
url = url(userId)
}
if (timeline === 'list') {
url = url(listId)
}
2016-10-28 12:26:51 +00:00
if (since) {
2017-06-12 14:20:02 +00:00
params.push(['since_id', since])
2016-10-28 12:26:51 +00:00
}
if (until) {
2017-06-12 14:20:02 +00:00
params.push(['max_id', until])
2017-06-12 14:00:46 +00:00
}
2017-09-17 11:26:35 +00:00
if (tag) {
url = url(tag)
2017-09-17 11:26:35 +00:00
}
if (timeline === 'media') {
params.push(['only_media', 1])
}
2019-03-07 18:16:35 +00:00
if (timeline === 'public') {
params.push(['local', true])
}
if (timeline === 'public' || timeline === 'publicAndExternal') {
params.push(['only_media', false])
}
if (timeline !== 'favorites' && timeline !== 'bookmarks') {
params.push(['with_muted', withMuted])
}
2020-06-30 14:02:38 +00:00
if (replyVisibility !== 'all') {
params.push(['reply_visibility', replyVisibility])
}
2016-10-28 12:26:51 +00:00
2020-04-13 11:26:55 +00:00
params.push(['limit', 20])
2017-06-12 15:35:04 +00:00
const queryString = map(params, (param) => `${param[0]}=${param[1]}`).join('&')
2017-06-12 14:00:46 +00:00
url += `?${queryString}`
2020-09-29 10:18:37 +00:00
2019-12-09 01:31:57 +00:00
let status = ''
let statusText = ''
2020-09-29 10:18:37 +00:00
let pagination = {}
return fetch(url, { headers: authHeaders(credentials) })
.then((data) => {
2019-12-09 01:31:57 +00:00
status = data.status
statusText = data.statusText
pagination = parseLinkHeaderPagination(data.headers.get('Link'), {
flakeId: timeline !== 'bookmarks' && timeline !== 'notifications'
})
2019-12-09 00:02:34 +00:00
return data
})
2019-12-05 02:48:37 +00:00
.then((data) => {
if (data.ok) return data.json()
throw new Error(errorStatusMapper(data))
})
.then((data) => {
if (data.error) {
throw new Error(data.error)
}
2020-11-10 10:52:54 +00:00
if (!data.errors) {
return { data: data.map(isNotifications ? parseNotification : parseStatus), pagination }
2019-12-05 02:48:37 +00:00
} else {
2019-12-09 01:31:57 +00:00
data.status = status
data.statusText = statusText
return data
}
})
2016-10-28 12:26:51 +00:00
}
const fetchPinnedStatuses = ({ id, credentials }) => {
const url = MASTODON_USER_TIMELINE_URL(id) + '?pinned=true'
2019-05-04 17:11:19 +00:00
return promisedRequest({ url, credentials })
.then((data) => data.map(parseStatus))
}
2016-10-28 12:26:51 +00:00
const verifyCredentials = (user) => {
2019-05-21 20:35:40 +00:00
return fetch(MASTODON_LOGIN_URL, {
2016-10-28 12:26:51 +00:00
headers: authHeaders(user)
})
2019-01-17 19:11:51 +00:00
.then((response) => {
if (response.ok) {
return response.json()
} else {
return {
error: response
}
}
})
2019-01-17 20:01:38 +00:00
.then((data) => data.error ? data : parseUser(data))
2016-10-28 12:26:51 +00:00
}
2016-10-30 15:12:35 +00:00
const favorite = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_FAVORITE_URL(id), method: 'POST', credentials })
.then((data) => parseStatus(data))
2016-10-30 15:12:35 +00:00
}
const unfavorite = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_UNFAVORITE_URL(id), method: 'POST', credentials })
.then((data) => parseStatus(data))
2016-10-30 15:12:35 +00:00
}
const retweet = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_RETWEET_URL(id), method: 'POST', credentials })
.then((data) => parseStatus(data))
}
2018-06-14 09:00:11 +00:00
const unretweet = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_UNRETWEET_URL(id), method: 'POST', credentials })
.then((data) => parseStatus(data))
2018-06-14 09:00:11 +00:00
}
const bookmarkStatus = ({ id, credentials }) => {
return promisedRequest({
url: MASTODON_BOOKMARK_STATUS_URL(id),
headers: authHeaders(credentials),
method: 'POST'
})
}
const unbookmarkStatus = ({ id, credentials }) => {
return promisedRequest({
url: MASTODON_UNBOOKMARK_STATUS_URL(id),
headers: authHeaders(credentials),
method: 'POST'
})
}
2019-06-18 20:28:31 +00:00
const postStatus = ({
credentials,
status,
spoilerText,
visibility,
sensitive,
poll,
mediaIds = [],
inReplyToStatusId,
2020-06-28 09:16:41 +00:00
contentType,
2020-07-15 13:19:57 +00:00
preview,
idempotencyKey
2019-06-18 20:28:31 +00:00
}) => {
2016-10-30 15:53:58 +00:00
const form = new FormData()
2019-06-18 20:28:31 +00:00
const pollOptions = poll.options || []
2016-10-30 15:53:58 +00:00
form.append('status', status)
form.append('source', 'Pleroma FE')
2018-06-07 09:03:50 +00: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 03:22:54 +00:00
mediaIds.forEach(val => {
form.append('media_ids[]', val)
})
2019-06-18 20:28:31 +00: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 15:53:58 +00:00
if (inReplyToStatusId) {
form.append('in_reply_to_id', inReplyToStatusId)
2016-10-30 15:53:58 +00:00
}
2020-06-28 09:16:41 +00:00
if (preview) {
form.append('preview', 'true')
}
2016-10-30 15:53:58 +00:00
2020-07-15 13:19:57 +00:00
let postHeaders = authHeaders(credentials)
if (idempotencyKey) {
postHeaders['idempotency-key'] = idempotencyKey
}
return fetch(MASTODON_POST_STATUS_URL, {
2016-10-30 15:53:58 +00:00
body: form,
method: 'POST',
2020-07-15 13:19:57 +00:00
headers: postHeaders
2016-10-30 15:53:58 +00:00
})
2019-01-17 20:01:38 +00:00
.then((response) => {
2020-06-28 09:16:41 +00:00
return response.json()
2019-01-17 20:01:38 +00:00
})
.then((data) => data.error ? data : parseStatus(data))
2016-10-30 15:53:58 +00:00
}
const deleteStatus = ({ id, credentials }) => {
return fetch(MASTODON_DELETE_URL(id), {
headers: authHeaders(credentials),
method: 'DELETE'
})
}
2019-06-18 20:28:31 +00:00
const uploadMedia = ({ formData, credentials }) => {
return fetch(MASTODON_MEDIA_UPLOAD_URL, {
2016-11-06 18:29:41 +00:00
body: formData,
method: 'POST',
headers: authHeaders(credentials)
})
2019-03-18 03:22:54 +00:00
.then((data) => data.json())
.then((data) => parseAttachment(data))
2016-11-06 18:29:41 +00:00
}
2020-07-07 06:07:20 +00:00
const setMediaDescription = ({ id, description, credentials }) => {
return promisedRequest({
url: `${MASTODON_MEDIA_UPLOAD_URL}/${id}`,
method: 'PUT',
headers: authHeaders(credentials),
payload: {
description
}
}).then((data) => parseAttachment(data))
}
2020-09-07 11:27:37 +00:00
const importMutes = ({ file, credentials }) => {
const formData = new FormData()
formData.append('list', file)
return fetch(MUTES_IMPORT_URL, {
body: formData,
method: 'POST',
headers: authHeaders(credentials)
})
.then((response) => response.ok)
}
2019-06-18 20:28:31 +00:00
const importBlocks = ({ file, credentials }) => {
2019-03-30 11:27:53 +00: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 20:28:31 +00:00
const importFollows = ({ file, credentials }) => {
const formData = new FormData()
formData.append('list', file)
2017-12-23 14:44:22 +00:00
return fetch(FOLLOW_IMPORT_URL, {
body: formData,
2017-12-23 14:44:22 +00:00
method: 'POST',
headers: authHeaders(credentials)
})
.then((response) => response.ok)
}
2019-06-18 20:28:31 +00: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 02:21:19 +00: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())
}
const moveAccount = ({ credentials, password, targetAccount }) => {
const form = new FormData()
form.append('password', password)
form.append('target_account', targetAccount)
return fetch(MOVE_ACCOUNT_URL, {
body: form,
method: 'POST',
headers: authHeaders(credentials)
})
.then((response) => response.json())
}
const addAlias = ({ credentials, alias }) => {
return promisedRequest({
url: ALIASES_URL,
method: 'PUT',
credentials,
payload: { alias }
})
}
const deleteAlias = ({ credentials, alias }) => {
return promisedRequest({
url: ALIASES_URL,
method: 'DELETE',
credentials,
payload: { alias }
})
}
const listAliases = ({ credentials }) => {
return promisedRequest({
url: ALIASES_URL,
method: 'GET',
credentials,
params: {
_cacheBooster: (new Date()).getTime()
}
})
}
2019-06-18 20:28:31 +00:00
const changePassword = ({ credentials, password, newPassword, newPasswordConfirmation }) => {
2018-05-21 22:01:09 +00: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 20:28:31 +00:00
const settingsMFA = ({ credentials }) => {
return fetch(MFA_SETTINGS_URL, {
headers: authHeaders(credentials),
method: 'GET'
}).then((data) => data.json())
}
2019-06-18 20:28:31 +00: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 20:28:31 +00: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 20:28:31 +00:00
const mfaSetupOTP = ({ credentials }) => {
return fetch(MFA_SETUP_OTP_URL, {
headers: authHeaders(credentials),
method: 'GET'
}).then((data) => data.json())
}
2019-06-18 20:28:31 +00:00
const generateMfaBackupCodes = ({ credentials }) => {
return fetch(MFA_BACKUP_CODES_URL, {
headers: authHeaders(credentials),
method: 'GET'
}).then((data) => data.json())
}
2019-06-18 20:28:31 +00:00
const fetchMutes = ({ credentials }) => {
return promisedRequest({ url: MASTODON_USER_MUTES_URL, credentials })
2019-03-22 01:27:10 +00:00
.then((users) => users.map(parseUser))
}
2019-06-18 20:28:31 +00:00
const muteUser = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_MUTE_USER_URL(id), credentials, method: 'POST' })
}
2019-06-18 20:28:31 +00:00
const unmuteUser = ({ id, credentials }) => {
return promisedRequest({ url: MASTODON_UNMUTE_USER_URL(id), credentials, method: 'POST' })
2019-02-13 17:05:23 +00:00
}
2022-06-22 15:46:47 +00:00
const setNote = ({ id, note, credentials }) => {
const form = new FormData()
form.append('comment', note)
return fetch(MASTODON_SET_NOTE_URL(id), {
body: form,
headers: authHeaders(credentials),
method: 'POST'
}).then((data) => data.json())
}
2020-05-08 13:38:46 +00:00
const fetchMascot = ({ credentials }) => {
return promisedRequest({ url: MASTODON_MASCOT_URL, credentials })
}
const updateMascot = ({ mascot, credentials }) => {
const form = new FormData()
form.append('file', mascot)
return fetch(MASTODON_MASCOT_URL, {
headers: authHeaders(credentials),
method: 'PUT',
body: form
}).then((data) => data.json())
}
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 20:28:31 +00:00
const fetchBlocks = ({ credentials }) => {
return promisedRequest({ url: MASTODON_USER_BLOCKS_URL, credentials })
2019-03-22 01:27:10 +00:00
.then((users) => users.map(parseUser))
2019-02-13 17:05:23 +00:00
}
2019-06-18 20:28:31 +00:00
const fetchOAuthTokens = ({ credentials }) => {
const url = '/api/oauth_tokens.json'
return fetch(url, {
headers: authHeaders(credentials)
2019-03-21 16:04:57 +00:00
}).then((data) => {
if (data.ok) {
return data.json()
}
throw new Error('Error fetching auth tokens', data)
})
}
2019-06-18 20:28:31 +00:00
const revokeOAuthToken = ({ id, credentials }) => {
const url = `/api/oauth_tokens/${id}`
return fetch(url, {
headers: authHeaders(credentials),
method: 'DELETE'
})
}
2019-06-18 20:28:31 +00:00
const suggestions = ({ credentials }) => {
2018-08-02 09:34:12 +00: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 20:28:31 +00: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 02:29:45 +00:00
}
const fetchRebloggedByUsers = ({ id, credentials }) => {
return promisedRequest({
url: MASTODON_STATUS_REBLOGGEDBY_URL(id),
method: 'GET',
credentials
}).then((users) => users.map(parseUser))
2019-04-02 02:29:45 +00: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 16:43:26 +00: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 20:28:31 +00:00
const reportUser = ({ credentials, userId, statusIds, comment, forward }) => {
2019-03-20 15:54:16 +00:00
return promisedRequest({
url: MASTODON_REPORT_USER_URL,
2019-03-20 15:54:16 +00:00
method: 'POST',
payload: {
'account_id': userId,
'status_ids': statusIds,
comment,
forward
2019-03-20 15:45:19 +00:00
},
2019-03-20 15:54:16 +00:00
credentials
})
2019-03-20 15:45:19 +00:00
}
const searchUsers = ({ credentials, query }) => {
return promisedRequest({
url: MASTODON_USER_SEARCH_URL,
params: {
q: query,
resolve: true
},
credentials
})
.then((data) => data.map(parseUser))
}
2022-07-05 13:28:23 +00:00
const search2 = ({ credentials, q, resolve, limit, offset, following, type }) => {
2019-07-15 16:42:27 +00:00
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])
}
2022-07-05 13:28:23 +00:00
if (type) {
params.push(['type', type])
}
2020-05-13 14:48:31 +00:00
params.push(['with_relationships', true])
2019-07-15 16:42:27 +00: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 20:22:54 +00: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 16:50:28 +00: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'
])
2020-05-07 13:10:53 +00:00
const PLEROMA_STREAMING_EVENTS = new Set([
'pleroma:chat_update'
])
2019-12-08 17:18:38 +00: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 19:30:27 +00:00
// Commented code reason: very spammy, uncomment to enable message debug logging
/*
2019-12-08 17:18:38 +00:00
socket.addEventListener('message', (wsEvent) => {
console.debug(
`[WS][${id}] Message received`,
wsEvent
)
})
2019-12-10 19:30:27 +00:00
/**/
2019-12-08 17:18:38 +00:00
proxy(socket, 'open')
proxy(socket, 'close')
proxy(socket, 'message', preprocessor)
proxy(socket, 'error')
2019-12-10 19:30:27 +00:00
// 1000 = Normal Closure
eventTarget.close = () => { socket.close(1000, 'Shutting down socket') }
eventTarget.getState = () => socket.readyState
2019-12-10 19:30:27 +00:00
2019-12-08 17:18:38 +00:00
return eventTarget
}
2019-11-24 16:50:28 +00:00
export const handleMastoWS = (wsEvent) => {
const { data } = wsEvent
if (!data) return
const parsedEvent = JSON.parse(data)
const { event, payload } = parsedEvent
2020-05-07 13:10:53 +00:00
if (MASTODON_STREAMING_EVENTS.has(event) || PLEROMA_STREAMING_EVENTS.has(event)) {
2019-12-11 16:20:43 +00:00
// MastoBE and PleromaBE both send payload for delete as a PLAIN string
if (event === 'delete') {
return { event, id: payload }
}
2019-11-24 16:50:28 +00: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) }
2020-05-07 13:10:53 +00:00
} else if (event === 'pleroma:chat_update') {
return { event, chatUpdate: parseChat(data) }
2019-11-24 16:50:28 +00:00
}
} else {
console.warn('Unknown event', wsEvent)
return null
}
}
2020-05-07 13:10:53 +00:00
export const WSConnectionStatus = Object.freeze({
'JOINED': 1,
'CLOSED': 2,
'ERROR': 3,
'DISABLED': 4,
'STARTING': 5,
'STARTING_INITIAL': 6
2020-05-07 13:10:53 +00:00
})
const chats = ({ credentials }) => {
return fetch(PLEROMA_CHATS_URL, { headers: authHeaders(credentials) })
.then((data) => data.json())
.then((data) => {
return { chats: data.map(parseChat).filter(c => c) }
})
}
const getOrCreateChat = ({ accountId, credentials }) => {
return promisedRequest({
url: PLEROMA_CHAT_URL(accountId),
method: 'POST',
credentials
})
}
const chatMessages = ({ id, credentials, maxId, sinceId, limit = 20 }) => {
let url = PLEROMA_CHAT_MESSAGES_URL(id)
const args = [
maxId && `max_id=${maxId}`,
sinceId && `since_id=${sinceId}`,
limit && `limit=${limit}`
].filter(_ => _).join('&')
url = url + (args ? '?' + args : '')
return promisedRequest({
url,
method: 'GET',
credentials
})
}
2020-10-29 10:33:06 +00:00
const sendChatMessage = ({ id, content, mediaId = null, idempotencyKey, credentials }) => {
2020-05-07 13:10:53 +00:00
const payload = {
'content': content
}
if (mediaId) {
payload['media_id'] = mediaId
}
2020-10-29 10:33:06 +00:00
const headers = {}
if (idempotencyKey) {
headers['idempotency-key'] = idempotencyKey
}
2020-05-07 13:10:53 +00:00
return promisedRequest({
url: PLEROMA_CHAT_MESSAGES_URL(id),
method: 'POST',
payload: payload,
2020-10-29 10:33:06 +00:00
credentials,
headers
2020-05-07 13:10:53 +00:00
})
}
const readChat = ({ id, lastReadId, credentials }) => {
return promisedRequest({
url: PLEROMA_CHAT_READ_URL(id),
method: 'POST',
payload: {
'last_read_id': lastReadId
},
credentials
})
}
const deleteChatMessage = ({ chatId, messageId, credentials }) => {
return promisedRequest({
url: PLEROMA_DELETE_CHAT_MESSAGE_URL(chatId, messageId),
method: 'DELETE',
credentials
})
}
2016-10-28 12:26:51 +00:00
const apiService = {
verifyCredentials,
2016-10-30 15:12:35 +00:00
fetchTimeline,
fetchPinnedStatuses,
fetchConversation,
fetchStatus,
2016-11-30 20:27:25 +00:00
fetchFriends,
exportFriends,
2017-08-21 17:25:01 +00:00
fetchFollowers,
2016-12-08 08:09:21 +00:00
followUser,
2016-12-23 15:45:57 +00:00
unfollowUser,
2019-04-04 15:27:02 +00:00
pinOwnStatus,
unpinOwnStatus,
muteConversation,
unmuteConversation,
2017-11-07 20:38:28 +00:00
blockUser,
unblockUser,
fetchUser,
fetchUserRelationship,
2016-10-30 15:12:35 +00:00
favorite,
2016-10-30 15:53:58 +00:00
unfavorite,
retweet,
2018-06-14 09:00:11 +00:00
unretweet,
bookmarkStatus,
unbookmarkStatus,
2016-11-06 18:29:41 +00:00
postStatus,
deleteStatus,
2017-02-13 21:55:38 +00:00
uploadMedia,
2020-07-07 06:07:20 +00:00
setMediaDescription,
2017-04-15 16:12:23 +00:00
fetchMutes,
muteUser,
unmuteUser,
2022-06-22 15:46:47 +00:00
setNote,
subscribeUser,
unsubscribeUser,
2019-02-13 17:05:23 +00:00
fetchBlocks,
fetchOAuthTokens,
revokeOAuthToken,
2019-02-18 14:49:32 +00:00
tagUser,
untagUser,
deleteUser,
addRight,
deleteRight,
activateUser,
deactivateUser,
2017-04-16 11:44:11 +00:00
register,
getCaptcha,
updateProfileImages,
updateProfile,
2020-09-07 11:27:37 +00:00
importMutes,
2019-03-30 11:27:53 +00:00
importBlocks,
2019-03-30 11:22:30 +00:00
importFollows,
2018-05-21 22:01:09 +00:00
deleteAccount,
2019-11-08 02:21:19 +00:00
changeEmail,
moveAccount,
addAlias,
deleteAlias,
listAliases,
2018-06-06 22:26:24 +00:00
changePassword,
settingsMFA,
mfaDisableOTP,
generateMfaBackupCodes,
mfaSetupOTP,
mfaConfirmOTP,
fetchFollowRequests,
2022-06-15 15:34:11 +00:00
fetchLists,
2022-06-15 22:52:24 +00:00
createList,
2022-06-16 02:41:43 +00:00
getList,
updateList,
getListAccounts,
2022-06-15 22:52:24 +00:00
addAccountsToList,
2022-06-16 07:04:33 +00:00
removeAccountsFromList,
2022-06-16 02:41:43 +00:00
deleteList,
approveUser,
2018-08-02 09:34:12 +00:00
denyUser,
suggestions,
2019-04-02 02:30:06 +00:00
markNotificationsAsSeen,
dismissNotification,
2019-06-18 20:28:31 +00:00
vote,
fetchPoll,
2019-04-02 16:13:55 +00:00
fetchFavoritedByUsers,
2019-03-20 15:45:19 +00:00
fetchRebloggedByUsers,
2020-05-08 13:38:46 +00:00
fetchMascot,
updateMascot,
fetchEmojiReactions,
reactWithEmoji,
unreactWithEmoji,
2019-05-25 07:01:02 +00:00
reportUser,
updateNotificationSettings,
search2,
2020-01-15 20:22:54 +00:00
searchUsers,
fetchKnownDomains,
2020-01-15 20:22:54 +00:00
fetchDomainMutes,
muteDomain,
2020-05-07 13:10:53 +00:00
unmuteDomain,
chats,
getOrCreateChat,
chatMessages,
sendChatMessage,
readChat,
deleteChatMessage
2016-10-27 16:03:14 +00:00
}
export default apiService