shared/ typescript types dir server-commands

10 files changed, 1869 insertions, 0 deletions

diff --git a/shared/server-commands/users/accounts-command.ts b/shared/server-commands/users/accounts-command.ts
new file mode 100644
index 000000000..98d9d5927
--- /dev/null
+++ b/shared/server-commands/users/accounts-command.ts
@@ -0,0 +1,78 @@
+import { HttpStatusCode, ResultList } from '@shared/models'
+import { Account, ActorFollow } from '../../models/actors'
+import { AccountVideoRate, VideoRateType } from '../../models/videos'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class AccountsCommand extends AbstractCommand {
+
+  list (options: OverrideCommandOptions & {
+    sort?: string // default -createdAt
+  } = {}) {
+    const { sort = '-createdAt' } = options
+    const path = '/api/v1/accounts'
+
+    return this.getRequestBody<ResultList<Account>>({
+      ...options,
+
+      path,
+      query: { sort },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  get (options: OverrideCommandOptions & {
+    accountName: string
+  }) {
+    const path = '/api/v1/accounts/' + options.accountName
+
+    return this.getRequestBody<Account>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listRatings (options: OverrideCommandOptions & {
+    accountName: string
+    rating?: VideoRateType
+  }) {
+    const { rating, accountName } = options
+    const path = '/api/v1/accounts/' + accountName + '/ratings'
+
+    const query = { rating }
+
+    return this.getRequestBody<ResultList<AccountVideoRate>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listFollowers (options: OverrideCommandOptions & {
+    accountName: string
+    start?: number
+    count?: number
+    sort?: string
+    search?: string
+  }) {
+    const { accountName, start, count, sort, search } = options
+    const path = '/api/v1/accounts/' + accountName + '/followers'
+
+    const query = { start, count, sort, search }
+
+    return this.getRequestBody<ResultList<ActorFollow>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/server-commands/users/actors.ts b/shared/server-commands/users/actors.ts
new file mode 100644
index 000000000..12c3e078a
--- /dev/null
+++ b/shared/server-commands/users/actors.ts
@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { pathExists, readdir } from 'fs-extra'
+import { join } from 'path'
+import { root } from '@shared/core-utils'
+import { Account, VideoChannel } from '@shared/models'
+import { PeerTubeServer } from '../server'
+
+async function expectChannelsFollows (options: {
+  server: PeerTubeServer
+  handle: string
+  followers: number
+  following: number
+}) {
+  const { server } = options
+  const { data } = await server.channels.list()
+
+  return expectActorFollow({ ...options, data })
+}
+
+async function expectAccountFollows (options: {
+  server: PeerTubeServer
+  handle: string
+  followers: number
+  following: number
+}) {
+  const { server } = options
+  const { data } = await server.accounts.list()
+
+  return expectActorFollow({ ...options, data })
+}
+
+async function checkActorFilesWereRemoved (filename: string, serverNumber: number) {
+  const testDirectory = 'test' + serverNumber
+
+  for (const directory of [ 'avatars' ]) {
+    const directoryPath = join(root(), testDirectory, directory)
+
+    const directoryExists = await pathExists(directoryPath)
+    expect(directoryExists).to.be.true
+
+    const files = await readdir(directoryPath)
+    for (const file of files) {
+      expect(file).to.not.contain(filename)
+    }
+  }
+}
+
+export {
+  expectAccountFollows,
+  expectChannelsFollows,
+  checkActorFilesWereRemoved
+}
+
+// ---------------------------------------------------------------------------
+
+function expectActorFollow (options: {
+  server: PeerTubeServer
+  data: (Account | VideoChannel)[]
+  handle: string
+  followers: number
+  following: number
+}) {
+  const { server, data, handle, followers, following } = options
+
+  const actor = data.find(a => a.name + '@' + a.host === handle)
+  const message = `${handle} on ${server.url}`
+
+  expect(actor, message).to.exist
+  expect(actor.followersCount).to.equal(followers, message)
+  expect(actor.followingCount).to.equal(following, message)
+}
diff --git a/shared/server-commands/users/blocklist-command.ts b/shared/server-commands/users/blocklist-command.ts
new file mode 100644
index 000000000..2e7ed074d
--- /dev/null
+++ b/shared/server-commands/users/blocklist-command.ts
@@ -0,0 +1,162 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { AccountBlock, BlockStatus, HttpStatusCode, ResultList, ServerBlock } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+type ListBlocklistOptions = OverrideCommandOptions & {
+  start: number
+  count: number
+  sort: string // default -createdAt
+}
+
+export class BlocklistCommand extends AbstractCommand {
+
+  listMyAccountBlocklist (options: ListBlocklistOptions) {
+    const path = '/api/v1/users/me/blocklist/accounts'
+
+    return this.listBlocklist<AccountBlock>(options, path)
+  }
+
+  listMyServerBlocklist (options: ListBlocklistOptions) {
+    const path = '/api/v1/users/me/blocklist/servers'
+
+    return this.listBlocklist<ServerBlock>(options, path)
+  }
+
+  listServerAccountBlocklist (options: ListBlocklistOptions) {
+    const path = '/api/v1/server/blocklist/accounts'
+
+    return this.listBlocklist<AccountBlock>(options, path)
+  }
+
+  listServerServerBlocklist (options: ListBlocklistOptions) {
+    const path = '/api/v1/server/blocklist/servers'
+
+    return this.listBlocklist<ServerBlock>(options, path)
+  }
+
+  // ---------------------------------------------------------------------------
+
+  getStatus (options: OverrideCommandOptions & {
+    accounts?: string[]
+    hosts?: string[]
+  }) {
+    const { accounts, hosts } = options
+
+    const path = '/api/v1/blocklist/status'
+
+    return this.getRequestBody<BlockStatus>({
+      ...options,
+
+      path,
+      query: {
+        accounts,
+        hosts
+      },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  addToMyBlocklist (options: OverrideCommandOptions & {
+    account?: string
+    server?: string
+  }) {
+    const { account, server } = options
+
+    const path = account
+      ? '/api/v1/users/me/blocklist/accounts'
+      : '/api/v1/users/me/blocklist/servers'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        accountName: account,
+        host: server
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  addToServerBlocklist (options: OverrideCommandOptions & {
+    account?: string
+    server?: string
+  }) {
+    const { account, server } = options
+
+    const path = account
+      ? '/api/v1/server/blocklist/accounts'
+      : '/api/v1/server/blocklist/servers'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        accountName: account,
+        host: server
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  removeFromMyBlocklist (options: OverrideCommandOptions & {
+    account?: string
+    server?: string
+  }) {
+    const { account, server } = options
+
+    const path = account
+      ? '/api/v1/users/me/blocklist/accounts/' + account
+      : '/api/v1/users/me/blocklist/servers/' + server
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  removeFromServerBlocklist (options: OverrideCommandOptions & {
+    account?: string
+    server?: string
+  }) {
+    const { account, server } = options
+
+    const path = account
+      ? '/api/v1/server/blocklist/accounts/' + account
+      : '/api/v1/server/blocklist/servers/' + server
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  private listBlocklist <T> (options: ListBlocklistOptions, path: string) {
+    const { start, count, sort = '-createdAt' } = options
+
+    return this.getRequestBody<ResultList<T>>({
+      ...options,
+
+      path,
+      query: { start, count, sort },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+}
diff --git a/shared/server-commands/users/index.ts b/shared/server-commands/users/index.ts
new file mode 100644
index 000000000..460a06f70
--- /dev/null
+++ b/shared/server-commands/users/index.ts
@@ -0,0 +1,9 @@
+export * from './accounts-command'
+export * from './actors'
+export * from './blocklist-command'
+export * from './login'
+export * from './login-command'
+export * from './notifications'
+export * from './notifications-command'
+export * from './subscriptions-command'
+export * from './users-command'
diff --git a/shared/server-commands/users/login-command.ts b/shared/server-commands/users/login-command.ts
new file mode 100644
index 000000000..143f72a59
--- /dev/null
+++ b/shared/server-commands/users/login-command.ts
@@ -0,0 +1,132 @@
+import { HttpStatusCode, PeerTubeProblemDocument } from '@shared/models'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class LoginCommand extends AbstractCommand {
+
+  login (options: OverrideCommandOptions & {
+    client?: { id?: string, secret?: string }
+    user?: { username: string, password?: string }
+  } = {}) {
+    const { client = this.server.store.client, user = this.server.store.user } = options
+    const path = '/api/v1/users/token'
+
+    const body = {
+      client_id: client.id,
+      client_secret: client.secret,
+      username: user.username,
+      password: user.password ?? 'password',
+      response_type: 'code',
+      grant_type: 'password',
+      scope: 'upload'
+    }
+
+    return unwrapBody<{ access_token: string, refresh_token: string } & PeerTubeProblemDocument>(this.postBodyRequest({
+      ...options,
+
+      path,
+      requestType: 'form',
+      fields: body,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+
+  getAccessToken (arg1?: { username: string, password?: string }): Promise<string>
+  getAccessToken (arg1: string, password?: string): Promise<string>
+  async getAccessToken (arg1?: { username: string, password?: string } | string, password?: string) {
+    let user: { username: string, password?: string }
+
+    if (!arg1) user = this.server.store.user
+    else if (typeof arg1 === 'object') user = arg1
+    else user = { username: arg1, password }
+
+    try {
+      const body = await this.login({ user })
+
+      return body.access_token
+    } catch (err) {
+      throw new Error(`Cannot authenticate. Please check your username/password. (${err})`)
+    }
+  }
+
+  loginUsingExternalToken (options: OverrideCommandOptions & {
+    username: string
+    externalAuthToken: string
+  }) {
+    const { username, externalAuthToken } = options
+    const path = '/api/v1/users/token'
+
+    const body = {
+      client_id: this.server.store.client.id,
+      client_secret: this.server.store.client.secret,
+      username: username,
+      response_type: 'code',
+      grant_type: 'password',
+      scope: 'upload',
+      externalAuthToken
+    }
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      requestType: 'form',
+      fields: body,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  logout (options: OverrideCommandOptions & {
+    token: string
+  }) {
+    const path = '/api/v1/users/revoke-token'
+
+    return unwrapBody<{ redirectUrl: string }>(this.postBodyRequest({
+      ...options,
+
+      path,
+      requestType: 'form',
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+
+  refreshToken (options: OverrideCommandOptions & {
+    refreshToken: string
+  }) {
+    const path = '/api/v1/users/token'
+
+    const body = {
+      client_id: this.server.store.client.id,
+      client_secret: this.server.store.client.secret,
+      refresh_token: options.refreshToken,
+      response_type: 'code',
+      grant_type: 'refresh_token'
+    }
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      requestType: 'form',
+      fields: body,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getClient (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/oauth-clients/local'
+
+    return this.getRequestBody<{ client_id: string, client_secret: string }>({
+      ...options,
+
+      path,
+      host: this.server.host,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/server-commands/users/login.ts b/shared/server-commands/users/login.ts
new file mode 100644
index 000000000..f1df027d3
--- /dev/null
+++ b/shared/server-commands/users/login.ts
@@ -0,0 +1,19 @@
+import { PeerTubeServer } from '../server/server'
+
+function setAccessTokensToServers (servers: PeerTubeServer[]) {
+  const tasks: Promise<any>[] = []
+
+  for (const server of servers) {
+    const p = server.login.getAccessToken()
+                                 .then(t => { server.accessToken = t })
+    tasks.push(p)
+  }
+
+  return Promise.all(tasks)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  setAccessTokensToServers
+}
diff --git a/shared/server-commands/users/notifications-command.ts b/shared/server-commands/users/notifications-command.ts
new file mode 100644
index 000000000..692420b8b
--- /dev/null
+++ b/shared/server-commands/users/notifications-command.ts
@@ -0,0 +1,86 @@
+import { HttpStatusCode, ResultList } from '@shared/models'
+import { UserNotification, UserNotificationSetting } from '../../models/users'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class NotificationsCommand extends AbstractCommand {
+
+  updateMySettings (options: OverrideCommandOptions & {
+    settings: UserNotificationSetting
+  }) {
+    const path = '/api/v1/users/me/notification-settings'
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: options.settings,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  list (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    unread?: boolean
+    sort?: string
+  }) {
+    const { start, count, unread, sort = '-createdAt' } = options
+    const path = '/api/v1/users/me/notifications'
+
+    return this.getRequestBody<ResultList<UserNotification>>({
+      ...options,
+
+      path,
+      query: {
+        start,
+        count,
+        sort,
+        unread
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  markAsRead (options: OverrideCommandOptions & {
+    ids: number[]
+  }) {
+    const { ids } = options
+    const path = '/api/v1/users/me/notifications/read'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { ids },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  markAsReadAll (options: OverrideCommandOptions) {
+    const path = '/api/v1/users/me/notifications/read-all'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  async getLatest (options: OverrideCommandOptions = {}) {
+    const { total, data } = await this.list({
+      ...options,
+      start: 0,
+      count: 1,
+      sort: '-createdAt'
+    })
+
+    if (total === 0) return undefined
+
+    return data[0]
+  }
+}
diff --git a/shared/server-commands/users/notifications.ts b/shared/server-commands/users/notifications.ts
new file mode 100644
index 000000000..07ccb0f8d
--- /dev/null
+++ b/shared/server-commands/users/notifications.ts
@@ -0,0 +1,795 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { inspect } from 'util'
+import { AbuseState, PluginType } from '@shared/models'
+import { UserNotification, UserNotificationSetting, UserNotificationSettingValue, UserNotificationType } from '../../models/users'
+import { MockSmtpServer } from '../mock-servers/mock-email'
+import { PeerTubeServer } from '../server'
+import { doubleFollow } from '../server/follows'
+import { createMultipleServers } from '../server/servers'
+import { setAccessTokensToServers } from './login'
+
+type CheckerBaseParams = {
+  server: PeerTubeServer
+  emails: any[]
+  socketNotifications: UserNotification[]
+  token: string
+  check?: { web: boolean, mail: boolean }
+}
+
+type CheckerType = 'presence' | 'absence'
+
+function getAllNotificationsSettings (): UserNotificationSetting {
+  return {
+    newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newCommentOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    abuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    myVideoImportFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    myVideoPublished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    commentMention: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newFollow: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newInstanceFollower: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    abuseNewMessage: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    autoInstanceFollowing: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newPluginVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
+  }
+}
+
+async function checkNewVideoFromSubscription (options: CheckerBaseParams & {
+  videoName: string
+  shortUUID: string
+  checkType: CheckerType
+}) {
+  const { videoName, shortUUID } = options
+  const notificationType = UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      checkVideo(notification.video, videoName, shortUUID)
+      checkActor(notification.video.channel)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.type !== UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION || n.video.name !== videoName
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+    return text.indexOf(shortUUID) !== -1 && text.indexOf('Your subscription') !== -1
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkVideoIsPublished (options: CheckerBaseParams & {
+  videoName: string
+  shortUUID: string
+  checkType: CheckerType
+}) {
+  const { videoName, shortUUID } = options
+  const notificationType = UserNotificationType.MY_VIDEO_PUBLISHED
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      checkVideo(notification.video, videoName, shortUUID)
+      checkActor(notification.video.channel)
+    } else {
+      expect(notification.video).to.satisfy(v => v === undefined || v.name !== videoName)
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text: string = email['text']
+    return text.includes(shortUUID) && text.includes('Your video')
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkMyVideoImportIsFinished (options: CheckerBaseParams & {
+  videoName: string
+  shortUUID: string
+  url: string
+  success: boolean
+  checkType: CheckerType
+}) {
+  const { videoName, shortUUID, url, success } = options
+
+  const notificationType = success ? UserNotificationType.MY_VIDEO_IMPORT_SUCCESS : UserNotificationType.MY_VIDEO_IMPORT_ERROR
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      expect(notification.videoImport.targetUrl).to.equal(url)
+
+      if (success) checkVideo(notification.videoImport.video, videoName, shortUUID)
+    } else {
+      expect(notification.videoImport).to.satisfy(i => i === undefined || i.targetUrl !== url)
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text: string = email['text']
+    const toFind = success ? ' finished' : ' error'
+
+    return text.includes(url) && text.includes(toFind)
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkUserRegistered (options: CheckerBaseParams & {
+  username: string
+  checkType: CheckerType
+}) {
+  const { username } = options
+  const notificationType = UserNotificationType.NEW_USER_REGISTRATION
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      checkActor(notification.account)
+      expect(notification.account.name).to.equal(username)
+    } else {
+      expect(notification).to.satisfy(n => n.type !== notificationType || n.account.name !== username)
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text: string = email['text']
+
+    return text.includes(' registered.') && text.includes(username)
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkNewActorFollow (options: CheckerBaseParams & {
+  followType: 'channel' | 'account'
+  followerName: string
+  followerDisplayName: string
+  followingDisplayName: string
+  checkType: CheckerType
+}) {
+  const { followType, followerName, followerDisplayName, followingDisplayName } = options
+  const notificationType = UserNotificationType.NEW_FOLLOW
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      checkActor(notification.actorFollow.follower)
+      expect(notification.actorFollow.follower.displayName).to.equal(followerDisplayName)
+      expect(notification.actorFollow.follower.name).to.equal(followerName)
+      expect(notification.actorFollow.follower.host).to.not.be.undefined
+
+      const following = notification.actorFollow.following
+      expect(following.displayName).to.equal(followingDisplayName)
+      expect(following.type).to.equal(followType)
+    } else {
+      expect(notification).to.satisfy(n => {
+        return n.type !== notificationType ||
+          (n.actorFollow.follower.name !== followerName && n.actorFollow.following !== followingDisplayName)
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text: string = email['text']
+
+    return text.includes(followType) && text.includes(followingDisplayName) && text.includes(followerDisplayName)
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkNewInstanceFollower (options: CheckerBaseParams & {
+  followerHost: string
+  checkType: CheckerType
+}) {
+  const { followerHost } = options
+  const notificationType = UserNotificationType.NEW_INSTANCE_FOLLOWER
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      checkActor(notification.actorFollow.follower)
+      expect(notification.actorFollow.follower.name).to.equal('peertube')
+      expect(notification.actorFollow.follower.host).to.equal(followerHost)
+
+      expect(notification.actorFollow.following.name).to.equal('peertube')
+    } else {
+      expect(notification).to.satisfy(n => {
+        return n.type !== notificationType || n.actorFollow.follower.host !== followerHost
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text: string = email['text']
+
+    return text.includes('instance has a new follower') && text.includes(followerHost)
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkAutoInstanceFollowing (options: CheckerBaseParams & {
+  followerHost: string
+  followingHost: string
+  checkType: CheckerType
+}) {
+  const { followerHost, followingHost } = options
+  const notificationType = UserNotificationType.AUTO_INSTANCE_FOLLOWING
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      const following = notification.actorFollow.following
+      checkActor(following)
+      expect(following.name).to.equal('peertube')
+      expect(following.host).to.equal(followingHost)
+
+      expect(notification.actorFollow.follower.name).to.equal('peertube')
+      expect(notification.actorFollow.follower.host).to.equal(followerHost)
+    } else {
+      expect(notification).to.satisfy(n => {
+        return n.type !== notificationType || n.actorFollow.following.host !== followingHost
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text: string = email['text']
+
+    return text.includes(' automatically followed a new instance') && text.includes(followingHost)
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkCommentMention (options: CheckerBaseParams & {
+  shortUUID: string
+  commentId: number
+  threadId: number
+  byAccountDisplayName: string
+  checkType: CheckerType
+}) {
+  const { shortUUID, commentId, threadId, byAccountDisplayName } = options
+  const notificationType = UserNotificationType.COMMENT_MENTION
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      checkComment(notification.comment, commentId, threadId)
+      checkActor(notification.comment.account)
+      expect(notification.comment.account.displayName).to.equal(byAccountDisplayName)
+
+      checkVideo(notification.comment.video, undefined, shortUUID)
+    } else {
+      expect(notification).to.satisfy(n => n.type !== notificationType || n.comment.id !== commentId)
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text: string = email['text']
+
+    return text.includes(' mentioned ') && text.includes(shortUUID) && text.includes(byAccountDisplayName)
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+let lastEmailCount = 0
+
+async function checkNewCommentOnMyVideo (options: CheckerBaseParams & {
+  shortUUID: string
+  commentId: number
+  threadId: number
+  checkType: CheckerType
+}) {
+  const { server, shortUUID, commentId, threadId, checkType, emails } = options
+  const notificationType = UserNotificationType.NEW_COMMENT_ON_MY_VIDEO
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      checkComment(notification.comment, commentId, threadId)
+      checkActor(notification.comment.account)
+      checkVideo(notification.comment.video, undefined, shortUUID)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.comment === undefined || n.comment.id !== commentId
+      })
+    }
+  }
+
+  const commentUrl = `http://localhost:${server.port}/w/${shortUUID};threadId=${threadId}`
+
+  function emailNotificationFinder (email: object) {
+    return email['text'].indexOf(commentUrl) !== -1
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+
+  if (checkType === 'presence') {
+    // We cannot detect email duplicates, so check we received another email
+    expect(emails).to.have.length.above(lastEmailCount)
+    lastEmailCount = emails.length
+  }
+}
+
+async function checkNewVideoAbuseForModerators (options: CheckerBaseParams & {
+  shortUUID: string
+  videoName: string
+  checkType: CheckerType
+}) {
+  const { shortUUID, videoName } = options
+  const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      expect(notification.abuse.id).to.be.a('number')
+      checkVideo(notification.abuse.video, videoName, shortUUID)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.abuse === undefined || n.abuse.video.shortUUID !== shortUUID
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+    return text.indexOf(shortUUID) !== -1 && text.indexOf('abuse') !== -1
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkNewAbuseMessage (options: CheckerBaseParams & {
+  abuseId: number
+  message: string
+  toEmail: string
+  checkType: CheckerType
+}) {
+  const { abuseId, message, toEmail } = options
+  const notificationType = UserNotificationType.ABUSE_NEW_MESSAGE
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      expect(notification.abuse.id).to.equal(abuseId)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.type !== notificationType || n.abuse === undefined || n.abuse.id !== abuseId
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+    const to = email['to'].filter(t => t.address === toEmail)
+
+    return text.indexOf(message) !== -1 && to.length !== 0
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkAbuseStateChange (options: CheckerBaseParams & {
+  abuseId: number
+  state: AbuseState
+  checkType: CheckerType
+}) {
+  const { abuseId, state } = options
+  const notificationType = UserNotificationType.ABUSE_STATE_CHANGE
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      expect(notification.abuse.id).to.equal(abuseId)
+      expect(notification.abuse.state).to.equal(state)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.abuse === undefined || n.abuse.id !== abuseId
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+
+    const contains = state === AbuseState.ACCEPTED
+      ? ' accepted'
+      : ' rejected'
+
+    return text.indexOf(contains) !== -1
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkNewCommentAbuseForModerators (options: CheckerBaseParams & {
+  shortUUID: string
+  videoName: string
+  checkType: CheckerType
+}) {
+  const { shortUUID, videoName } = options
+  const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      expect(notification.abuse.id).to.be.a('number')
+      checkVideo(notification.abuse.comment.video, videoName, shortUUID)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.abuse === undefined || n.abuse.comment.video.shortUUID !== shortUUID
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+    return text.indexOf(shortUUID) !== -1 && text.indexOf('abuse') !== -1
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkNewAccountAbuseForModerators (options: CheckerBaseParams & {
+  displayName: string
+  checkType: CheckerType
+}) {
+  const { displayName } = options
+  const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      expect(notification.abuse.id).to.be.a('number')
+      expect(notification.abuse.account.displayName).to.equal(displayName)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.abuse === undefined || n.abuse.account.displayName !== displayName
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+    return text.indexOf(displayName) !== -1 && text.indexOf('abuse') !== -1
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkVideoAutoBlacklistForModerators (options: CheckerBaseParams & {
+  shortUUID: string
+  videoName: string
+  checkType: CheckerType
+}) {
+  const { shortUUID, videoName } = options
+  const notificationType = UserNotificationType.VIDEO_AUTO_BLACKLIST_FOR_MODERATORS
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      expect(notification.videoBlacklist.video.id).to.be.a('number')
+      checkVideo(notification.videoBlacklist.video, videoName, shortUUID)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.video === undefined || n.video.shortUUID !== shortUUID
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+    return text.indexOf(shortUUID) !== -1 && email['text'].indexOf('video-auto-blacklist/list') !== -1
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkNewBlacklistOnMyVideo (options: CheckerBaseParams & {
+  shortUUID: string
+  videoName: string
+  blacklistType: 'blacklist' | 'unblacklist'
+}) {
+  const { videoName, shortUUID, blacklistType } = options
+  const notificationType = blacklistType === 'blacklist'
+    ? UserNotificationType.BLACKLIST_ON_MY_VIDEO
+    : UserNotificationType.UNBLACKLIST_ON_MY_VIDEO
+
+  function notificationChecker (notification: UserNotification) {
+    expect(notification).to.not.be.undefined
+    expect(notification.type).to.equal(notificationType)
+
+    const video = blacklistType === 'blacklist' ? notification.videoBlacklist.video : notification.video
+
+    checkVideo(video, videoName, shortUUID)
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+    const blacklistText = blacklistType === 'blacklist'
+      ? 'blacklisted'
+      : 'unblacklisted'
+
+    return text.includes(shortUUID) && text.includes(blacklistText)
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder, checkType: 'presence' })
+}
+
+async function checkNewPeerTubeVersion (options: CheckerBaseParams & {
+  latestVersion: string
+  checkType: CheckerType
+}) {
+  const { latestVersion } = options
+  const notificationType = UserNotificationType.NEW_PEERTUBE_VERSION
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      expect(notification.peertube).to.exist
+      expect(notification.peertube.latestVersion).to.equal(latestVersion)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.peertube === undefined || n.peertube.latestVersion !== latestVersion
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+
+    return text.includes(latestVersion)
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function checkNewPluginVersion (options: CheckerBaseParams & {
+  pluginType: PluginType
+  pluginName: string
+  checkType: CheckerType
+}) {
+  const { pluginName, pluginType } = options
+  const notificationType = UserNotificationType.NEW_PLUGIN_VERSION
+
+  function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+    if (checkType === 'presence') {
+      expect(notification).to.not.be.undefined
+      expect(notification.type).to.equal(notificationType)
+
+      expect(notification.plugin.name).to.equal(pluginName)
+      expect(notification.plugin.type).to.equal(pluginType)
+    } else {
+      expect(notification).to.satisfy((n: UserNotification) => {
+        return n === undefined || n.plugin === undefined || n.plugin.name !== pluginName
+      })
+    }
+  }
+
+  function emailNotificationFinder (email: object) {
+    const text = email['text']
+
+    return text.includes(pluginName)
+  }
+
+  await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
+async function prepareNotificationsTest (serversCount = 3, overrideConfigArg: any = {}) {
+  const userNotifications: UserNotification[] = []
+  const adminNotifications: UserNotification[] = []
+  const adminNotificationsServer2: UserNotification[] = []
+  const emails: object[] = []
+
+  const port = await MockSmtpServer.Instance.collectEmails(emails)
+
+  const overrideConfig = {
+    smtp: {
+      hostname: 'localhost',
+      port
+    },
+    signup: {
+      limit: 20
+    }
+  }
+  const servers = await createMultipleServers(serversCount, Object.assign(overrideConfig, overrideConfigArg))
+
+  await setAccessTokensToServers(servers)
+
+  if (serversCount > 1) {
+    await doubleFollow(servers[0], servers[1])
+  }
+
+  const user = { username: 'user_1', password: 'super password' }
+  await servers[0].users.create({ ...user, videoQuota: 10 * 1000 * 1000 })
+  const userAccessToken = await servers[0].login.getAccessToken(user)
+
+  await servers[0].notifications.updateMySettings({ token: userAccessToken, settings: getAllNotificationsSettings() })
+  await servers[0].notifications.updateMySettings({ settings: getAllNotificationsSettings() })
+
+  if (serversCount > 1) {
+    await servers[1].notifications.updateMySettings({ settings: getAllNotificationsSettings() })
+  }
+
+  {
+    const socket = servers[0].socketIO.getUserNotificationSocket({ token: userAccessToken })
+    socket.on('new-notification', n => userNotifications.push(n))
+  }
+  {
+    const socket = servers[0].socketIO.getUserNotificationSocket()
+    socket.on('new-notification', n => adminNotifications.push(n))
+  }
+
+  if (serversCount > 1) {
+    const socket = servers[1].socketIO.getUserNotificationSocket()
+    socket.on('new-notification', n => adminNotificationsServer2.push(n))
+  }
+
+  const { videoChannels } = await servers[0].users.getMyInfo()
+  const channelId = videoChannels[0].id
+
+  return {
+    userNotifications,
+    adminNotifications,
+    adminNotificationsServer2,
+    userAccessToken,
+    emails,
+    servers,
+    channelId
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  getAllNotificationsSettings,
+
+  CheckerBaseParams,
+  CheckerType,
+  checkMyVideoImportIsFinished,
+  checkUserRegistered,
+  checkAutoInstanceFollowing,
+  checkVideoIsPublished,
+  checkNewVideoFromSubscription,
+  checkNewActorFollow,
+  checkNewCommentOnMyVideo,
+  checkNewBlacklistOnMyVideo,
+  checkCommentMention,
+  checkNewVideoAbuseForModerators,
+  checkVideoAutoBlacklistForModerators,
+  checkNewAbuseMessage,
+  checkAbuseStateChange,
+  checkNewInstanceFollower,
+  prepareNotificationsTest,
+  checkNewCommentAbuseForModerators,
+  checkNewAccountAbuseForModerators,
+  checkNewPeerTubeVersion,
+  checkNewPluginVersion
+}
+
+// ---------------------------------------------------------------------------
+
+async function checkNotification (options: CheckerBaseParams & {
+  notificationChecker: (notification: UserNotification, checkType: CheckerType) => void
+  emailNotificationFinder: (email: object) => boolean
+  checkType: CheckerType
+}) {
+  const { server, token, checkType, notificationChecker, emailNotificationFinder, socketNotifications, emails } = options
+
+  const check = options.check || { web: true, mail: true }
+
+  if (check.web) {
+    const notification = await server.notifications.getLatest({ token: token })
+
+    if (notification || checkType !== 'absence') {
+      notificationChecker(notification, checkType)
+    }
+
+    const socketNotification = socketNotifications.find(n => {
+      try {
+        notificationChecker(n, 'presence')
+        return true
+      } catch {
+        return false
+      }
+    })
+
+    if (checkType === 'presence') {
+      const obj = inspect(socketNotifications, { depth: 5 })
+      expect(socketNotification, 'The socket notification is absent when it should be present. ' + obj).to.not.be.undefined
+    } else {
+      const obj = inspect(socketNotification, { depth: 5 })
+      expect(socketNotification, 'The socket notification is present when it should not be present. ' + obj).to.be.undefined
+    }
+  }
+
+  if (check.mail) {
+    // Last email
+    const email = emails
+                      .slice()
+                      .reverse()
+                      .find(e => emailNotificationFinder(e))
+
+    if (checkType === 'presence') {
+      const texts = emails.map(e => e.text)
+      expect(email, 'The email is absent when is should be present. ' + inspect(texts)).to.not.be.undefined
+    } else {
+      expect(email, 'The email is present when is should not be present. ' + inspect(email)).to.be.undefined
+    }
+  }
+}
+
+function checkVideo (video: any, videoName?: string, shortUUID?: string) {
+  if (videoName) {
+    expect(video.name).to.be.a('string')
+    expect(video.name).to.not.be.empty
+    expect(video.name).to.equal(videoName)
+  }
+
+  if (shortUUID) {
+    expect(video.shortUUID).to.be.a('string')
+    expect(video.shortUUID).to.not.be.empty
+    expect(video.shortUUID).to.equal(shortUUID)
+  }
+
+  expect(video.id).to.be.a('number')
+}
+
+function checkActor (actor: any) {
+  expect(actor.displayName).to.be.a('string')
+  expect(actor.displayName).to.not.be.empty
+  expect(actor.host).to.not.be.undefined
+}
+
+function checkComment (comment: any, commentId: number, threadId: number) {
+  expect(comment.id).to.equal(commentId)
+  expect(comment.threadId).to.equal(threadId)
+}
diff --git a/shared/server-commands/users/subscriptions-command.ts b/shared/server-commands/users/subscriptions-command.ts
new file mode 100644
index 000000000..edc60e612
--- /dev/null
+++ b/shared/server-commands/users/subscriptions-command.ts
@@ -0,0 +1,99 @@
+import { HttpStatusCode, ResultList, Video, VideoChannel } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class SubscriptionsCommand extends AbstractCommand {
+
+  add (options: OverrideCommandOptions & {
+    targetUri: string
+  }) {
+    const path = '/api/v1/users/me/subscriptions'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { uri: options.targetUri },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  list (options: OverrideCommandOptions & {
+    sort?: string // default -createdAt
+    search?: string
+  } = {}) {
+    const { sort = '-createdAt', search } = options
+    const path = '/api/v1/users/me/subscriptions'
+
+    return this.getRequestBody<ResultList<VideoChannel>>({
+      ...options,
+
+      path,
+      query: {
+        sort,
+        search
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listVideos (options: OverrideCommandOptions & {
+    sort?: string // default -createdAt
+  } = {}) {
+    const { sort = '-createdAt' } = options
+    const path = '/api/v1/users/me/subscriptions/videos'
+
+    return this.getRequestBody<ResultList<Video>>({
+      ...options,
+
+      path,
+      query: { sort },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  get (options: OverrideCommandOptions & {
+    uri: string
+  }) {
+    const path = '/api/v1/users/me/subscriptions/' + options.uri
+
+    return this.getRequestBody<VideoChannel>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  remove (options: OverrideCommandOptions & {
+    uri: string
+  }) {
+    const path = '/api/v1/users/me/subscriptions/' + options.uri
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  exist (options: OverrideCommandOptions & {
+    uris: string[]
+  }) {
+    const path = '/api/v1/users/me/subscriptions/exist'
+
+    return this.getRequestBody<{ [id: string ]: boolean }>({
+      ...options,
+
+      path,
+      query: { 'uris[]': options.uris },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/server-commands/users/users-command.ts b/shared/server-commands/users/users-command.ts
new file mode 100644
index 000000000..90c5f2183
--- /dev/null
+++ b/shared/server-commands/users/users-command.ts
@@ -0,0 +1,416 @@
+import { omit } from 'lodash'
+import { pick } from '@shared/core-utils'
+import {
+  HttpStatusCode,
+  MyUser,
+  ResultList,
+  User,
+  UserAdminFlag,
+  UserCreateResult,
+  UserRole,
+  UserUpdate,
+  UserUpdateMe,
+  UserVideoQuota,
+  UserVideoRate
+} from '@shared/models'
+import { ScopedToken } from '@shared/models/users/user-scoped-token'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class UsersCommand extends AbstractCommand {
+
+  askResetPassword (options: OverrideCommandOptions & {
+    email: string
+  }) {
+    const { email } = options
+    const path = '/api/v1/users/ask-reset-password'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { email },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  resetPassword (options: OverrideCommandOptions & {
+    userId: number
+    verificationString: string
+    password: string
+  }) {
+    const { userId, verificationString, password } = options
+    const path = '/api/v1/users/' + userId + '/reset-password'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { password, verificationString },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  askSendVerifyEmail (options: OverrideCommandOptions & {
+    email: string
+  }) {
+    const { email } = options
+    const path = '/api/v1/users/ask-send-verify-email'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { email },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  verifyEmail (options: OverrideCommandOptions & {
+    userId: number
+    verificationString: string
+    isPendingEmail?: boolean // default false
+  }) {
+    const { userId, verificationString, isPendingEmail = false } = options
+    const path = '/api/v1/users/' + userId + '/verify-email'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        verificationString,
+        isPendingEmail
+      },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  banUser (options: OverrideCommandOptions & {
+    userId: number
+    reason?: string
+  }) {
+    const { userId, reason } = options
+    const path = '/api/v1/users' + '/' + userId + '/block'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { reason },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  unbanUser (options: OverrideCommandOptions & {
+    userId: number
+  }) {
+    const { userId } = options
+    const path = '/api/v1/users' + '/' + userId + '/unblock'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  getMyScopedTokens (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/scoped-tokens'
+
+    return this.getRequestBody<ScopedToken>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  renewMyScopedTokens (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/scoped-tokens'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  create (options: OverrideCommandOptions & {
+    username: string
+    password?: string
+    videoQuota?: number
+    videoQuotaDaily?: number
+    role?: UserRole
+    adminFlags?: UserAdminFlag
+  }) {
+    const {
+      username,
+      adminFlags,
+      password = 'password',
+      videoQuota = 42000000,
+      videoQuotaDaily = -1,
+      role = UserRole.USER
+    } = options
+
+    const path = '/api/v1/users'
+
+    return unwrapBody<{ user: UserCreateResult }>(this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        username,
+        password,
+        role,
+        adminFlags,
+        email: username + '@example.com',
+        videoQuota,
+        videoQuotaDaily
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })).then(res => res.user)
+  }
+
+  async generate (username: string, role?: UserRole) {
+    const password = 'password'
+    const user = await this.create({ username, password, role })
+
+    const token = await this.server.login.getAccessToken({ username, password })
+
+    const me = await this.getMyInfo({ token })
+
+    return {
+      token,
+      userId: user.id,
+      userChannelId: me.videoChannels[0].id,
+      userChannelName: me.videoChannels[0].name
+    }
+  }
+
+  async generateUserAndToken (username: string, role?: UserRole) {
+    const password = 'password'
+    await this.create({ username, password, role })
+
+    return this.server.login.getAccessToken({ username, password })
+  }
+
+  register (options: OverrideCommandOptions & {
+    username: string
+    password?: string
+    displayName?: string
+    channel?: {
+      name: string
+      displayName: string
+    }
+  }) {
+    const { username, password = 'password', displayName, channel } = options
+    const path = '/api/v1/users/register'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        username,
+        password,
+        email: username + '@example.com',
+        displayName,
+        channel
+      },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  getMyInfo (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/me'
+
+    return this.getRequestBody<MyUser>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getMyQuotaUsed (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/me/video-quota-used'
+
+    return this.getRequestBody<UserVideoQuota>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getMyRating (options: OverrideCommandOptions & {
+    videoId: number | string
+  }) {
+    const { videoId } = options
+    const path = '/api/v1/users/me/videos/' + videoId + '/rating'
+
+    return this.getRequestBody<UserVideoRate>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  deleteMe (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/me'
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  updateMe (options: OverrideCommandOptions & UserUpdateMe) {
+    const path = '/api/v1/users/me'
+
+    const toSend: UserUpdateMe = omit(options, 'url', 'accessToken')
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: toSend,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  updateMyAvatar (options: OverrideCommandOptions & {
+    fixture: string
+  }) {
+    const { fixture } = options
+    const path = '/api/v1/users/me/avatar/pick'
+
+    return this.updateImageRequest({
+      ...options,
+
+      path,
+      fixture,
+      fieldname: 'avatarfile',
+
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  get (options: OverrideCommandOptions & {
+    userId: number
+    withStats?: boolean // default false
+  }) {
+    const { userId, withStats } = options
+    const path = '/api/v1/users/' + userId
+
+    return this.getRequestBody<User>({
+      ...options,
+
+      path,
+      query: { withStats },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  list (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+    search?: string
+    blocked?: boolean
+  } = {}) {
+    const path = '/api/v1/users'
+
+    return this.getRequestBody<ResultList<User>>({
+      ...options,
+
+      path,
+      query: pick(options, [ 'start', 'count', 'sort', 'search', 'blocked' ]),
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  remove (options: OverrideCommandOptions & {
+    userId: number
+  }) {
+    const { userId } = options
+    const path = '/api/v1/users/' + userId
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  update (options: OverrideCommandOptions & {
+    userId: number
+    email?: string
+    emailVerified?: boolean
+    videoQuota?: number
+    videoQuotaDaily?: number
+    password?: string
+    adminFlags?: UserAdminFlag
+    pluginAuth?: string
+    role?: UserRole
+  }) {
+    const path = '/api/v1/users/' + options.userId
+
+    const toSend: UserUpdate = {}
+    if (options.password !== undefined && options.password !== null) toSend.password = options.password
+    if (options.email !== undefined && options.email !== null) toSend.email = options.email
+    if (options.emailVerified !== undefined && options.emailVerified !== null) toSend.emailVerified = options.emailVerified
+    if (options.videoQuota !== undefined && options.videoQuota !== null) toSend.videoQuota = options.videoQuota
+    if (options.videoQuotaDaily !== undefined && options.videoQuotaDaily !== null) toSend.videoQuotaDaily = options.videoQuotaDaily
+    if (options.role !== undefined && options.role !== null) toSend.role = options.role
+    if (options.adminFlags !== undefined && options.adminFlags !== null) toSend.adminFlags = options.adminFlags
+    if (options.pluginAuth !== undefined) toSend.pluginAuth = options.pluginAuth
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: toSend,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}