server/models/video/video-channel.ts

   1 import {
   2   AllowNull,
   3   BeforeDestroy,
   4   BelongsTo,
   5   Column,
   6   CreatedAt,
   7   DataType,
   8   Default,
   9   DefaultScope,
  10   ForeignKey,
  11   HasMany,
  12   Is,
  13   Model,
  14   Scopes,
  15   Sequelize,
  16   Table,
  17   UpdatedAt
  18 } from 'sequelize-typescript'
  19 import { ActivityPubActor } from '../../../shared/models/activitypub'
  20 import { VideoChannel } from '../../../shared/models/videos'
  21 import {
  22   isVideoChannelDescriptionValid,
  23   isVideoChannelNameValid,
  24   isVideoChannelSupportValid
  25 } from '../../helpers/custom-validators/video-channels'
  26 import { sendDeleteActor } from '../../lib/activitypub/send'
  27 import { AccountModel } from '../account/account'
  28 import { ActorModel, unusedActorAttributesForAPI } from '../activitypub/actor'
  29 import { buildTrigramSearchIndex, createSimilarityAttribute, getSort, throwIfNotValid } from '../utils'
  30 import { VideoModel } from './video'
  31 import { CONSTRAINTS_FIELDS } from '../../initializers'
  32 import { ServerModel } from '../server/server'
  33 import { DefineIndexesOptions } from 'sequelize'
  34
  35 // FIXME: Define indexes here because there is an issue with TS and Sequelize.literal when called directly in the annotation
  36 const indexes: DefineIndexesOptions[] = [
  37   buildTrigramSearchIndex('video_channel_name_trigram', 'name'),
  38
  39   {
  40     fields: [ 'accountId' ]
  41   },
  42   {
  43     fields: [ 'actorId' ]
  44   }
  45 ]
  46
  47 enum ScopeNames {
  48   AVAILABLE_FOR_LIST = 'AVAILABLE_FOR_LIST',
  49   WITH_ACCOUNT = 'WITH_ACCOUNT',
  50   WITH_ACTOR = 'WITH_ACTOR',
  51   WITH_VIDEOS = 'WITH_VIDEOS'
  52 }
  53
  54 type AvailableForListOptions = {
  55   actorId: number
  56 }
  57
  58 @DefaultScope({
  59   include: [
  60     {
  61       model: () => ActorModel,
  62       required: true
  63     }
  64   ]
  65 })
  66 @Scopes({
  67   [ScopeNames.AVAILABLE_FOR_LIST]: (options: AvailableForListOptions) => {
  68     const actorIdNumber = parseInt(options.actorId + '', 10)
  69
  70     // Only list local channels OR channels that are on an instance followed by actorId
  71     const inQueryInstanceFollow = '(' +
  72       'SELECT "actor"."serverId" FROM "actorFollow" ' +
  73       'INNER JOIN "actor" ON actor.id=  "actorFollow"."targetActorId" ' +
  74       'WHERE "actor"."id" = ' + actorIdNumber +
  75     ')'
  76
  77     return {
  78       include: [
  79         {
  80           attributes: {
  81             exclude: unusedActorAttributesForAPI
  82           },
  83           model: ActorModel,
  84           where: {
  85             [Sequelize.Op.or]: [
  86               {
  87                 serverId: null
  88               },
  89               {
  90                 serverId: {
  91                   [ Sequelize.Op.in ]: Sequelize.literal(inQueryInstanceFollow)
  92                 }
  93               }
  94             ]
  95           }
  96         },
  97         {
  98           model: AccountModel,
  99           required: true,
 100           include: [
 101             {
 102               attributes: {
 103                 exclude: unusedActorAttributesForAPI
 104               },
 105               model: ActorModel, // Default scope includes avatar and server
 106               required: true
 107             }
 108           ]
 109         }
 110       ]
 111     }
 112   },
 113   [ScopeNames.WITH_ACCOUNT]: {
 114     include: [
 115       {
 116         model: () => AccountModel,
 117         required: true
 118       }
 119     ]
 120   },
 121   [ScopeNames.WITH_VIDEOS]: {
 122     include: [
 123       () => VideoModel
 124     ]
 125   },
 126   [ScopeNames.WITH_ACTOR]: {
 127     include: [
 128       () => ActorModel
 129     ]
 130   }
 131 })
 132 @Table({
 133   tableName: 'videoChannel',
 134   indexes
 135 })
 136 export class VideoChannelModel extends Model<VideoChannelModel> {
 137
 138   @AllowNull(false)
 139   @Is('VideoChannelName', value => throwIfNotValid(value, isVideoChannelNameValid, 'name'))
 140   @Column
 141   name: string
 142
 143   @AllowNull(true)
 144   @Default(null)
 145   @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description'))
 146   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.DESCRIPTION.max))
 147   description: string
 148
 149   @AllowNull(true)
 150   @Default(null)
 151   @Is('VideoChannelSupport', value => throwIfNotValid(value, isVideoChannelSupportValid, 'support'))
 152   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.SUPPORT.max))
 153   support: string
 154
 155   @CreatedAt
 156   createdAt: Date
 157
 158   @UpdatedAt
 159   updatedAt: Date
 160
 161   @ForeignKey(() => ActorModel)
 162   @Column
 163   actorId: number
 164
 165   @BelongsTo(() => ActorModel, {
 166     foreignKey: {
 167       allowNull: false
 168     },
 169     onDelete: 'cascade'
 170   })
 171   Actor: ActorModel
 172
 173   @ForeignKey(() => AccountModel)
 174   @Column
 175   accountId: number
 176
 177   @BelongsTo(() => AccountModel, {
 178     foreignKey: {
 179       allowNull: false
 180     },
 181     hooks: true
 182   })
 183   Account: AccountModel
 184
 185   @HasMany(() => VideoModel, {
 186     foreignKey: {
 187       name: 'channelId',
 188       allowNull: false
 189     },
 190     onDelete: 'CASCADE',
 191     hooks: true
 192   })
 193   Videos: VideoModel[]
 194
 195   @BeforeDestroy
 196   static async sendDeleteIfOwned (instance: VideoChannelModel, options) {
 197     if (!instance.Actor) {
 198       instance.Actor = await instance.$get('Actor', { transaction: options.transaction }) as ActorModel
 199     }
 200
 201     if (instance.Actor.isOwned()) {
 202       return sendDeleteActor(instance.Actor, options.transaction)
 203     }
 204
 205     return undefined
 206   }
 207
 208   static countByAccount (accountId: number) {
 209     const query = {
 210       where: {
 211         accountId
 212       }
 213     }
 214
 215     return VideoChannelModel.count(query)
 216   }
 217
 218   static listForApi (actorId: number, start: number, count: number, sort: string) {
 219     const query = {
 220       offset: start,
 221       limit: count,
 222       order: getSort(sort)
 223     }
 224
 225     const scopes = {
 226       method: [ ScopeNames.AVAILABLE_FOR_LIST, { actorId } as AvailableForListOptions ]
 227     }
 228     return VideoChannelModel
 229       .scope(scopes)
 230       .findAndCountAll(query)
 231       .then(({ rows, count }) => {
 232         return { total: count, data: rows }
 233       })
 234   }
 235
 236   static searchForApi (options: {
 237     actorId: number
 238     search: string
 239     start: number
 240     count: number
 241     sort: string
 242   }) {
 243     const attributesInclude = []
 244     const escapedSearch = VideoModel.sequelize.escape(options.search)
 245     const escapedLikeSearch = VideoModel.sequelize.escape('%' + options.search + '%')
 246     attributesInclude.push(createSimilarityAttribute('VideoChannelModel.name', options.search))
 247
 248     const query = {
 249       attributes: {
 250         include: attributesInclude
 251       },
 252       offset: options.start,
 253       limit: options.count,
 254       order: getSort(options.sort),
 255       where: {
 256         [Sequelize.Op.or]: [
 257           Sequelize.literal(
 258             'lower(immutable_unaccent("VideoChannelModel"."name")) % lower(immutable_unaccent(' + escapedSearch + '))'
 259           ),
 260           Sequelize.literal(
 261             'lower(immutable_unaccent("VideoChannelModel"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))'
 262           )
 263         ]
 264       }
 265     }
 266
 267     const scopes = {
 268       method: [ ScopeNames.AVAILABLE_FOR_LIST, { actorId: options.actorId } as AvailableForListOptions ]
 269     }
 270     return VideoChannelModel
 271       .scope(scopes)
 272       .findAndCountAll(query)
 273       .then(({ rows, count }) => {
 274         return { total: count, data: rows }
 275       })
 276   }
 277
 278   static listByAccount (accountId: number) {
 279     const query = {
 280       order: getSort('createdAt'),
 281       include: [
 282         {
 283           model: AccountModel,
 284           where: {
 285             id: accountId
 286           },
 287           required: true
 288         }
 289       ]
 290     }
 291
 292     return VideoChannelModel
 293       .findAndCountAll(query)
 294       .then(({ rows, count }) => {
 295         return { total: count, data: rows }
 296       })
 297   }
 298
 299   static loadByIdAndAccount (id: number, accountId: number) {
 300     const query = {
 301       where: {
 302         id,
 303         accountId
 304       }
 305     }
 306
 307     return VideoChannelModel
 308       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 309       .findOne(query)
 310   }
 311
 312   static loadAndPopulateAccount (id: number) {
 313     return VideoChannelModel
 314       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 315       .findById(id)
 316   }
 317
 318   static loadByUUIDAndPopulateAccount (uuid: string) {
 319     const query = {
 320       include: [
 321         {
 322           model: ActorModel,
 323           required: true,
 324           where: {
 325             uuid
 326           }
 327         }
 328       ]
 329     }
 330
 331     return VideoChannelModel
 332       .scope([ ScopeNames.WITH_ACCOUNT ])
 333       .findOne(query)
 334   }
 335
 336   static loadByUrlAndPopulateAccount (url: string) {
 337     const query = {
 338       include: [
 339         {
 340           model: ActorModel,
 341           required: true,
 342           where: {
 343             url
 344           }
 345         }
 346       ]
 347     }
 348
 349     return VideoChannelModel
 350       .scope([ ScopeNames.WITH_ACCOUNT ])
 351       .findOne(query)
 352   }
 353
 354   static loadLocalByNameAndPopulateAccount (name: string) {
 355     const query = {
 356       include: [
 357         {
 358           model: ActorModel,
 359           required: true,
 360           where: {
 361             preferredUsername: name,
 362             serverId: null
 363           }
 364         }
 365       ]
 366     }
 367
 368     return VideoChannelModel
 369       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 370       .findOne(query)
 371   }
 372
 373   static loadByNameAndHostAndPopulateAccount (name: string, host: string) {
 374     const query = {
 375       include: [
 376         {
 377           model: ActorModel,
 378           required: true,
 379           where: {
 380             preferredUsername: name
 381           },
 382           include: [
 383             {
 384               model: ServerModel,
 385               required: true,
 386               where: { host }
 387             }
 388           ]
 389         }
 390       ]
 391     }
 392
 393     return VideoChannelModel
 394       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 395       .findOne(query)
 396   }
 397
 398   static loadAndPopulateAccountAndVideos (id: number) {
 399     const options = {
 400       include: [
 401         VideoModel
 402       ]
 403     }
 404
 405     return VideoChannelModel
 406       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ])
 407       .findById(id, options)
 408   }
 409
 410   toFormattedJSON (): VideoChannel {
 411     const actor = this.Actor.toFormattedJSON()
 412     const videoChannel = {
 413       id: this.id,
 414       displayName: this.getDisplayName(),
 415       description: this.description,
 416       support: this.support,
 417       isLocal: this.Actor.isOwned(),
 418       createdAt: this.createdAt,
 419       updatedAt: this.updatedAt,
 420       ownerAccount: undefined
 421     }
 422
 423     if (this.Account) videoChannel.ownerAccount = this.Account.toFormattedJSON()
 424
 425     return Object.assign(actor, videoChannel)
 426   }
 427
 428   toActivityPubObject (): ActivityPubActor {
 429     const obj = this.Actor.toActivityPubObject(this.name, 'VideoChannel')
 430
 431     return Object.assign(obj, {
 432       summary: this.description,
 433       support: this.support,
 434       attributedTo: [
 435         {
 436           type: 'Person' as 'Person',
 437           id: this.Account.Actor.url
 438         }
 439       ]
 440     })
 441   }
 442
 443   getDisplayName () {
 444     return this.name
 445   }
 446 }