server/models/server/server-blocklist.ts

   1 import { BelongsTo, Column, CreatedAt, ForeignKey, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
   2 import { AccountModel } from '../account/account'
   3 import { ServerModel } from './server'
   4 import { ServerBlock } from '../../../shared/models/blocklist'
   5 import { getSort, searchAttribute } from '../utils'
   6 import * as Bluebird from 'bluebird'
   7 import { MServerBlocklist, MServerBlocklistAccountServer, MServerBlocklistFormattable } from '@server/typings/models'
   8 import { Op } from 'sequelize'
   9
  10 enum ScopeNames {
  11   WITH_ACCOUNT = 'WITH_ACCOUNT',
  12   WITH_SERVER = 'WITH_SERVER'
  13 }
  14
  15 @Scopes(() => ({
  16   [ScopeNames.WITH_ACCOUNT]: {
  17     include: [
  18       {
  19         model: AccountModel,
  20         required: true
  21       }
  22     ]
  23   },
  24   [ScopeNames.WITH_SERVER]: {
  25     include: [
  26       {
  27         model: ServerModel,
  28         required: true
  29       }
  30     ]
  31   }
  32 }))
  33
  34 @Table({
  35   tableName: 'serverBlocklist',
  36   indexes: [
  37     {
  38       fields: [ 'accountId', 'targetServerId' ],
  39       unique: true
  40     },
  41     {
  42       fields: [ 'targetServerId' ]
  43     }
  44   ]
  45 })
  46 export class ServerBlocklistModel extends Model<ServerBlocklistModel> {
  47
  48   @CreatedAt
  49   createdAt: Date
  50
  51   @UpdatedAt
  52   updatedAt: Date
  53
  54   @ForeignKey(() => AccountModel)
  55   @Column
  56   accountId: number
  57
  58   @BelongsTo(() => AccountModel, {
  59     foreignKey: {
  60       name: 'accountId',
  61       allowNull: false
  62     },
  63     onDelete: 'CASCADE'
  64   })
  65   ByAccount: AccountModel
  66
  67   @ForeignKey(() => ServerModel)
  68   @Column
  69   targetServerId: number
  70
  71   @BelongsTo(() => ServerModel, {
  72     foreignKey: {
  73       allowNull: false
  74     },
  75     onDelete: 'CASCADE'
  76   })
  77   BlockedServer: ServerModel
  78
  79   static isServerMutedByMulti (accountIds: number[], targetServerId: number) {
  80     const query = {
  81       attributes: [ 'accountId', 'id' ],
  82       where: {
  83         accountId: {
  84           [Op.in]: accountIds
  85         },
  86         targetServerId
  87       },
  88       raw: true
  89     }
  90
  91     return ServerBlocklistModel.unscoped()
  92                                 .findAll(query)
  93                                 .then(rows => {
  94                                   const result: { [accountId: number]: boolean } = {}
  95
  96                                   for (const accountId of accountIds) {
  97                                     result[accountId] = !!rows.find(r => r.accountId === accountId)
  98                                   }
  99
 100                                   return result
 101                                 })
 102   }
 103
 104   static loadByAccountAndHost (accountId: number, host: string): Bluebird<MServerBlocklist> {
 105     const query = {
 106       where: {
 107         accountId
 108       },
 109       include: [
 110         {
 111           model: ServerModel,
 112           where: {
 113             host
 114           },
 115           required: true
 116         }
 117       ]
 118     }
 119
 120     return ServerBlocklistModel.findOne(query)
 121   }
 122
 123   static listForApi (parameters: {
 124     start: number
 125     count: number
 126     sort: string
 127     search?: string
 128     accountId: number
 129   }) {
 130     const { start, count, sort, search, accountId } = parameters
 131
 132     const query = {
 133       offset: start,
 134       limit: count,
 135       order: getSort(sort),
 136       where: {
 137         accountId,
 138         ...searchAttribute(search, '$BlockedServer.host$')
 139       }
 140     }
 141
 142     return ServerBlocklistModel
 143       .scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_SERVER ])
 144       .findAndCountAll<MServerBlocklistAccountServer>(query)
 145       .then(({ rows, count }) => {
 146         return { total: count, data: rows }
 147       })
 148   }
 149
 150   toFormattedJSON (this: MServerBlocklistFormattable): ServerBlock {
 151     return {
 152       byAccount: this.ByAccount.toFormattedJSON(),
 153       blockedServer: this.BlockedServer.toFormattedJSON(),
 154       createdAt: this.createdAt
 155     }
 156   }
 157 }