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     attributes: {
 171       include: [
 172         [
 173           literal(
 174             '(' +
 175             `SELECT string_agg(concat_ws('|', t.day, t.views), ',') ` +
 176             'FROM ( ' +
 177               'WITH ' +
 178                 'days AS ( ' +
 179                   `SELECT generate_series(date_trunc('day', now()) - '${options.daysPrior} day'::interval, ` +
 180                          `date_trunc('day', now()), '1 day'::interval) AS day ` +
 181                 '), ' +
 182                 'views AS ( ' +
 183                   'SELECT * ' +
 184                   'FROM "videoView" ' +
 185                   'WHERE "videoView"."videoId" IN ( ' +
 186                     'SELECT "video"."id" ' +
 187                     'FROM "video" ' +
 188                     'WHERE "video"."channelId" = "VideoChannelModel"."id" ' +
 189                   ') ' +
 190                 ') ' +
 191               'SELECT days.day AS day, ' +
 192                      'COALESCE(SUM(views.views), 0) AS views ' +
 193               'FROM days ' +
 194               `LEFT JOIN views ON date_trunc('day', "views"."createdAt") = days.day ` +
 195               'GROUP BY 1 ' +
 196               'ORDER BY day ' +
 197             ') t' +
 198             ')'
 199           ),
 200           'viewsPerDay'
 201         ]
 202       ]
 203     }
 204   })
 205 }))
 206 @Table({
 207   tableName: 'videoChannel',
 208   indexes: [
 209     buildTrigramSearchIndex('video_channel_name_trigram', 'name'),
 210
 211     {
 212       fields: [ 'accountId' ]
 213     },
 214     {
 215       fields: [ 'actorId' ]
 216     }
 217   ]
 218 })
 219 export class VideoChannelModel extends Model<VideoChannelModel> {
 220
 221   @AllowNull(false)
 222   @Is('VideoChannelName', value => throwIfNotValid(value, isVideoChannelNameValid, 'name'))
 223   @Column
 224   name: string
 225
 226   @AllowNull(true)
 227   @Default(null)
 228   @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description', true))
 229   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.DESCRIPTION.max))
 230   description: string
 231
 232   @AllowNull(true)
 233   @Default(null)
 234   @Is('VideoChannelSupport', value => throwIfNotValid(value, isVideoChannelSupportValid, 'support', true))
 235   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.SUPPORT.max))
 236   support: string
 237
 238   @CreatedAt
 239   createdAt: Date
 240
 241   @UpdatedAt
 242   updatedAt: Date
 243
 244   @ForeignKey(() => ActorModel)
 245   @Column
 246   actorId: number
 247
 248   @BelongsTo(() => ActorModel, {
 249     foreignKey: {
 250       allowNull: false
 251     },
 252     onDelete: 'cascade'
 253   })
 254   Actor: ActorModel
 255
 256   @ForeignKey(() => AccountModel)
 257   @Column
 258   accountId: number
 259
 260   @BelongsTo(() => AccountModel, {
 261     foreignKey: {
 262       allowNull: false
 263     },
 264     hooks: true
 265   })
 266   Account: AccountModel
 267
 268   @HasMany(() => VideoModel, {
 269     foreignKey: {
 270       name: 'channelId',
 271       allowNull: false
 272     },
 273     onDelete: 'CASCADE',
 274     hooks: true
 275   })
 276   Videos: VideoModel[]
 277
 278   @HasMany(() => VideoPlaylistModel, {
 279     foreignKey: {
 280       allowNull: true
 281     },
 282     onDelete: 'CASCADE',
 283     hooks: true
 284   })
 285   VideoPlaylists: VideoPlaylistModel[]
 286
 287   @BeforeDestroy
 288   static async sendDeleteIfOwned (instance: VideoChannelModel, options) {
 289     if (!instance.Actor) {
 290       instance.Actor = await instance.$get('Actor', { transaction: options.transaction })
 291     }
 292
 293     if (instance.Actor.isOwned()) {
 294       return sendDeleteActor(instance.Actor, options.transaction)
 295     }
 296
 297     return undefined
 298   }
 299
 300   static countByAccount (accountId: number) {
 301     const query = {
 302       where: {
 303         accountId
 304       }
 305     }
 306
 307     return VideoChannelModel.count(query)
 308   }
 309
 310   static listForApi (actorId: number, start: number, count: number, sort: string) {
 311     const query = {
 312       offset: start,
 313       limit: count,
 314       order: getSort(sort)
 315     }
 316
 317     const scopes = {
 318       method: [ ScopeNames.FOR_API, { actorId } as AvailableForListOptions ]
 319     }
 320     return VideoChannelModel
 321       .scope(scopes)
 322       .findAndCountAll(query)
 323       .then(({ rows, count }) => {
 324         return { total: count, data: rows }
 325       })
 326   }
 327
 328   static listLocalsForSitemap (sort: string): Bluebird<MChannelActor[]> {
 329     const query = {
 330       attributes: [ ],
 331       offset: 0,
 332       order: getSort(sort),
 333       include: [
 334         {
 335           attributes: [ 'preferredUsername', 'serverId' ],
 336           model: ActorModel.unscoped(),
 337           where: {
 338             serverId: null
 339           }
 340         }
 341       ]
 342     }
 343
 344     return VideoChannelModel
 345       .unscoped()
 346       .findAll(query)
 347   }
 348
 349   static searchForApi (options: {
 350     actorId: number
 351     search: string
 352     start: number
 353     count: number
 354     sort: string
 355   }) {
 356     const attributesInclude = []
 357     const escapedSearch = VideoModel.sequelize.escape(options.search)
 358     const escapedLikeSearch = VideoModel.sequelize.escape('%' + options.search + '%')
 359     attributesInclude.push(createSimilarityAttribute('VideoChannelModel.name', options.search))
 360
 361     const query = {
 362       attributes: {
 363         include: attributesInclude
 364       },
 365       offset: options.start,
 366       limit: options.count,
 367       order: getSort(options.sort),
 368       where: {
 369         [Op.or]: [
 370           Sequelize.literal(
 371             'lower(immutable_unaccent("VideoChannelModel"."name")) % lower(immutable_unaccent(' + escapedSearch + '))'
 372           ),
 373           Sequelize.literal(
 374             'lower(immutable_unaccent("VideoChannelModel"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))'
 375           )
 376         ]
 377       }
 378     }
 379
 380     const scopes = {
 381       method: [ ScopeNames.FOR_API, { actorId: options.actorId } as AvailableForListOptions ]
 382     }
 383     return VideoChannelModel
 384       .scope(scopes)
 385       .findAndCountAll(query)
 386       .then(({ rows, count }) => {
 387         return { total: count, data: rows }
 388       })
 389   }
 390
 391   static listByAccount (options: {
 392     accountId: number
 393     start: number
 394     count: number
 395     sort: string
 396     withStats?: boolean
 397   }) {
 398     const query = {
 399       offset: options.start,
 400       limit: options.count,
 401       order: getSort(options.sort),
 402       include: [
 403         {
 404           model: AccountModel,
 405           where: {
 406             id: options.accountId
 407           },
 408           required: true
 409         }
 410       ]
 411     }
 412
 413     const scopes: string | ScopeOptions | (string | ScopeOptions)[] = [ ScopeNames.WITH_ACTOR ]
 414
 415     if (options.withStats) {
 416       scopes.push({
 417         method: [ ScopeNames.WITH_STATS, { daysPrior: 30 } as AvailableWithStatsOptions ]
 418       })
 419     }
 420
 421     return VideoChannelModel
 422       .scope(scopes)
 423       .findAndCountAll(query)
 424       .then(({ rows, count }) => {
 425         return { total: count, data: rows }
 426       })
 427   }
 428
 429   static loadByIdAndPopulateAccount (id: number): Bluebird<MChannelAccountDefault> {
 430     return VideoChannelModel.unscoped()
 431       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 432       .findByPk(id)
 433   }
 434
 435   static loadByIdAndAccount (id: number, accountId: number): Bluebird<MChannelAccountDefault> {
 436     const query = {
 437       where: {
 438         id,
 439         accountId
 440       }
 441     }
 442
 443     return VideoChannelModel.unscoped()
 444       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 445       .findOne(query)
 446   }
 447
 448   static loadAndPopulateAccount (id: number): Bluebird<MChannelAccountDefault> {
 449     return VideoChannelModel.unscoped()
 450       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 451       .findByPk(id)
 452   }
 453
 454   static loadByUrlAndPopulateAccount (url: string): Bluebird<MChannelAccountDefault> {
 455     const query = {
 456       include: [
 457         {
 458           model: ActorModel,
 459           required: true,
 460           where: {
 461             url
 462           }
 463         }
 464       ]
 465     }
 466
 467     return VideoChannelModel
 468       .scope([ ScopeNames.WITH_ACCOUNT ])
 469       .findOne(query)
 470   }
 471
 472   static loadByNameWithHostAndPopulateAccount (nameWithHost: string) {
 473     const [ name, host ] = nameWithHost.split('@')
 474
 475     if (!host || host === WEBSERVER.HOST) return VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
 476
 477     return VideoChannelModel.loadByNameAndHostAndPopulateAccount(name, host)
 478   }
 479
 480   static loadLocalByNameAndPopulateAccount (name: string): Bluebird<MChannelAccountDefault> {
 481     const query = {
 482       include: [
 483         {
 484           model: ActorModel,
 485           required: true,
 486           where: {
 487             preferredUsername: name,
 488             serverId: null
 489           }
 490         }
 491       ]
 492     }
 493
 494     return VideoChannelModel.unscoped()
 495       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 496       .findOne(query)
 497   }
 498
 499   static loadByNameAndHostAndPopulateAccount (name: string, host: string): Bluebird<MChannelAccountDefault> {
 500     const query = {
 501       include: [
 502         {
 503           model: ActorModel,
 504           required: true,
 505           where: {
 506             preferredUsername: name
 507           },
 508           include: [
 509             {
 510               model: ServerModel,
 511               required: true,
 512               where: { host }
 513             }
 514           ]
 515         }
 516       ]
 517     }
 518
 519     return VideoChannelModel.unscoped()
 520       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
 521       .findOne(query)
 522   }
 523
 524   static loadAndPopulateAccountAndVideos (id: number): Bluebird<MChannelActorAccountDefaultVideos> {
 525     const options = {
 526       include: [
 527         VideoModel
 528       ]
 529     }
 530
 531     return VideoChannelModel.unscoped()
 532       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ])
 533       .findByPk(id, options)
 534   }
 535
 536   toFormattedSummaryJSON (this: MChannelSummaryFormattable): VideoChannelSummary {
 537     const actor = this.Actor.toFormattedSummaryJSON()
 538
 539     return {
 540       id: this.id,
 541       name: actor.name,
 542       displayName: this.getDisplayName(),
 543       url: actor.url,
 544       host: actor.host,
 545       avatar: actor.avatar
 546     }
 547   }
 548
 549   toFormattedJSON (this: MChannelFormattable): VideoChannel {
 550     const viewsPerDay = this.get('viewsPerDay') as string
 551
 552     const actor = this.Actor.toFormattedJSON()
 553     const videoChannel = {
 554       id: this.id,
 555       displayName: this.getDisplayName(),
 556       description: this.description,
 557       support: this.support,
 558       isLocal: this.Actor.isOwned(),
 559       createdAt: this.createdAt,
 560       updatedAt: this.updatedAt,
 561       ownerAccount: undefined,
 562       viewsPerDay: viewsPerDay !== undefined
 563         ? viewsPerDay.split(',').map(v => {
 564           const o = v.split('|')
 565           return {
 566             date: new Date(o[0]),
 567             views: +o[1]
 568           }
 569         })
 570         : undefined
 571     }
 572
 573     if (this.Account) videoChannel.ownerAccount = this.Account.toFormattedJSON()
 574
 575     return Object.assign(actor, videoChannel)
 576   }
 577
 578   toActivityPubObject (this: MChannelAP): ActivityPubActor {
 579     const obj = this.Actor.toActivityPubObject(this.name)
 580
 581     return Object.assign(obj, {
 582       summary: this.description,
 583       support: this.support,
 584       attributedTo: [
 585         {
 586           type: 'Person' as 'Person',
 587           id: this.Account.Actor.url
 588         }
 589       ]
 590     })
 591   }
 592
 593   getDisplayName () {
 594     return this.name
 595   }
 596
 597   isOutdated () {
 598     return this.Actor.isOutdated()
 599   }
 600 }