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, VideoChannelSummary } 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, ScopeNames as AccountModelScopeNames, SummaryOptions as AccountSummaryOptions } from '../account/account'
  28 import { ActorModel, unusedActorAttributesForAPI } from '../activitypub/actor'
  29 import { buildServerIdsFollowedBy, buildTrigramSearchIndex, createSimilarityAttribute, getSort, throwIfNotValid } from '../utils'
  30 import { VideoModel } from './video'
  31 import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
  32 import { ServerModel } from '../server/server'
  33 import { FindOptions, Op, literal, ScopeOptions } from 'sequelize'
  34 import { AvatarModel } from '../avatar/avatar'
  35 import { VideoPlaylistModel } from './video-playlist'
  36 import * as Bluebird from 'bluebird'
  37 import {
  38   MChannelAccountDefault,
  39   MChannelActor,
  40   MChannelActorAccountDefaultVideos,
  41   MChannelAP,
  42   MChannelFormattable,
  43   MChannelSummaryFormattable
  44 } from '../../typings/models/video'
  45
  46 export enum ScopeNames {
  47   FOR_API = 'FOR_API',
  48   SUMMARY = 'SUMMARY',
  49   WITH_ACCOUNT = 'WITH_ACCOUNT',
  50   WITH_ACTOR = 'WITH_ACTOR',
  51   WITH_VIDEOS = 'WITH_VIDEOS',
  52   WITH_STATS = 'WITH_STATS'
  53 }
  54
  55 type AvailableForListOptions = {
  56   actorId: number
  57 }
  58
  59 type AvailableWithStatsOptions = {
  60   daysPrior: number
  61 }
  62
  63 export type SummaryOptions = {
  64   withAccount?: boolean // Default: false
  65   withAccountBlockerIds?: number[]
  66 }
  67
  68 @DefaultScope(() => ({
  69   include: [
  70     {
  71       model: ActorModel,
  72       required: true
  73     }
  74   ]
  75 }))
  76 @Scopes(() => ({
  77   [ScopeNames.FOR_API]: (options: AvailableForListOptions) => {
  78     // Only list local channels OR channels that are on an instance followed by actorId
  79     const inQueryInstanceFollow = buildServerIdsFollowedBy(options.actorId)
  80
  81     return {
  82       include: [
  83         {
  84           attributes: {
  85             exclude: unusedActorAttributesForAPI
  86           },
  87           model: ActorModel,
  88           where: {
  89             [Op.or]: [
  90               {
  91                 serverId: null
  92               },
  93               {
  94                 serverId: {
  95                   [Op.in]: Sequelize.literal(inQueryInstanceFollow)
  96                 }
  97               }
  98             ]
  99           }
 100         },
 101         {
 102           model: AccountModel,
 103           required: true,
 104           include: [
 105             {
 106               attributes: {
 107                 exclude: unusedActorAttributesForAPI
 108               },
 109               model: ActorModel, // Default scope includes avatar and server
 110               required: true
 111             }
 112           ]
 113         }
 114       ]
 115     }
 116   },
 117   [ScopeNames.SUMMARY]: (options: SummaryOptions = {}) => {
 118     const base: FindOptions = {
 119       attributes: [ 'id', 'name', 'description', 'actorId' ],
 120       include: [
 121         {
 122           attributes: [ 'id', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
 123           model: ActorModel.unscoped(),
 124           required: true,
 125           include: [
 126             {
 127               attributes: [ 'host' ],
 128               model: ServerModel.unscoped(),
 129               required: false
 130             },
 131             {
 132               model: AvatarModel.unscoped(),
 133               required: false
 134             }
 135           ]
 136         }
 137       ]
 138     }
 139
 140     if (options.withAccount === true) {
 141       base.include.push({
 142         model: AccountModel.scope({
 143           method: [ AccountModelScopeNames.SUMMARY, { withAccountBlockerIds: options.withAccountBlockerIds } as AccountSummaryOptions ]
 144         }),
 145         required: true
 146       })
 147     }
 148
 149     return base
 150   },
 151   [ScopeNames.WITH_ACCOUNT]: {
 152     include: [
 153       {
 154         model: AccountModel,
 155         required: true
 156       }
 157     ]
 158   },
 159   [ScopeNames.WITH_ACTOR]: {
 160     include: [
 161       ActorModel
 162     ]
 163   },
 164   [ScopeNames.WITH_VIDEOS]: {
 165     include: [
 166       VideoModel
 167     ]
 168   },
 169   [ScopeNames.WITH_STATS]: (options: AvailableWithStatsOptions = { daysPrior: 30 }) => {
 170     const daysPrior = parseInt(options.daysPrior + '', 10)
 171
 172     return {
 173       attributes: {
 174         include: [
 175           [
 176             literal('(SELECT COUNT(*) FROM "video" WHERE "channelId" = "VideoChannelModel"."id")'),
 177             'videosCount'
 178           ],
 179           [
 180             literal(
 181               '(' +
 182               `SELECT string_agg(concat_ws('|', t.day, t.views), ',') ` +
 183               'FROM ( ' +
 184                 'WITH ' +
 185                   'days AS ( ' +
 186                     `SELECT generate_series(date_trunc('day', now()) - '${daysPrior} day'::interval, ` +
 187                           `date_trunc('day', now()), '1 day'::interval) AS day ` +
 188                   ') ' +
 189                   'SELECT days.day AS day, COALESCE(SUM("videoView".views), 0) AS views ' +
 190                   'FROM days ' +
 191                   'LEFT JOIN (' +
 192                     '"videoView" INNER JOIN "video" ON "videoView"."videoId" = "video"."id" ' +
 193                     'AND "video"."channelId" = "VideoChannelModel"."id"' +
 194                   `) ON date_trunc('day', "videoView"."startDate") = date_trunc('day', days.day) ` +
 195                   'GROUP BY day ' +
 196                   'ORDER BY day ' +
 197                 ') t' +
 198               ')'
 199             ),
 200             'viewsPerDay'
 201           ]
 202         ]
 203       }
 204     }
 205   }
 206 }))
 207 @Table({
 208   tableName: 'videoChannel',
 209   indexes: [
 210     buildTrigramSearchIndex('video_channel_name_trigram', 'name'),
 211
 212     {
 213       fields: [ 'accountId' ]
 214     },
 215     {
 216       fields: [ 'actorId' ]
 217     }
 218   ]
 219 })
 220 export class VideoChannelModel extends Model<VideoChannelModel> {
 221
 222   @AllowNull(false)
 223   @Is('VideoChannelName', value => throwIfNotValid(value, isVideoChannelNameValid, 'name'))
 224   @Column
 225   name: string
 226
 227   @AllowNull(true)
 228   @Default(null)
 229   @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description', true))
 230   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.DESCRIPTION.max))
 231   description: string
 232
 233   @AllowNull(true)
 234   @Default(null)
 235   @Is('VideoChannelSupport', value => throwIfNotValid(value, isVideoChannelSupportValid, 'support', true))
 236   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.SUPPORT.max))
 237   support: string
 238
 239   @CreatedAt
 240   createdAt: Date
 241
 242   @UpdatedAt
 243   updatedAt: Date
 244
 245   @ForeignKey(() => ActorModel)
 246   @Column
 247   actorId: number
 248
 249   @BelongsTo(() => ActorModel, {
 250     foreignKey: {
 251       allowNull: false
 252     },
 253     onDelete: 'cascade'
 254   })
 255   Actor: ActorModel
 256
 257   @ForeignKey(() => AccountModel)
 258   @Column
 259   accountId: number
 260
 261   @BelongsTo(() => AccountModel, {
 262     foreignKey: {
 263       allowNull: false
 264     },
 265     hooks: true
 266   })
 267   Account: AccountModel
 268
 269   @HasMany(() => VideoModel, {
 270     foreignKey: {
 271       name: 'channelId',
 272       allowNull: false
 273     },
 274     onDelete: 'CASCADE',
 275     hooks: true
 276   })
 277   Videos: VideoModel[]
 278
 279   @HasMany(() => VideoPlaylistModel, {
 280     foreignKey: {
 281       allowNull: true
 282     },
 283     onDelete: 'CASCADE',
 284     hooks: true
 285   })
 286   VideoPlaylists: VideoPlaylistModel[]
 287
 288   @BeforeDestroy
 289   static async sendDeleteIfOwned (instance: VideoChannelModel, options) {
 290     if (!instance.Actor) {
 291       instance.Actor = await instance.$get('Actor', { transaction: options.transaction })
 292     }
 293
 294     if (instance.Actor.isOwned()) {
 295       return sendDeleteActor(instance.Actor, options.transaction)
 296     }
 297
 298     return undefined
 299   }
 300
 301   static countByAccount (accountId: number) {
 302     const query = {
 303       where: {
 304         accountId
 305       }
 306     }
 307
 308     return VideoChannelModel.count(query)
 309   }
 310
 311   static listForApi (actorId: number, start: number, count: number, sort: string) {
 312     const query = {
 313       offset: start,
 314       limit: count,
 315       order: getSort(sort)
 316     }
 317
 318     const scopes = {
 319       method: [ ScopeNames.FOR_API, { actorId } as AvailableForListOptions ]
 320     }
 321     return VideoChannelModel
 322       .scope(scopes)
 323       .findAndCountAll(query)
 324       .then(({ rows, count }) => {
 325         return { total: count, data: rows }
 326       })
 327   }
 328
 329   static listLocalsForSitemap (sort: string): Bluebird<MChannelActor[]> {
 330     const query = {
 331       attributes: [ ],
 332       offset: 0,
 333       order: getSort(sort),
 334       include: [
 335         {
 336           attributes: [ 'preferredUsername', 'serverId' ],
 337           model: ActorModel.unscoped(),
 338           where: {
 339             serverId: null
 340           }
 341         }
 342       ]
 343     }
 344
 345     return VideoChannelModel
 346       .unscoped()
 347       .findAll(query)
 348   }
 349
 350   static searchForApi (options: {
 351     actorId: number
 352     search: string
 353     start: number
 354     count: number
 355     sort: string
 356   }) {
 357     const attributesInclude = []
 358     const escapedSearch = VideoModel.sequelize.escape(options.search)
 359     const escapedLikeSearch = VideoModel.sequelize.escape('%' + options.search + '%')
 360     attributesInclude.push(createSimilarityAttribute('VideoChannelModel.name', options.search))
 361
 362     const query = {
 363       attributes: {
 364         include: attributesInclude
 365       },
 366       offset: options.start,
 367       limit: options.count,
 368       order: getSort(options.sort),
 369       where: {
 370         [Op.or]: [
 371           Sequelize.literal(
 372             'lower(immutable_unaccent("VideoChannelModel"."name")) % lower(immutable_unaccent(' + escapedSearch + '))'
 373           ),
 374           Sequelize.literal(
 375             'lower(immutable_unaccent("VideoChannelModel"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))'
 376           )
 377         ]
 378       }
 379     }
 380
 381     const scopes = {
 382       method: [ ScopeNames.FOR_API, { actorId: options.actorId } as AvailableForListOptions ]
 383     }
 384     return VideoChannelModel
 385       .scope(scopes)
 386       .findAndCountAll(query)
 387       .then(({ rows, count }) => {
 388         return { total: count, data: rows }
 389       })
 390   }
 391
 392   static listByAccount (options: {
 393     accountId: number
 394     start: number
 395     count: number
 396     sort: string
 397     withStats?: boolean
 398   }) {
 399     const query = {
 400       offset: options.start,
 401       limit: options.count,
 402       order: getSort(options.sort),
 403       include: [
 404         {
 405           model: AccountModel,
 406           where: {
 407             id: options.accountId
 408           },
 409           required: true
 410         }
 411       ]
 412     }
 413
 414     const scopes: string | ScopeOptions | (string | ScopeOptions)[] = [ ScopeNames.WITH_ACTOR ]
 415
 416     if (options.withStats === true) {
 417       scopes.push({
 418         method: [ ScopeNames.WITH_STATS, { daysPrior: 30 } as AvailableWithStatsOptions ]
 419       })
 420     }
 421
 422     return VideoChannelModel
 423       .scope(scopes)
 424       .findAndCountAll(query)
 425       .then(({ rows, count }) => {
 426         return { total: count, data: rows }
 427       })
 428   }
 429
 430   static loadByIdAndPopulateAccount (id: number): Bluebird<MChannelAccountDefault> {
 431     return VideoChannelModel.unscoped()
 432       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 433       .findByPk(id)
 434   }
 435
 436   static loadByIdAndAccount (id: number, accountId: number): Bluebird<MChannelAccountDefault> {
 437     const query = {
 438       where: {
 439         id,
 440         accountId
 441       }
 442     }
 443
 444     return VideoChannelModel.unscoped()
 445       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 446       .findOne(query)
 447   }
 448
 449   static loadAndPopulateAccount (id: number): Bluebird<MChannelAccountDefault> {
 450     return VideoChannelModel.unscoped()
 451       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 452       .findByPk(id)
 453   }
 454
 455   static loadByUrlAndPopulateAccount (url: string): Bluebird<MChannelAccountDefault> {
 456     const query = {
 457       include: [
 458         {
 459           model: ActorModel,
 460           required: true,
 461           where: {
 462             url
 463           }
 464         }
 465       ]
 466     }
 467
 468     return VideoChannelModel
 469       .scope([ ScopeNames.WITH_ACCOUNT ])
 470       .findOne(query)
 471   }
 472
 473   static loadByNameWithHostAndPopulateAccount (nameWithHost: string) {
 474     const [ name, host ] = nameWithHost.split('@')
 475
 476     if (!host || host === WEBSERVER.HOST) return VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
 477
 478     return VideoChannelModel.loadByNameAndHostAndPopulateAccount(name, host)
 479   }
 480
 481   static loadLocalByNameAndPopulateAccount (name: string): Bluebird<MChannelAccountDefault> {
 482     const query = {
 483       include: [
 484         {
 485           model: ActorModel,
 486           required: true,
 487           where: {
 488             preferredUsername: name,
 489             serverId: null
 490           }
 491         }
 492       ]
 493     }
 494
 495     return VideoChannelModel.unscoped()
 496       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 497       .findOne(query)
 498   }
 499
 500   static loadByNameAndHostAndPopulateAccount (name: string, host: string): Bluebird<MChannelAccountDefault> {
 501     const query = {
 502       include: [
 503         {
 504           model: ActorModel,
 505           required: true,
 506           where: {
 507             preferredUsername: name
 508           },
 509           include: [
 510             {
 511               model: ServerModel,
 512               required: true,
 513               where: { host }
 514             }
 515           ]
 516         }
 517       ]
 518     }
 519
 520     return VideoChannelModel.unscoped()
 521       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 522       .findOne(query)
 523   }
 524
 525   static loadAndPopulateAccountAndVideos (id: number): Bluebird<MChannelActorAccountDefaultVideos> {
 526     const options = {
 527       include: [
 528         VideoModel
 529       ]
 530     }
 531
 532     return VideoChannelModel.unscoped()
 533       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ])
 534       .findByPk(id, options)
 535   }
 536
 537   toFormattedSummaryJSON (this: MChannelSummaryFormattable): VideoChannelSummary {
 538     const actor = this.Actor.toFormattedSummaryJSON()
 539
 540     return {
 541       id: this.id,
 542       name: actor.name,
 543       displayName: this.getDisplayName(),
 544       url: actor.url,
 545       host: actor.host,
 546       avatar: actor.avatar
 547     }
 548   }
 549
 550   toFormattedJSON (this: MChannelFormattable): VideoChannel {
 551     const viewsPerDayString = this.get('viewsPerDay') as string
 552     const videosCount = this.get('videosCount') as number
 553
 554     let viewsPerDay: { date: Date, views: number }[]
 555
 556     if (viewsPerDayString) {
 557       viewsPerDay = viewsPerDayString.split(',')
 558         .map(v => {
 559           const [ dateString, amount ] = v.split('|')
 560
 561           return {
 562             date: new Date(dateString),
 563             views: +amount
 564           }
 565         })
 566     }
 567
 568     const actor = this.Actor.toFormattedJSON()
 569     const videoChannel = {
 570       id: this.id,
 571       displayName: this.getDisplayName(),
 572       description: this.description,
 573       support: this.support,
 574       isLocal: this.Actor.isOwned(),
 575       createdAt: this.createdAt,
 576       updatedAt: this.updatedAt,
 577       ownerAccount: undefined,
 578       videosCount,
 579       viewsPerDay
 580     }
 581
 582     if (this.Account) videoChannel.ownerAccount = this.Account.toFormattedJSON()
 583
 584     return Object.assign(actor, videoChannel)
 585   }
 586
 587   toActivityPubObject (this: MChannelAP): ActivityPubActor {
 588     const obj = this.Actor.toActivityPubObject(this.name)
 589
 590     return Object.assign(obj, {
 591       summary: this.description,
 592       support: this.support,
 593       attributedTo: [
 594         {
 595           type: 'Person' as 'Person',
 596           id: this.Account.Actor.url
 597         }
 598       ]
 599     })
 600   }
 601
 602   getDisplayName () {
 603     return this.name
 604   }
 605
 606   isOutdated () {
 607     return this.Actor.isOutdated()
 608   }
 609 }