src/api/__mocks__/mediaProxyCache.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+const urls = [
+  'http://example.com/media/a688346.jpg',
+  'http://example.com/media/fb1f4d.jpg'
+]
+
+export async function listBannedUrls(page, pageSize, authHost, token) {
+  return Promise.resolve({ data: { page_size: 1, count: 2, urls }})
+}
+
+export async function purgeUrls(urls, ban, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function removeBannedUrls(urls, authHost, token) {
+  return Promise.resolve()
+}
+
+export async function searchBannedUrls(query, page, pageSize, authHost, token) {
+  return Promise.resolve()
+}

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: {

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: { acct: 'benj', display_name: 'Benjamin Fame', tags: [] }, actor: { acct: 'admin' }, state: 'open', id: '2', content: 'This is a report', statuses: [] },
-  { created_at: '2019-05-20T22:45:33.000Z', account: { acct: 'alice', display_name: 'Alice Pool', tags: [] }, actor: { acct: 'admin2' }, state: 'resolved', id: '1', content: 'Please block this user', statuses: [] },
-  { created_at: '2019-05-18T13:01:33.000Z', account: { acct: 'nick', display_name: 'Nick Keys', tags: [] }, actor: { acct: 'admin' }, state: 'closed', id: '3', content: '', statuses: [] },
-  { created_at: '2019-05-21T21:35:33.000Z', account: { acct: 'benj', display_name: 'Benjamin Fame', tags: [] }, actor: { acct: 'admin' }, state: 'open', id: '5', content: 'This is a report', statuses: [] },
-  { created_at: '2019-05-20T22:45:33.000Z', account: { acct: 'alice', display_name: 'Alice Pool', tags: [] }, actor: { acct: 'admin2' }, state: 'resolved', id: '7', content: 'Please block this user', statuses: [
-    { account: { display_name: 'Alice Pool', avatar: '' }, visibility: 'public', sensitive: false, id: '11', content: 'Hey!', url: '', created_at: '2019-05-10T21:35:33.000Z' },
-    { account: { display_name: 'Alice Pool', avatar: '' }, visibility: 'unlisted', sensitive: true, id: '10', content: 'Bye!', url: '', created_at: '2019-05-10T21:00:33.000Z' }
+  { 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: { acct: 'nick', display_name: 'Nick Keys', tags: [] }, actor: { acct: 'admin' }, state: 'closed', id: '6', content: '', statuses: [] },
-  { created_at: '2019-05-18T13:01:33.000Z', account: { acct: 'nick', display_name: 'Nick Keys', tags: [] }, actor: { acct: 'admin' }, state: 'closed', id: '4', content: '', statuses: [] }
+  { 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) {
@@ -21,11 +24,19 @@ export async function changeState(reportsData, authHost, token) {
   return Promise.resolve({ data: '' })
 }
 
-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 createNote(content, reportID, authHost, token) {
+  return Promise.resolve()
 }
 
-export async function deleteStatus(statusId, authHost, token) {
+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()
 }
@@ -5,3 +8,93 @@ export async function changeStatusScope(id, sensitive, visibility, authHost, tok
 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 = [
-  { active: true, deactivated: false, id: '2', nickname: 'allis', local: true, external: false, roles: { admin: true, moderator: false }, tags: [] },
-  { active: true, deactivated: false, id: '10', nickname: 'bob', local: false, external: true, roles: { admin: false, moderator: false }, tags: ['sandbox'] },
-  { active: false, deactivated: true, id: 'abc', nickname: 'john', local: true, external: false, roles: { admin: false, moderator: false }, tags: ['strip_media'] }
+  { 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', display_name: 'Allis', nickname: 'allis', id: '2', tags: [], roles: { admin: true, moderator: false }, local: true, external: false }
+const userProfile = { avatar: 'avatar.jpg', nickname: 'allis', id: '2', tags: [], roles: { admin: true, moderator: false }, local: true, external: false }
 
-const userStatuses = []
-
-const filterUsers = (str) => {
-  const filters = str.split(',').filter(item => item.length > 0)
-  if (filters.length === 0) {
-    return users
-  }
-  const applyFilters = (acc, filters, users) => {
-    if (filters.length === 0) {
-      return acc
-    }
-    const filteredUsers = users.filter(user => user[filters[0]])
-    const newAcc = [...filteredUsers]
-    return applyFilters(newAcc, filters.slice(1), filteredUsers)
-  }
-  return applyFilters([], filters, users)
-}
+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 fetchUsers(filters, authHost, token, page = 1) {
-  const filteredUsers = filterUsers(filters)
+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: filteredUsers,
-    count: filteredUsers.length,
+    users,
+    count: users.length,
     page_size: 50
   }})
 }
@@ -41,13 +40,16 @@ 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, authHost, token, page = 1) {
-  const filteredUsers = filterUsers(filters)
-  const response = filteredUsers.filter(user => user.nickname === query)
+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,
@@ -58,7 +60,7 @@ export async function searchUsers(query, filters, authHost, token, page = 1) {
 export async function activateUsers(nicknames, authHost, token) {
   const response = nicknames.map(nickname => {
     const currentUser = users.find(user => user.nickname === nickname)
-    return { ...currentUser, deactivated: false }
+    return { ...currentUser, is_active: true }
   })
   return Promise.resolve({ data: response })
 }
@@ -72,7 +74,15 @@ export async function addRight(nicknames, right, authHost, token) {
 export async function deactivateUsers(nicknames, authHost, token) {
   const response = nicknames.map(nickname => {
     const currentUser = users.find(user => user.nickname === nickname)
-    return { ...currentUser, deactivated: true }
+    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 })
 }
@@ -98,7 +108,27 @@ export async function untagUser(nickname, tag, authHost, token) {
 }
 
 export async function createNewAccount(nickname, email, password, authHost, token) {
-  const newUser = { active: true, deactivated: false, id: '15', nickname, local: true, external: false, roles: { admin: false, moderator: false }, tags: [] }
+  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/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'
 
-import _ from 'lodash'
+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)
 
-export async function deletePack(host, token, name) {
   return await request({
     baseURL: baseName(host),
-    url: `/api/pleroma/emoji/packs/${name}`,
-    method: 'delete',
-    headers: authHeaders(token)
+    url: `/api/pleroma/emoji/packs/files?name=${packName}`,
+    method: 'post',
+    headers: authHeaders(token),
+    data
   })
 }
 
-export async function reloadEmoji(host, token) {
+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/admin/reload_emoji',
+    url: `/api/pleroma/emoji/pack?name=${packName}`,
     method: 'post',
     headers: authHeaders(token)
   })
 }
 
-export async function importFromFS(host, token) {
+export async function deleteEmojiFile(packName, shortcode, host, token) {
   return await request({
     baseURL: baseName(host),
-    url: '/api/pleroma/emoji/packs/import_from_fs',
-    method: 'post',
+    url: `/api/pleroma/emoji/packs/files?name=${packName}&shortcode=${shortcode}`,
+    method: 'delete',
     headers: authHeaders(token)
   })
 }
 
-export async function createPack(host, token, name) {
+export async function deletePack(host, token, packName) {
   return await request({
     baseURL: baseName(host),
-    url: `/api/pleroma/emoji/packs/${name}`,
-    method: 'put',
+    url: `/api/pleroma/emoji/pack?name=${packName}`,
+    method: 'delete',
     headers: authHeaders(token)
   })
 }
 
-export async function listPacks(host) {
+export async function downloadFrom(instanceAddress, packName, as, host, token) {
   return await request({
     baseURL: baseName(host),
-    url: `/api/pleroma/emoji/packs/`,
-    method: 'get'
+    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 listRemotePacks(host, token, instance) {
+export async function fetchPack(packName, page, pageSize, host, token) {
   return await request({
     baseURL: baseName(host),
-    url: `/api/pleroma/emoji/packs/list_from`,
-    method: 'post',
-    headers: authHeaders(token),
-    data: { instance_address: baseName(instance) }
+    url: `/api/pleroma/emoji/pack?name=${packName}&page=${page}&page_size=${pageSize}`,
+    method: 'get',
+    headers: authHeaders(token)
   })
 }
 
-export async function downloadFrom(host, instance_address, pack_name, as, token) {
-  if (as.trim() === '') {
-    as = null
-  }
-
+export async function importFromFS(host, token) {
   return await request({
     baseURL: baseName(host),
-    url: '/api/pleroma/emoji/packs/download_from',
-    method: 'post',
-    headers: authHeaders(token),
-    data: { instance_address: baseName(instance_address), pack_name, as },
-    timeout: 0
+    url: '/api/pleroma/emoji/packs/import',
+    method: 'get',
+    headers: authHeaders(token)
   })
 }
 
-export async function savePackMetadata(host, token, name, new_data) {
+export async function listPacks(page, pageSize, host, token) {
   return await request({
     baseURL: baseName(host),
-    url: `/api/pleroma/emoji/packs/${name}/update_metadata`,
-    method: 'post',
-    headers: authHeaders(token),
-    data: { name, new_data },
-    timeout: 0 // This might take a long time
+    url: `/api/pleroma/emoji/packs?page=${page}&page_size=${pageSize}`,
+    method: 'get',
+    headers: authHeaders(token)
   })
 }
 
-function fileUpdateFormData(d) {
-  const data = new FormData()
-
-  _.each(d, (v, k) => {
-    data.set(k, v)
+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)
   })
-
-  return data
 }
 
-export async function updatePackFile(host, token, args) {
-  let data = null
-
-  switch (args.action) {
-    case 'add': {
-      const { shortcode, file, fileName } = args
-
-      data = fileUpdateFormData({
-        action: 'add',
-        shortcode: shortcode,
-        file: file
-      })
-      if (fileName.trim() !== '') {
-        data.set('filename', fileName)
-      }
-
-      break
-    }
-
-    case 'update': {
-      const { oldName, newName, newFilename } = args
-
-      data = fileUpdateFormData({
-        action: 'update',
-        shortcode: oldName,
-        new_shortcode: newName,
-        new_filename: newFilename
-      })
-
-      break
-    }
-
-    case 'remove': {
-      const { name } = args
-      data = fileUpdateFormData({
-        action: 'remove',
-        shortcode: name
-      })
-
-      break
-    }
-  }
-
-  const { packName } = args
-
+export async function reloadEmoji(host, token) {
   return await request({
     baseURL: baseName(host),
-    url: `/api/pleroma/emoji/packs/${packName}/update_file`,
+    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: data,
-    timeout: 0
+    data: { metadata },
+    timeout: 0 // This might take a long time
   })
 }
 
-export function addressOfEmojiInPack(host, packName, name) {
-  return `${baseName(host)}/emoji/${packName}/${name}`
+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'
@@ -13,14 +16,13 @@ export async function generateInviteToken(max_use, expires_at, authHost, token)
 }
 
 export async function inviteViaEmail(email, name, authHost, token) {
-  const url = name.length > 0
-    ? `/api/pleroma/admin/users/email_invite?email=${email}&name=${name}`
-    : `/api/pleroma/admin/users/email_invite?email=${email}`
+  const data = name.length > 0 ? { email, name } : { email }
   return await request({
     baseURL: baseName(authHost),
-    url,
+    url: '/api/pleroma/admin/users/email_invite',
     method: 'post',
-    headers: authHeaders(token)
+    headers: authHeaders(token),
+    data
   })
 }
 

src/api/login.js

+// 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
+
 import request from '@/utils/request'
 import { baseName } from './utils'
 

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'

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'
 

src/api/peers.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'