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 { CONFIG, 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 listLocalsForSitemap (sort: string) {
 237     const query = {
 238       attributes: [ ],
 239       offset: 0,
 240       order: getSort(sort),
 241       include: [
 242         {
 243           attributes: [ 'preferredUsername', 'serverId' ],
 244           model: ActorModel.unscoped(),
 245           where: {
 246             serverId: null
 247           }
 248         }
 249       ]
 250     }
 251
 252     return VideoChannelModel
 253       .unscoped()
 254       .findAll(query)
 255   }
 256
 257   static searchForApi (options: {
 258     actorId: number
 259     search: string
 260     start: number
 261     count: number
 262     sort: string
 263   }) {
 264     const attributesInclude = []
 265     const escapedSearch = VideoModel.sequelize.escape(options.search)
 266     const escapedLikeSearch = VideoModel.sequelize.escape('%' + options.search + '%')
 267     attributesInclude.push(createSimilarityAttribute('VideoChannelModel.name', options.search))
 268
 269     const query = {
 270       attributes: {
 271         include: attributesInclude
 272       },
 273       offset: options.start,
 274       limit: options.count,
 275       order: getSort(options.sort),
 276       where: {
 277         [Sequelize.Op.or]: [
 278           Sequelize.literal(
 279             'lower(immutable_unaccent("VideoChannelModel"."name")) % lower(immutable_unaccent(' + escapedSearch + '))'
 280           ),
 281           Sequelize.literal(
 282             'lower(immutable_unaccent("VideoChannelModel"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))'
 283           )
 284         ]
 285       }
 286     }
 287
 288     const scopes = {
 289       method: [ ScopeNames.AVAILABLE_FOR_LIST, { actorId: options.actorId } as AvailableForListOptions ]
 290     }
 291     return VideoChannelModel
 292       .scope(scopes)
 293       .findAndCountAll(query)
 294       .then(({ rows, count }) => {
 295         return { total: count, data: rows }
 296       })
 297   }
 298
 299   static listByAccount (accountId: number) {
 300     const query = {
 301       order: getSort('createdAt'),
 302       include: [
 303         {
 304           model: AccountModel,
 305           where: {
 306             id: accountId
 307           },
 308           required: true
 309         }
 310       ]
 311     }
 312
 313     return VideoChannelModel
 314       .findAndCountAll(query)
 315       .then(({ rows, count }) => {
 316         return { total: count, data: rows }
 317       })
 318   }
 319
 320   static loadByIdAndPopulateAccount (id: number) {
 321     return VideoChannelModel.unscoped()
 322       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 323       .findById(id)
 324   }
 325
 326   static loadByIdAndAccount (id: number, accountId: number) {
 327     const query = {
 328       where: {
 329         id,
 330         accountId
 331       }
 332     }
 333
 334     return VideoChannelModel.unscoped()
 335       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 336       .findOne(query)
 337   }
 338
 339   static loadAndPopulateAccount (id: number) {
 340     return VideoChannelModel.unscoped()
 341       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 342       .findById(id)
 343   }
 344
 345   static loadByUUIDAndPopulateAccount (uuid: string) {
 346     const query = {
 347       include: [
 348         {
 349           model: ActorModel,
 350           required: true,
 351           where: {
 352             uuid
 353           }
 354         }
 355       ]
 356     }
 357
 358     return VideoChannelModel
 359       .scope([ ScopeNames.WITH_ACCOUNT ])
 360       .findOne(query)
 361   }
 362
 363   static loadByUrlAndPopulateAccount (url: string) {
 364     const query = {
 365       include: [
 366         {
 367           model: ActorModel,
 368           required: true,
 369           where: {
 370             url
 371           }
 372         }
 373       ]
 374     }
 375
 376     return VideoChannelModel
 377       .scope([ ScopeNames.WITH_ACCOUNT ])
 378       .findOne(query)
 379   }
 380
 381   static loadByNameWithHostAndPopulateAccount (nameWithHost: string) {
 382     const [ name, host ] = nameWithHost.split('@')
 383
 384     if (!host || host === CONFIG.WEBSERVER.HOST) return VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
 385
 386     return VideoChannelModel.loadByNameAndHostAndPopulateAccount(name, host)
 387   }
 388
 389   static loadLocalByNameAndPopulateAccount (name: string) {
 390     const query = {
 391       include: [
 392         {
 393           model: ActorModel,
 394           required: true,
 395           where: {
 396             preferredUsername: name,
 397             serverId: null
 398           }
 399         }
 400       ]
 401     }
 402
 403     return VideoChannelModel.unscoped()
 404       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 405       .findOne(query)
 406   }
 407
 408   static loadByNameAndHostAndPopulateAccount (name: string, host: string) {
 409     const query = {
 410       include: [
 411         {
 412           model: ActorModel,
 413           required: true,
 414           where: {
 415             preferredUsername: name
 416           },
 417           include: [
 418             {
 419               model: ServerModel,
 420               required: true,
 421               where: { host }
 422             }
 423           ]
 424         }
 425       ]
 426     }
 427
 428     return VideoChannelModel.unscoped()
 429       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 430       .findOne(query)
 431   }
 432
 433   static loadAndPopulateAccountAndVideos (id: number) {
 434     const options = {
 435       include: [
 436         VideoModel
 437       ]
 438     }
 439
 440     return VideoChannelModel.unscoped()
 441       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ])
 442       .findById(id, options)
 443   }
 444
 445   toFormattedJSON (): VideoChannel {
 446     const actor = this.Actor.toFormattedJSON()
 447     const videoChannel = {
 448       id: this.id,
 449       displayName: this.getDisplayName(),
 450       description: this.description,
 451       support: this.support,
 452       isLocal: this.Actor.isOwned(),
 453       createdAt: this.createdAt,
 454       updatedAt: this.updatedAt,
 455       ownerAccount: undefined
 456     }
 457
 458     if (this.Account) videoChannel.ownerAccount = this.Account.toFormattedJSON()
 459
 460     return Object.assign(actor, videoChannel)
 461   }
 462
 463   toActivityPubObject (): ActivityPubActor {
 464     const obj = this.Actor.toActivityPubObject(this.name, 'VideoChannel')
 465
 466     return Object.assign(obj, {
 467       summary: this.description,
 468       support: this.support,
 469       attributedTo: [
 470         {
 471           type: 'Person' as 'Person',
 472           id: this.Account.Actor.url
 473         }
 474       ]
 475     })
 476   }
 477
 478   getDisplayName () {
 479     return this.name
 480   }
 481
 482   isOutdated () {
 483     return this.Actor.isOutdated()
 484   }
 485 }