src/api/__mocks__/mediaUpload.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+export function uploadMedia({ formData, authHost }) {
+  return Promise.resolve()
+}

src/api/__mocks__/moderationLog.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+export async function fetchLog(authHost, token, params, page = 1) {
+  return Promise.resolve()
+}
+
+export async function fetchAdmins(authHost, token) {
+  return Promise.resolve()
+}
+
+export async function fetchModerators(authHost, token) {
+  return Promise.resolve()
+}

src/api/__mocks__/nodeInfo.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+export async function getNodeInfo(authHost) {
+  const data = {
+    metadata: {
+      mailerEnabled: true
+    }
+  }
+
+  return Promise.resolve({ data })
+}

src/api/__mocks__/peers.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+export async function fetchPeers(authHost, token) {
+  const data = ['lain.com', 'heaven.com']
+  return Promise.resolve({ data })
+}

src/api/__mocks__/relays.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+export async function fetchRelays(authHost, token) {
+  return Promise.resolve()
+}
+
+export async function addRelay(relay_url, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function deleteRelay(relay_url, authHost, token) {
+  return Promise.resolve()
+}

src/api/__mocks__/reports.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+const reports = [
+  { created_at: '2019-05-21T21:35:33.000Z', account: { nickname: 'benjamin', tags: [] }, actor: {}, state: 'open', id: '2', content: 'This is a report', statuses: [] },
+  { created_at: '2019-05-20T22:45:33.000Z', account: { nickname: 'alice', tags: [] }, actor: {}, state: 'resolved', id: '1', content: 'Please block this user', statuses: [] },
+  { created_at: '2019-05-18T13:01:33.000Z', account: { nickname: 'nick_keys', tags: [] }, actor: {}, state: 'closed', id: '3', content: '', statuses: [] },
+  { created_at: '2019-05-21T21:35:33.000Z', account: { nickname: 'benjamin', tags: [] }, actor: {}, state: 'open', id: '5', content: 'This is a report', statuses: [] },
+  { created_at: '2019-05-20T22:45:33.000Z', account: { nickname: 'alice', tags: [] }, actor: {}, state: 'resolved', id: '7', content: 'Please block this user', statuses: [
+    { account: { nickname: 'alice', avatar: '' }, visibility: 'public', sensitive: false, id: '11', content: 'Hey!', url: '', created_at: '2019-05-10T21:35:33.000Z' },
+    { account: { nickname: 'alice', avatar: '' }, visibility: 'unlisted', sensitive: true, id: '10', content: 'Bye!', url: '', created_at: '2019-05-10T21:00:33.000Z' }
+  ] },
+  { created_at: '2019-05-18T13:01:33.000Z', account: { nickname: 'nick_keys', tags: [] }, actor: {}, state: 'closed', id: '6', content: '', statuses: [] },
+  { created_at: '2019-05-18T13:01:33.000Z', account: { nickname: 'nick_keys', tags: [] }, actor: {}, state: 'closed', id: '4', content: '', statuses: [] }
+]
+
+export async function fetchReports(filter, page, pageSize, authHost, token) {
+  return filter.length > 0
+    ? Promise.resolve({ data: { reports: reports.filter(report => report.state === filter) }})
+    : Promise.resolve({ data: { reports }})
+}
+
+export async function changeState(reportsData, authHost, token) {
+  return Promise.resolve({ data: '' })
+}
+
+export async function createNote(content, reportID, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function deleteNote(noteID, reportID, authHost, token) {
+  return Promise.resolve()
+}
+
+// export async function changeStatusScope(id, sensitive, visibility, authHost, token) {
+//   const status = reports[4].statuses[0]
+//   return Promise.resolve({ data: { ...status, sensitive, visibility }})
+// }
+
+// export async function deleteStatus(statusId, authHost, token) {
+//   return Promise.resolve()
+// }

src/api/__mocks__/settings.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+const configsWithTagPolicy = {
+  configs: [{
+    group: ':pleroma',
+    key: ':mrf',
+    value: [
+      { tuple: [':policies', ['Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy', 'Pleroma.Web.ActivityPub.MRF.TagPolicy']] },
+      { tuple: [':transparency', true] },
+      { tuple: [':transparency_exclusions', []] }
+    ] },
+  {
+    group: ':pleroma',
+    key: ':media_proxy',
+    value: [
+      { tuple: [':enabled', true] },
+      { tuple: [':invalidation', [
+        { tuple: [':provider', 'Pleroma.Web.MediaProxy.Invalidation.Script'] },
+        { tuple: [':enabled', true] }
+      ]] }
+    ] }],
+  need_reboot: false
+}
+
+const configAfterUpdate = {
+  configs: [{
+    db: [':policies'],
+    group: ':pleroma',
+    key: ':mrf',
+    value: [{ tuple: [':policies', ['Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy', 'Pleroma.Web.ActivityPub.MRF.TagPolicy']] }]
+  }],
+  need_reboot: false
+}
+
+export async function fetchSettings(authHost, token) {
+  return Promise.resolve({ data: configsWithTagPolicy })
+}
+
+export async function getInstanceDocument(name, authHost, token) {
+  return Promise.resolve({ data: '<h1>Instance panel</h1>' })
+}
+
+export async function updateSettings(configs, authHost, token) {
+  return Promise.resolve({ data: configAfterUpdate })
+}
+
+export async function deleteInstanceDocument(name, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function fetchDescription(authHost, token) {
+  return Promise.resolve()
+}
+
+export async function updateInstanceDocument(name, formData, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function removeSettings(configs, authHost, token) {
+  return Promise.resolve()
+}

src/api/__mocks__/status.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+export async function changeStatusScope(id, sensitive, visibility, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function deleteStatus(id, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function fetchStatus(id, authHost, token) {
+  const data = {
+    account: {
+      id: '9n1bySks25olxWrku0',
+      avatar: 'http://localhost:4000/images/avi.png',
+      nickname: 'dolin',
+      tags: ['mrf_tag:media-strip', 'mrf_tag:sandbox', 'mrf_tag:disable-any-subscription', 'mrf_tag:media-force-nsfw'],
+      url: 'http://localhost:4000/users/dolin'
+    },
+    content: 'pizza makes everything better',
+    created_at: '2020-05-22T17:34:34.000Z',
+    id: '9vJOO3iFPyjNaEhJ5s',
+    media_attachments: [],
+    poll: null,
+    sensitive: false,
+    spoiler_text: '',
+    visibility: 'public',
+    url: 'http://localhost:4000/notice/9vJOO3iFPyjNaEhJ5s'
+  }
+
+  return Promise.resolve({ data })
+}
+
+export async function fetchStatusesByInstance({ instance, authHost, token, pageSize, page }) {
+  let data
+  if (pageSize === 1) {
+    data = page === 1 || page === 2
+      ? [{
+        'account': {
+          'avatar': 'http://localhost:4000/images/avi.png',
+          'nickname': 'sky',
+          'url': 'http://localhost:4000/users/sky'
+        },
+        'content': 'A nice young couple contacted us from Brazil to decorate their newly acquired apartment.',
+        'created_at': '2020-01-31T18:20:01.000Z',
+        'id': '9rZIr0Jzao5Gjgfmro',
+        'sensitive': false,
+        'url': 'http://localhost:4000/objects/7af9abbd-fb6c-4318-aeb7-6636c138ac98',
+        'visibility': 'unlisted'
+      }]
+      : []
+  } else {
+    data = [
+      {
+        'account': {
+          'avatar': 'http://localhost:4000/images/avi.png',
+          'nickname': 'sky',
+          'url': 'http://localhost:4000/users/sky'
+        },
+        'content': 'i love parks&rec',
+        'created_at': '2020-04-12T18:20:01.000Z',
+        'id': 'o5Gjgfmro9rZIr0Jza',
+        'sensitive': false,
+        'url': 'http://localhost:4000/objects/7af9abbd-aeb7-6636c138ac98-fb6c-4318',
+        'visibility': 'unlisted'
+      },
+      {
+        'account': {
+          'avatar': 'http://localhost:4000/images/avi.png',
+          'nickname': 'sky',
+          'url': 'http://localhost:4000/users/sky'
+        },
+        'content': 'the happiest man ever',
+        'created_at': '2019-11-23T12:56:18.000Z',
+        'id': '9pFoVfWMU3A96Rzq3k',
+        'sensitive': false,
+        'url': 'http://localhost:4000/objects/449c90fe-c457-4c64-baf2-fe6d0a59ca25',
+        'visibility': 'unlisted'
+      }]
+  }
+  return Promise.resolve({ data })
+}
+
+export async function fetchStatusesCount(instance, authHost, token) {
+  const data = instance === 'heaven.com'
+    ? {
+      'status_visibility':
+      { 'direct': 1, 'private': 2, 'public': 3, 'unlisted': 0 }
+    }
+    : {
+      'status_visibility':
+      { 'direct': 4, 'private': 10, 'public': 4, 'unlisted': 10 }
+    }
+  return Promise.resolve({ data })
+}
+
+export async function fetchStatuses({ godmode, localOnly, authHost, token, pageSize, page }) {
+  return Promise.resolve()
+}

src/api/__mocks__/users.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import userChats from './chat'
+
+export let users = [
+  { is_confirmed: true, is_approved: true, is_active: true, id: '2', nickname: 'allis', local: true, external: false, roles: { admin: true, moderator: false }, tags: [], actor_type: 'Person' },
+  { is_confirmed: true, is_approved: true, is_active: true, id: '10', nickname: 'bob', local: true, external: false, roles: { admin: false, moderator: false }, tags: ['mrf_tag:sandbox'], actor_type: 'Person' },
+  { is_confirmed: true, is_approved: false, is_active: true, id: '567', nickname: 'ded', local: false, external: true, roles: { admin: false, moderator: false }, tags: [], actor_type: 'Person' },
+  { is_confirmed: true, is_approved: true, is_active: false, id: 'abc', nickname: 'john', local: true, external: false, roles: { admin: false, moderator: false }, tags: ['mrf_tag:media-strip'], actor_type: 'Person' },
+  { is_confirmed: true, is_approved: false, is_active: true, id: '100', nickname: 'sally', local: true, external: false, roles: { admin: false, moderator: false }, tags: [], actor_type: 'Service' },
+  { is_confirmed: true, is_approved: false, is_active: true, id: '123', nickname: 'bot', local: true, external: false, roles: { admin: false, moderator: false }, tags: [], actor_type: 'Application' }
+]
+
+const userProfile = { avatar: 'avatar.jpg', nickname: 'allis', id: '2', tags: [], roles: { admin: true, moderator: false }, local: true, external: false }
+
+const userStatuses = [
+  { account: { id: '9n1bySks25olxWrku0', nickname: 'dolin' }, content: 'pizza makes everything better', id: '9vJOO3iFPyjNaEhJ5s', created_at: '2020-05-22T17:34:34.000Z', visibility: 'public' },
+  { account: { id: '9n1bySks25olxWrku0', nickname: 'dolin' }, content: 'pizza time', id: '9vJPD5XKOdzQ0bvGLY', created_at: '2020-05-22T17:34:34.000Z', visibility: 'public' },
+  { account: { id: '9n1bySks25olxWrku0', nickname: 'dolin' }, content: 'what is yout favorite pizza?', id: '9jop82OBXeFPYulVjM', created_at: '2020-05-22T17:34:34.000Z', visibility: 'public' }
+]
+
+export async function fetchUser(id, authHost, token) {
+  return Promise.resolve({ data: userProfile })
+}
+
+export async function fetchUserCredentials(nickname, authHost, token) {
+  return Promise.resolve({ data: {}})
+}
+
+export async function fetchUsers(filters, actorTypeFilters, authHost, token, page = 1) {
+  return Promise.resolve({ data: {
+    users,
+    count: users.length,
+    page_size: 50
+  }})
+}
+
+export async function fetchUserStatuses(id, authHost, godmode, token) {
+  return Promise.resolve({ data: userStatuses })
+}
+
+export async function fetchUserChats(id, authHost, godmode, token) {
+  return Promise.resolve({ data: userChats })
+}
+
+export async function getPasswordResetToken(nickname, authHost, token) {
+  return Promise.resolve({ data: { token: 'g05lxnBJQnL', link: 'http://url/api/pleroma/password_reset/g05lxnBJQnL' }})
+}
+
+export async function searchUsers(query, filters, actorTypeFilters, authHost, token, page = 1) {
+  const response = users.filter(user => user.nickname === query)
+  return Promise.resolve({ data: {
+    users: response,
+    count: response.length,
+    page_size: 50
+  }})
+}
+
+export async function activateUsers(nicknames, authHost, token) {
+  const response = nicknames.map(nickname => {
+    const currentUser = users.find(user => user.nickname === nickname)
+    return { ...currentUser, is_active: true }
+  })
+  return Promise.resolve({ data: response })
+}
+
+export async function addRight(nicknames, right, authHost, token) {
+  return Promise.resolve({ data:
+    { [`is_${right}`]: true }
+  })
+}
+
+export async function deactivateUsers(nicknames, authHost, token) {
+  const response = nicknames.map(nickname => {
+    const currentUser = users.find(user => user.nickname === nickname)
+    return { ...currentUser, is_active: false }
+  })
+  return Promise.resolve({ data: response })
+}
+
+export async function approveUserAccount(nicknames, authHost, token) {
+  const response = nicknames.map(nickname => {
+    const currentUser = users.find(user => user.nickname === nickname)
+    return { ...currentUser, is_approved: true }
+  })
+  return Promise.resolve({ data: response })
+}
+
+export async function deleteRight(nickname, right, authHost, token) {
+  return Promise.resolve({ data:
+    { [`is_${right}`]: false }
+  })
+}
+
+export async function deleteUsers(nicknames, authHost, token) {
+  return Promise.resolve({ data:
+    nicknames
+  })
+}
+
+export async function tagUser(nickname, tag, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function untagUser(nickname, tag, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function createNewAccount(nickname, email, password, authHost, token) {
+  const newUser = { active: true, is_active: true, id: '15', nickname, local: true, external: false, roles: { admin: false, moderator: false }, tags: [] }
+  users = [...users, newUser]
+  return Promise.resolve()
+}
+
+export async function updateUserCredentials(nickname, credentials, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function disableMfa(nickname, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function forcePasswordReset(nicknames, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function confirmUserEmail(nicknames, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function resendConfirmationEmail(nicknames, authHost, token) {
+  return Promise.resolve()
+}

src/api/app.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import request from '@/utils/request'
+import { getToken } from '@/utils/auth'
+import { baseName } from './utils'
+
+export async function needReboot(authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/need_reboot`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function restartApp(authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/restart`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+const authHeaders = (token) => token ? { 'Authorization': `Bearer ${getToken()}` } : {}

src/api/article.js

-import fetch from 'utils/fetch';
-
-export function getList() {
-  return fetch({
-    url: '/article/list',
-    method: 'get'
-  });
-}
-
-export function getArticle() {
-  return fetch({
-    url: '/article/detail',
-    method: 'get'
-  });
-}
-

src/api/article_table.js

-import fetch from 'utils/fetch';
-
-export function fetchList(query) {
-  return fetch({
-    url: '/article_table/list',
-    method: 'get',
-    params: query
-  });
-}
-
-export function fetchPv(pv) {
-  return fetch({
-    url: '/article_table/pv',
-    method: 'get',
-    params: { pv }
-  });
-}

src/api/chat.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import request from '@/utils/request'
+import { getToken } from '@/utils/auth'
+import { baseName } from './utils'
+
+export async function deleteChatMessage(chat_id, message_id, authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/chats/${chat_id}/messages/${message_id}`,
+    method: 'delete',
+    headers: authHeaders(token)
+  })
+}
+
+export async function fetchChat(id, authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/chats/${id}`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function fetchChatMessages(id, maxId, authHost, token) {
+  const url = maxId
+    ? `/api/pleroma/admin/chats/${id}/messages?max_id=${maxId}`
+    : `/api/pleroma/admin/chats/${id}/messages`
+  return await request({
+    baseURL: baseName(authHost),
+    url,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+const authHeaders = (token) => token ? { 'Authorization': `Bearer ${getToken()}` } : {}

src/api/emojiPacks.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import request from '@/utils/request'
+import { getToken } from '@/utils/auth'
+import { baseName } from './utils'
+
+export async function addNewEmojiFile(packName, file, shortcode, filename, host, token) {
+  const data = new FormData()
+  if (filename.trim() !== '') {
+    data.set('filename', filename)
+  }
+  if (shortcode.trim() !== '') {
+    data.set('shortcode', shortcode)
+  }
+  data.set('file', file)
+
+  return await request({
+    baseURL: baseName(host),
+    url: `/api/pleroma/emoji/packs/files?name=${packName}`,
+    method: 'post',
+    headers: authHeaders(token),
+    data
+  })
+}
+
+export function addressOfEmojiInPack(host, packName, name) {
+  return `${baseName(host)}/emoji/${encodeUri(packName)}/${name}`
+}
+
+export async function createPack(host, token, packName) {
+  return await request({
+    baseURL: baseName(host),
+    url: `/api/pleroma/emoji/pack?name=${packName}`,
+    method: 'post',
+    headers: authHeaders(token)
+  })
+}
+
+export async function deleteEmojiFile(packName, shortcode, host, token) {
+  return await request({
+    baseURL: baseName(host),
+    url: `/api/pleroma/emoji/packs/files?name=${packName}&shortcode=${shortcode}`,
+    method: 'delete',
+    headers: authHeaders(token)
+  })
+}
+
+export async function deletePack(host, token, packName) {
+  return await request({
+    baseURL: baseName(host),
+    url: `/api/pleroma/emoji/pack?name=${packName}`,
+    method: 'delete',
+    headers: authHeaders(token)
+  })
+}
+
+export async function downloadFrom(instanceAddress, packName, as, host, token) {
+  return await request({
+    baseURL: baseName(host),
+    url: '/api/pleroma/emoji/packs/download',
+    method: 'post',
+    headers: authHeaders(token),
+    data: as.trim() === ''
+      ? { url: baseName(instanceAddress), name: packName }
+      : { url: baseName(instanceAddress), name: packName, as },
+    timeout: 0
+  })
+}
+
+export async function fetchPack(packName, page, pageSize, host, token) {
+  return await request({
+    baseURL: baseName(host),
+    url: `/api/pleroma/emoji/pack?name=${packName}&page=${page}&page_size=${pageSize}`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function importFromFS(host, token) {
+  return await request({
+    baseURL: baseName(host),
+    url: '/api/pleroma/emoji/packs/import',
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function listPacks(page, pageSize, host, token) {
+  return await request({
+    baseURL: baseName(host),
+    url: `/api/pleroma/emoji/packs?page=${page}&page_size=${pageSize}`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function listRemotePacks(instance, page, pageSize, host, token) {
+  return await request({
+    baseURL: baseName(host),
+    url: `/api/pleroma/emoji/packs/remote?url=${baseName(instance)}&page=${page}&page_size=${pageSize}`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function reloadEmoji(host, token) {
+  return await request({
+    baseURL: baseName(host),
+    url: '/api/pleroma/admin/reload_emoji',
+    method: 'post',
+    headers: authHeaders(token)
+  })
+}
+
+export async function savePackMetadata(host, token, packName, metadata) {
+  return await request({
+    baseURL: baseName(host),
+    url: `/api/pleroma/emoji/pack?name=${packName}`,
+    method: 'patch',
+    headers: authHeaders(token),
+    data: { metadata },
+    timeout: 0 // This might take a long time
+  })
+}
+
+export async function updateEmojiFile(packName, shortcode, newShortcode, newFilename, force, host, token) {
+  return await request({
+    baseURL: baseName(host),
+    url: `/api/pleroma/emoji/packs/files?name=${packName}`,
+    method: 'patch',
+    headers: authHeaders(token),
+    data: { shortcode, new_shortcode: newShortcode, new_filename: newFilename, force }
+  })
+}
+
+const authHeaders = (token) => token ? { 'Authorization': `Bearer ${getToken()}` } : {}
+
+const encodeUri = (name) => encodeURIComponent(name)

src/api/invites.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import request from '@/utils/request'
+import { getToken } from '@/utils/auth'
+import { baseName } from './utils'
+
+export async function generateInviteToken(max_use, expires_at, authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/users/invite_token`,
+    method: 'post',
+    headers: authHeaders(token),
+    data: expires_at && expires_at.length > 0 ? { max_use, expires_at } : { max_use }
+  })
+}
+
+export async function inviteViaEmail(email, name, authHost, token) {
+  const data = name.length > 0 ? { email, name } : { email }
+  return await request({
+    baseURL: baseName(authHost),
+    url: '/api/pleroma/admin/users/email_invite',
+    method: 'post',
+    headers: authHeaders(token),
+    data
+  })
+}
+
+export async function listInviteTokens(authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/users/invites`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function revokeToken(tokenToRevoke, authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/users/revoke_invite`,
+    method: 'post',
+    headers: authHeaders(token),
+    data: { token: tokenToRevoke }
+  })
+}
+
+const authHeaders = (token) => token ? { 'Authorization': `Bearer ${getToken()}` } : {}

src/api/login.js

-import fetch from 'utils/fetch';
+// SPDX-FileCopyrightText: 2017-2019 PanJiaChen <https://github.com/PanJiaChen/vue-element-admin>
+// SPDX-License-Identifier: MIT
+//
+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
 
-export function loginByEmail(email, password) {
-  const data = {
-    email,
-    password
-  };
-  return fetch({
-    url: '/login/loginbyemail',
+import request from '@/utils/request'
+import { baseName } from './utils'
+
+export async function loginByUsername(username, password, authHost) {
+  const appsRequest = await request({
+    baseURL: baseName(authHost),
+    url: '/api/v1/apps',
     method: 'post',
-    data
-  });
-}
+    data: {
+      client_name: `AdminFE_${Math.random()}`,
+      redirect_uris: `${window.location.origin}/oauth-callback`,
+      scopes: 'read write follow push admin'
+    }
+  })
+
+  const app = appsRequest.data
 
-export function logout() {
-  return fetch({
-    url: '/login/logout',
-    method: 'post'
-  });
+  return request({
+    baseURL: baseName(authHost),
+    url: '/oauth/token',
+    method: 'post',
+    data: {
+      client_id: app.client_id,
+      client_secret: app.client_secret,
+      grant_type: 'password',
+      username: username,
+      password: password
+    }
+  })
 }
 
-export function getInfo(token) {
-  return fetch({
-    url: '/user/info',
+export function getUserInfo(token, authHost) {
+  return request({
+    baseURL: baseName(authHost),
+    url: '/api/v1/accounts/verify_credentials',
     method: 'get',
-    params: { token }
-  });
+    headers: token ? { 'Authorization': `Bearer ${token}` } : {}
+  })
 }
 
+const oauth = { loginByUsername, getUserInfo }
+
+export default oauth

src/api/mediaProxyCache.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import request from '@/utils/request'
+import { getToken } from '@/utils/auth'
+import { baseName } from './utils'
+
+export async function listBannedUrls(page, pageSize, authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/media_proxy_caches?page=${page}&page_size=${pageSize}`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function purgeUrls(urls, ban, authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/media_proxy_caches/purge`,
+    method: 'post',
+    headers: authHeaders(token),
+    data: { urls, ban }
+  })
+}
+
+export async function removeBannedUrls(urls, authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/media_proxy_caches/delete`,
+    method: 'post',
+    headers: authHeaders(token),
+    data: { urls }
+  })
+}
+
+export async function searchBannedUrls(query, page, pageSize, authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/media_proxy_caches?query=${query}&page=${page}&page_size=${pageSize}`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+const authHeaders = (token) => token ? { 'Authorization': `Bearer ${getToken()}` } : {}

src/api/mediaUpload.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { getToken } from '@/utils/auth'
+import { baseName } from './utils'
+
+const UPLOAD_URL = '/api/v1/media'
+
+export function uploadMedia({ formData, authHost }) {
+  const url = baseName(authHost) + UPLOAD_URL
+
+  return fetch(url, {
+    body: formData,
+    method: 'POST',
+    headers: authHeaders()
+  })
+    .then((data) => data.json())
+}
+
+const authHeaders = () => {
+  return { 'Authorization': `Bearer ${getToken()}` }
+}

src/api/moderationLog.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import _ from 'lodash'
+
+import request from '@/utils/request'
+import { getToken } from '@/utils/auth'
+import { baseName } from './utils'
+
+export async function fetchLog(authHost, token, params, page = 1) {
+  const normalizedParams = new URLSearchParams(
+    _.omitBy({ ...params, page }, _.isUndefined)
+  ).toString()
+
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/moderation_log?${normalizedParams}`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function fetchAdmins(authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/users?filters=is_admin`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+export async function fetchModerators(authHost, token) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/api/pleroma/admin/users?filters=is_moderator`,
+    method: 'get',
+    headers: authHeaders(token)
+  })
+}
+
+const authHeaders = (token) => token ? { 'Authorization': `Bearer ${getToken()}` } : {}

src/api/nodeInfo.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import request from '@/utils/request'
+import { baseName } from './utils'
+
+export async function getNodeInfo(authHost) {
+  return await request({
+    baseURL: baseName(authHost),
+    url: `/nodeinfo/2.0.json`,
+    method: 'get'
+  })
+}