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 "actorFollow"."actorId" = ' + 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 loadByIdAndPopulateAccount (id: number) {
 300     return VideoChannelModel.unscoped()
 301       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 302       .findById(id)
 303   }
 304
 305   static loadByIdAndAccount (id: number, accountId: number) {
 306     const query = {
 307       where: {
 308         id,
 309         accountId
 310       }
 311     }
 312
 313     return VideoChannelModel.unscoped()
 314       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 315       .findOne(query)
 316   }
 317
 318   static loadAndPopulateAccount (id: number) {
 319     return VideoChannelModel.unscoped()
 320       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 321       .findById(id)
 322   }
 323
 324   static loadByUUIDAndPopulateAccount (uuid: string) {
 325     const query = {
 326       include: [
 327         {
 328           model: ActorModel,
 329           required: true,
 330           where: {
 331             uuid
 332           }
 333         }
 334       ]
 335     }
 336
 337     return VideoChannelModel
 338       .scope([ ScopeNames.WITH_ACCOUNT ])
 339       .findOne(query)
 340   }
 341
 342   static loadByUrlAndPopulateAccount (url: string) {
 343     const query = {
 344       include: [
 345         {
 346           model: ActorModel,
 347           required: true,
 348           where: {
 349             url
 350           }
 351         }
 352       ]
 353     }
 354
 355     return VideoChannelModel
 356       .scope([ ScopeNames.WITH_ACCOUNT ])
 357       .findOne(query)
 358   }
 359
 360   static loadLocalByNameAndPopulateAccount (name: string) {
 361     const query = {
 362       include: [
 363         {
 364           model: ActorModel,
 365           required: true,
 366           where: {
 367             preferredUsername: name,
 368             serverId: null
 369           }
 370         }
 371       ]
 372     }
 373
 374     return VideoChannelModel.unscoped()
 375       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 376       .findOne(query)
 377   }
 378
 379   static loadByNameAndHostAndPopulateAccount (name: string, host: string) {
 380     const query = {
 381       include: [
 382         {
 383           model: ActorModel,
 384           required: true,
 385           where: {
 386             preferredUsername: name
 387           },
 388           include: [
 389             {
 390               model: ServerModel,
 391               required: true,
 392               where: { host }
 393             }
 394           ]
 395         }
 396       ]
 397     }
 398
 399     return VideoChannelModel.unscoped()
 400       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 401       .findOne(query)
 402   }
 403
 404   static loadAndPopulateAccountAndVideos (id: number) {
 405     const options = {
 406       include: [
 407         VideoModel
 408       ]
 409     }
 410
 411     return VideoChannelModel.unscoped()
 412       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ])
 413       .findById(id, options)
 414   }
 415
 416   toFormattedJSON (): VideoChannel {
 417     const actor = this.Actor.toFormattedJSON()
 418     const videoChannel = {
 419       id: this.id,
 420       displayName: this.getDisplayName(),
 421       description: this.description,
 422       support: this.support,
 423       isLocal: this.Actor.isOwned(),
 424       createdAt: this.createdAt,
 425       updatedAt: this.updatedAt,
 426       ownerAccount: undefined
 427     }
 428
 429     if (this.Account) videoChannel.ownerAccount = this.Account.toFormattedJSON()
 430
 431     return Object.assign(actor, videoChannel)
 432   }
 433
 434   toActivityPubObject (): ActivityPubActor {
 435     const obj = this.Actor.toActivityPubObject(this.name, 'VideoChannel')
 436
 437     return Object.assign(obj, {
 438       summary: this.description,
 439       support: this.support,
 440       attributedTo: [
 441         {
 442           type: 'Person' as 'Person',
 443           id: this.Account.Actor.url
 444         }
 445       ]
 446     })
 447   }
 448
 449   getDisplayName () {
 450     return this.name
 451   }
 452 }