Fix subscribe button responsive

[github/Chocobozzz/PeerTube.git] / server / models / account / account-blocklist.ts

diff --git a/server/models/account/account-blocklist.ts b/server/models/account/account-blocklist.ts
index b2375b00648ac8a79d2aa0e05750a64744c7321d..f6212ff6e9a11e43c5ca8bb5b7f58ac44b7f7135 100644 (file)
--- a/server/models/account/account-blocklist.ts
+++ b/server/models/account/account-blocklist.ts
@@ -1,34 +1,14 @@
-import { Op } from 'sequelize'
-import { BelongsTo, Column, CreatedAt, ForeignKey, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
-import { MAccountBlocklist, MAccountBlocklistAccounts, MAccountBlocklistFormattable } from '@server/types/models'
-import { AttributesOnly } from '@shared/core-utils'
+import { FindOptions, Op, QueryTypes } from 'sequelize'
+import { BelongsTo, Column, CreatedAt, ForeignKey, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { handlesToNameAndHost } from '@server/helpers/actors'
+import { MAccountBlocklist, MAccountBlocklistFormattable } from '@server/types/models'
+import { AttributesOnly } from '@shared/typescript-utils'
 import { AccountBlock } from '../../../shared/models'
 import { ActorModel } from '../actor/actor'
 import { ServerModel } from '../server/server'
-import { getSort, searchAttribute } from '../utils'
+import { createSafeIn, getSort, searchAttribute } from '../shared'
 import { AccountModel } from './account'
 
-enum ScopeNames {
-  WITH_ACCOUNTS = 'WITH_ACCOUNTS'
-}
-
-@Scopes(() => ({
-  [ScopeNames.WITH_ACCOUNTS]: {
-    include: [
-      {
-        model: AccountModel,
-        required: true,
-        as: 'ByAccount'
-      },
-      {
-        model: AccountModel,
-        required: true,
-        as: 'BlockedAccount'
-      }
-    ]
-  }
-}))
-
 @Table({
   tableName: 'accountBlocklist',
   indexes: [
@@ -77,7 +57,7 @@ export class AccountBlocklistModel extends Model<Partial<AttributesOnly<AccountB
   })
   BlockedAccount: AccountModel
 
-  static isAccountMutedByMulti (accountIds: number[], targetAccountId: number) {
+  static isAccountMutedByAccounts (accountIds: number[], targetAccountId: number) {
     const query = {
       attributes: [ 'accountId', 'id' ],
       where: {
@@ -122,33 +102,59 @@ export class AccountBlocklistModel extends Model<Partial<AttributesOnly<AccountB
   }) {
     const { start, count, sort, search, accountId } = parameters
 
-    const query = {
-      offset: start,
-      limit: count,
-      order: getSort(sort)
-    }
+    const getQuery = (forCount: boolean) => {
+      const query: FindOptions = {
+        offset: start,
+        limit: count,
+        order: getSort(sort),
+        where: { accountId }
+      }
 
-    const where = {
-      accountId
-    }
+      if (search) {
+        Object.assign(query.where, {
+          [Op.or]: [
+            searchAttribute(search, '$BlockedAccount.name$'),
+            searchAttribute(search, '$BlockedAccount.Actor.url$')
+          ]
+        })
+      }
 
-    if (search) {
-      Object.assign(where, {
-        [Op.or]: [
-          searchAttribute(search, '$BlockedAccount.name$'),
-          searchAttribute(search, '$BlockedAccount.Actor.url$')
+      if (forCount !== true) {
+        query.include = [
+          {
+            model: AccountModel,
+            required: true,
+            as: 'ByAccount'
+          },
+          {
+            model: AccountModel,
+            required: true,
+            as: 'BlockedAccount'
+          }
         ]
-      })
-    }
+      } else if (search) { // We need some joins when counting with search
+        query.include = [
+          {
+            model: AccountModel.unscoped(),
+            required: true,
+            as: 'BlockedAccount',
+            include: [
+              {
+                model: ActorModel.unscoped(),
+                required: true
+              }
+            ]
+          }
+        ]
+      }
 
-    Object.assign(query, { where })
+      return query
+    }
 
-    return AccountBlocklistModel
-      .scope([ ScopeNames.WITH_ACCOUNTS ])
-      .findAndCountAll<MAccountBlocklistAccounts>(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    return Promise.all([
+      AccountBlocklistModel.count(getQuery(true)),
+      AccountBlocklistModel.findAll(getQuery(false))
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listHandlesBlockedBy (accountIds: number[]): Promise<string[]> {
@@ -187,6 +193,39 @@ export class AccountBlocklistModel extends Model<Partial<AttributesOnly<AccountB
       .then(entries => entries.map(e => `${e.BlockedAccount.Actor.preferredUsername}@${e.BlockedAccount.Actor.Server.host}`))
   }
 
+  static getBlockStatus (byAccountIds: number[], handles: string[]): Promise<{ name: string, host: string, accountId: number }[]> {
+    const sanitizedHandles = handlesToNameAndHost(handles)
+
+    const localHandles = sanitizedHandles.filter(h => !h.host)
+                                         .map(h => h.name)
+
+    const remoteHandles = sanitizedHandles.filter(h => !!h.host)
+                                          .map(h => ([ h.name, h.host ]))
+
+    const handlesWhere: string[] = []
+
+    if (localHandles.length !== 0) {
+      handlesWhere.push(`("actor"."preferredUsername" IN (:localHandles) AND "server"."id" IS NULL)`)
+    }
+
+    if (remoteHandles.length !== 0) {
+      handlesWhere.push(`(("actor"."preferredUsername", "server"."host") IN (:remoteHandles))`)
+    }
+
+    const rawQuery = `SELECT "accountBlocklist"."accountId", "actor"."preferredUsername" AS "name", "server"."host" ` +
+      `FROM "accountBlocklist" ` +
+      `INNER JOIN "account" ON "account"."id" = "accountBlocklist"."targetAccountId" ` +
+      `INNER JOIN "actor" ON "actor"."id" = "account"."actorId" ` +
+      `LEFT JOIN "server" ON "server"."id" = "actor"."serverId" ` +
+      `WHERE "accountBlocklist"."accountId" IN (${createSafeIn(AccountBlocklistModel.sequelize, byAccountIds)}) ` +
+      `AND (${handlesWhere.join(' OR ')})`
+
+    return AccountBlocklistModel.sequelize.query(rawQuery, {
+      type: QueryTypes.SELECT as QueryTypes.SELECT,
+      replacements: { byAccountIds, localHandles, remoteHandles }
+    })
+  }
+
   toFormattedJSON (this: MAccountBlocklistFormattable): AccountBlock {
     return {
       byAccount: this.ByAccount.toFormattedJSON(),