server/models/video/video.ts

   1 import * as Bluebird from 'bluebird'
   2 import { maxBy } from 'lodash'
   3 import * as magnetUtil from 'magnet-uri'
   4 import * as parseTorrent from 'parse-torrent'
   5 import { join } from 'path'
   6 import * as Sequelize from 'sequelize'
   7 import {
   8   AllowNull,
   9   BeforeDestroy,
  10   BelongsTo,
  11   BelongsToMany,
  12   Column,
  13   CreatedAt,
  14   DataType,
  15   Default,
  16   ForeignKey,
  17   HasMany,
  18   HasOne,
  19   IFindOptions,
  20   IIncludeOptions,
  21   Is,
  22   IsInt,
  23   IsUUID,
  24   Min,
  25   Model,
  26   Scopes,
  27   Table,
  28   UpdatedAt
  29 } from 'sequelize-typescript'
  30 import { VideoPrivacy, VideoState } from '../../../shared'
  31 import { VideoTorrentObject } from '../../../shared/models/activitypub/objects'
  32 import { Video, VideoDetails, VideoFile } from '../../../shared/models/videos'
  33 import { VideoFilter } from '../../../shared/models/videos/video-query.type'
  34 import { createTorrentPromise, peertubeTruncate } from '../../helpers/core-utils'
  35 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
  36 import { isArray, isBooleanValid } from '../../helpers/custom-validators/misc'
  37 import {
  38   isVideoCategoryValid,
  39   isVideoDescriptionValid,
  40   isVideoDurationValid,
  41   isVideoLanguageValid,
  42   isVideoLicenceValid,
  43   isVideoNameValid,
  44   isVideoPrivacyValid,
  45   isVideoStateValid,
  46   isVideoSupportValid
  47 } from '../../helpers/custom-validators/videos'
  48 import { generateImageFromVideoFile, getVideoFileResolution } from '../../helpers/ffmpeg-utils'
  49 import { logger } from '../../helpers/logger'
  50 import { getServerActor } from '../../helpers/utils'
  51 import {
  52   ACTIVITY_PUB,
  53   API_VERSION,
  54   CONFIG,
  55   CONSTRAINTS_FIELDS,
  56   PREVIEWS_SIZE,
  57   REMOTE_SCHEME,
  58   STATIC_DOWNLOAD_PATHS,
  59   STATIC_PATHS,
  60   THUMBNAILS_SIZE,
  61   VIDEO_CATEGORIES,
  62   VIDEO_LANGUAGES,
  63   VIDEO_LICENCES,
  64   VIDEO_PRIVACIES,
  65   VIDEO_STATES
  66 } from '../../initializers'
  67 import { sendDeleteVideo } from '../../lib/activitypub/send'
  68 import { AccountModel } from '../account/account'
  69 import { AccountVideoRateModel } from '../account/account-video-rate'
  70 import { ActorModel } from '../activitypub/actor'
  71 import { AvatarModel } from '../avatar/avatar'
  72 import { ServerModel } from '../server/server'
  73 import { buildTrigramSearchIndex, createSimilarityAttribute, getVideoSort, throwIfNotValid } from '../utils'
  74 import { TagModel } from './tag'
  75 import { VideoAbuseModel } from './video-abuse'
  76 import { VideoChannelModel } from './video-channel'
  77 import { VideoCommentModel } from './video-comment'
  78 import { VideoFileModel } from './video-file'
  79 import { VideoShareModel } from './video-share'
  80 import { VideoTagModel } from './video-tag'
  81 import { ScheduleVideoUpdateModel } from './schedule-video-update'
  82 import { VideoCaptionModel } from './video-caption'
  83 import { VideoBlacklistModel } from './video-blacklist'
  84 import { remove, writeFile } from 'fs-extra'
  85 import { VideoViewModel } from './video-views'
  86 import { VideoRedundancyModel } from '../redundancy/video-redundancy'
  87 import {
  88   videoFilesModelToFormattedJSON,
  89   VideoFormattingJSONOptions,
  90   videoModelToActivityPubObject,
  91   videoModelToFormattedDetailsJSON,
  92   videoModelToFormattedJSON
  93 } from './video-format-utils'
  94 import * as validator from 'validator'
  95 import { UserVideoHistoryModel } from '../account/user-video-history'
  96
  97 // FIXME: Define indexes here because there is an issue with TS and Sequelize.literal when called directly in the annotation
  98 const indexes: Sequelize.DefineIndexesOptions[] = [
  99   buildTrigramSearchIndex('video_name_trigram', 'name'),
 100
 101   { fields: [ 'createdAt' ] },
 102   { fields: [ 'publishedAt' ] },
 103   { fields: [ 'duration' ] },
 104   { fields: [ 'category' ] },
 105   { fields: [ 'licence' ] },
 106   { fields: [ 'nsfw' ] },
 107   { fields: [ 'language' ] },
 108   { fields: [ 'waitTranscoding' ] },
 109   { fields: [ 'state' ] },
 110   { fields: [ 'remote' ] },
 111   { fields: [ 'views' ] },
 112   { fields: [ 'likes' ] },
 113   { fields: [ 'channelId' ] },
 114   {
 115     fields: [ 'uuid' ],
 116     unique: true
 117   },
 118   {
 119     fields: [ 'url' ],
 120     unique: true
 121   }
 122 ]
 123
 124 export enum ScopeNames {
 125   AVAILABLE_FOR_LIST_IDS = 'AVAILABLE_FOR_LIST_IDS',
 126   FOR_API = 'FOR_API',
 127   WITH_ACCOUNT_DETAILS = 'WITH_ACCOUNT_DETAILS',
 128   WITH_TAGS = 'WITH_TAGS',
 129   WITH_FILES = 'WITH_FILES',
 130   WITH_SCHEDULED_UPDATE = 'WITH_SCHEDULED_UPDATE',
 131   WITH_BLACKLISTED = 'WITH_BLACKLISTED',
 132   WITH_USER_HISTORY = 'WITH_USER_HISTORY'
 133 }
 134
 135 type ForAPIOptions = {
 136   ids: number[]
 137   withFiles?: boolean
 138 }
 139
 140 type AvailableForListIDsOptions = {
 141   actorId: number
 142   includeLocalVideos: boolean
 143   filter?: VideoFilter
 144   categoryOneOf?: number[]
 145   nsfw?: boolean
 146   licenceOneOf?: number[]
 147   languageOneOf?: string[]
 148   tagsOneOf?: string[]
 149   tagsAllOf?: string[]
 150   withFiles?: boolean
 151   accountId?: number
 152   videoChannelId?: number
 153   trendingDays?: number
 154 }
 155
 156 @Scopes({
 157   [ ScopeNames.FOR_API ]: (options: ForAPIOptions) => {
 158     const accountInclude = {
 159       attributes: [ 'id', 'name' ],
 160       model: AccountModel.unscoped(),
 161       required: true,
 162       include: [
 163         {
 164           attributes: [ 'id', 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
 165           model: ActorModel.unscoped(),
 166           required: true,
 167           include: [
 168             {
 169               attributes: [ 'host' ],
 170               model: ServerModel.unscoped(),
 171               required: false
 172             },
 173             {
 174               model: AvatarModel.unscoped(),
 175               required: false
 176             }
 177           ]
 178         }
 179       ]
 180     }
 181
 182     const videoChannelInclude = {
 183       attributes: [ 'name', 'description', 'id' ],
 184       model: VideoChannelModel.unscoped(),
 185       required: true,
 186       include: [
 187         {
 188           attributes: [ 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
 189           model: ActorModel.unscoped(),
 190           required: true,
 191           include: [
 192             {
 193               attributes: [ 'host' ],
 194               model: ServerModel.unscoped(),
 195               required: false
 196             },
 197             {
 198               model: AvatarModel.unscoped(),
 199               required: false
 200             }
 201           ]
 202         },
 203         accountInclude
 204       ]
 205     }
 206
 207     const query: IFindOptions<VideoModel> = {
 208       where: {
 209         id: {
 210           [ Sequelize.Op.any ]: options.ids
 211         }
 212       },
 213       include: [ videoChannelInclude ]
 214     }
 215
 216     if (options.withFiles === true) {
 217       query.include.push({
 218         model: VideoFileModel.unscoped(),
 219         required: true
 220       })
 221     }
 222
 223     return query
 224   },
 225   [ ScopeNames.AVAILABLE_FOR_LIST_IDS ]: (options: AvailableForListIDsOptions) => {
 226     const query: IFindOptions<VideoModel> = {
 227       raw: true,
 228       attributes: [ 'id' ],
 229       where: {
 230         id: {
 231           [ Sequelize.Op.and ]: [
 232             {
 233               [ Sequelize.Op.notIn ]: Sequelize.literal(
 234                 '(SELECT "videoBlacklist"."videoId" FROM "videoBlacklist")'
 235               )
 236             }
 237           ]
 238         },
 239         // Always list public videos
 240         privacy: VideoPrivacy.PUBLIC,
 241         // Always list published videos, or videos that are being transcoded but on which we don't want to wait for transcoding
 242         [ Sequelize.Op.or ]: [
 243           {
 244             state: VideoState.PUBLISHED
 245           },
 246           {
 247             [ Sequelize.Op.and ]: {
 248               state: VideoState.TO_TRANSCODE,
 249               waitTranscoding: false
 250             }
 251           }
 252         ]
 253       },
 254       include: []
 255     }
 256
 257     if (options.filter || options.accountId || options.videoChannelId) {
 258       const videoChannelInclude: IIncludeOptions = {
 259         attributes: [],
 260         model: VideoChannelModel.unscoped(),
 261         required: true
 262       }
 263
 264       if (options.videoChannelId) {
 265         videoChannelInclude.where = {
 266           id: options.videoChannelId
 267         }
 268       }
 269
 270       if (options.filter || options.accountId) {
 271         const accountInclude: IIncludeOptions = {
 272           attributes: [],
 273           model: AccountModel.unscoped(),
 274           required: true
 275         }
 276
 277         if (options.filter) {
 278           accountInclude.include = [
 279             {
 280               attributes: [],
 281               model: ActorModel.unscoped(),
 282               required: true,
 283               where: VideoModel.buildActorWhereWithFilter(options.filter)
 284             }
 285           ]
 286         }
 287
 288         if (options.accountId) {
 289           accountInclude.where = { id: options.accountId }
 290         }
 291
 292         videoChannelInclude.include = [ accountInclude ]
 293       }
 294
 295       query.include.push(videoChannelInclude)
 296     }
 297
 298     if (options.actorId) {
 299       let localVideosReq = ''
 300       if (options.includeLocalVideos === true) {
 301         localVideosReq = ' UNION ALL ' +
 302           'SELECT "video"."id" AS "id" FROM "video" ' +
 303           'INNER JOIN "videoChannel" ON "videoChannel"."id" = "video"."channelId" ' +
 304           'INNER JOIN "account" ON "account"."id" = "videoChannel"."accountId" ' +
 305           'INNER JOIN "actor" ON "account"."actorId" = "actor"."id" ' +
 306           'WHERE "actor"."serverId" IS NULL'
 307       }
 308
 309       // Force actorId to be a number to avoid SQL injections
 310       const actorIdNumber = parseInt(options.actorId.toString(), 10)
 311       query.where[ 'id' ][ Sequelize.Op.and ].push({
 312         [ Sequelize.Op.in ]: Sequelize.literal(
 313           '(' +
 314           'SELECT "videoShare"."videoId" AS "id" FROM "videoShare" ' +
 315           'INNER JOIN "actorFollow" ON "actorFollow"."targetActorId" = "videoShare"."actorId" ' +
 316           'WHERE "actorFollow"."actorId" = ' + actorIdNumber +
 317           ' UNION ALL ' +
 318           'SELECT "video"."id" AS "id" FROM "video" ' +
 319           'INNER JOIN "videoChannel" ON "videoChannel"."id" = "video"."channelId" ' +
 320           'INNER JOIN "account" ON "account"."id" = "videoChannel"."accountId" ' +
 321           'INNER JOIN "actor" ON "account"."actorId" = "actor"."id" ' +
 322           'INNER JOIN "actorFollow" ON "actorFollow"."targetActorId" = "actor"."id" ' +
 323           'WHERE "actorFollow"."actorId" = ' + actorIdNumber +
 324           localVideosReq +
 325           ')'
 326         )
 327       })
 328     }
 329
 330     if (options.withFiles === true) {
 331       query.where[ 'id' ][ Sequelize.Op.and ].push({
 332         [ Sequelize.Op.in ]: Sequelize.literal(
 333           '(SELECT "videoId" FROM "videoFile")'
 334         )
 335       })
 336     }
 337
 338     // FIXME: issues with sequelize count when making a join on n:m relation, so we just make a IN()
 339     if (options.tagsAllOf || options.tagsOneOf) {
 340       const createTagsIn = (tags: string[]) => {
 341         return tags.map(t => VideoModel.sequelize.escape(t))
 342                    .join(', ')
 343       }
 344
 345       if (options.tagsOneOf) {
 346         query.where[ 'id' ][ Sequelize.Op.and ].push({
 347           [ Sequelize.Op.in ]: Sequelize.literal(
 348             '(' +
 349             'SELECT "videoId" FROM "videoTag" ' +
 350             'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
 351             'WHERE "tag"."name" IN (' + createTagsIn(options.tagsOneOf) + ')' +
 352             ')'
 353           )
 354         })
 355       }
 356
 357       if (options.tagsAllOf) {
 358         query.where[ 'id' ][ Sequelize.Op.and ].push({
 359           [ Sequelize.Op.in ]: Sequelize.literal(
 360             '(' +
 361             'SELECT "videoId" FROM "videoTag" ' +
 362             'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
 363             'WHERE "tag"."name" IN (' + createTagsIn(options.tagsAllOf) + ')' +
 364             'GROUP BY "videoTag"."videoId" HAVING COUNT(*) = ' + options.tagsAllOf.length +
 365             ')'
 366           )
 367         })
 368       }
 369     }
 370
 371     if (options.nsfw === true || options.nsfw === false) {
 372       query.where[ 'nsfw' ] = options.nsfw
 373     }
 374
 375     if (options.categoryOneOf) {
 376       query.where[ 'category' ] = {
 377         [ Sequelize.Op.or ]: options.categoryOneOf
 378       }
 379     }
 380
 381     if (options.licenceOneOf) {
 382       query.where[ 'licence' ] = {
 383         [ Sequelize.Op.or ]: options.licenceOneOf
 384       }
 385     }
 386
 387     if (options.languageOneOf) {
 388       query.where[ 'language' ] = {
 389         [ Sequelize.Op.or ]: options.languageOneOf
 390       }
 391     }
 392
 393     if (options.trendingDays) {
 394       query.include.push(VideoModel.buildTrendingQuery(options.trendingDays))
 395
 396       query.subQuery = false
 397     }
 398
 399     return query
 400   },
 401   [ ScopeNames.WITH_ACCOUNT_DETAILS ]: {
 402     include: [
 403       {
 404         model: () => VideoChannelModel.unscoped(),
 405         required: true,
 406         include: [
 407           {
 408             attributes: {
 409               exclude: [ 'privateKey', 'publicKey' ]
 410             },
 411             model: () => ActorModel.unscoped(),
 412             required: true,
 413             include: [
 414               {
 415                 attributes: [ 'host' ],
 416                 model: () => ServerModel.unscoped(),
 417                 required: false
 418               },
 419               {
 420                 model: () => AvatarModel.unscoped(),
 421                 required: false
 422               }
 423             ]
 424           },
 425           {
 426             model: () => AccountModel.unscoped(),
 427             required: true,
 428             include: [
 429               {
 430                 model: () => ActorModel.unscoped(),
 431                 attributes: {
 432                   exclude: [ 'privateKey', 'publicKey' ]
 433                 },
 434                 required: true,
 435                 include: [
 436                   {
 437                     attributes: [ 'host' ],
 438                     model: () => ServerModel.unscoped(),
 439                     required: false
 440                   },
 441                   {
 442                     model: () => AvatarModel.unscoped(),
 443                     required: false
 444                   }
 445                 ]
 446               }
 447             ]
 448           }
 449         ]
 450       }
 451     ]
 452   },
 453   [ ScopeNames.WITH_TAGS ]: {
 454     include: [ () => TagModel ]
 455   },
 456   [ ScopeNames.WITH_BLACKLISTED ]: {
 457     include: [
 458       {
 459         attributes: [ 'id', 'reason' ],
 460         model: () => VideoBlacklistModel,
 461         required: false
 462       }
 463     ]
 464   },
 465   [ ScopeNames.WITH_FILES ]: {
 466     include: [
 467       {
 468         model: () => VideoFileModel.unscoped(),
 469         // FIXME: typings
 470         [ 'separate' as any ]: true, // We may have multiple files, having multiple redundancies so let's separate this join
 471         required: false,
 472         include: [
 473           {
 474             attributes: [ 'fileUrl' ],
 475             model: () => VideoRedundancyModel.unscoped(),
 476             required: false
 477           }
 478         ]
 479       }
 480     ]
 481   },
 482   [ ScopeNames.WITH_SCHEDULED_UPDATE ]: {
 483     include: [
 484       {
 485         model: () => ScheduleVideoUpdateModel.unscoped(),
 486         required: false
 487       }
 488     ]
 489   },
 490   [ ScopeNames.WITH_USER_HISTORY ]: (userId: number) => {
 491     return {
 492       include: [
 493         {
 494           attributes: [ 'currentTime' ],
 495           model: UserVideoHistoryModel.unscoped(),
 496           required: false,
 497           where: {
 498             userId
 499           }
 500         }
 501       ]
 502     }
 503   }
 504 })
 505 @Table({
 506   tableName: 'video',
 507   indexes
 508 })
 509 export class VideoModel extends Model<VideoModel> {
 510
 511   @AllowNull(false)
 512   @Default(DataType.UUIDV4)
 513   @IsUUID(4)
 514   @Column(DataType.UUID)
 515   uuid: string
 516
 517   @AllowNull(false)
 518   @Is('VideoName', value => throwIfNotValid(value, isVideoNameValid, 'name'))
 519   @Column
 520   name: string
 521
 522   @AllowNull(true)
 523   @Default(null)
 524   @Is('VideoCategory', value => throwIfNotValid(value, isVideoCategoryValid, 'category'))
 525   @Column
 526   category: number
 527
 528   @AllowNull(true)
 529   @Default(null)
 530   @Is('VideoLicence', value => throwIfNotValid(value, isVideoLicenceValid, 'licence'))
 531   @Column
 532   licence: number
 533
 534   @AllowNull(true)
 535   @Default(null)
 536   @Is('VideoLanguage', value => throwIfNotValid(value, isVideoLanguageValid, 'language'))
 537   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.LANGUAGE.max))
 538   language: string
 539
 540   @AllowNull(false)
 541   @Is('VideoPrivacy', value => throwIfNotValid(value, isVideoPrivacyValid, 'privacy'))
 542   @Column
 543   privacy: number
 544
 545   @AllowNull(false)
 546   @Is('VideoNSFW', value => throwIfNotValid(value, isBooleanValid, 'NSFW boolean'))
 547   @Column
 548   nsfw: boolean
 549
 550   @AllowNull(true)
 551   @Default(null)
 552   @Is('VideoDescription', value => throwIfNotValid(value, isVideoDescriptionValid, 'description'))
 553   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.DESCRIPTION.max))
 554   description: string
 555
 556   @AllowNull(true)
 557   @Default(null)
 558   @Is('VideoSupport', value => throwIfNotValid(value, isVideoSupportValid, 'support'))
 559   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.SUPPORT.max))
 560   support: string
 561
 562   @AllowNull(false)
 563   @Is('VideoDuration', value => throwIfNotValid(value, isVideoDurationValid, 'duration'))
 564   @Column
 565   duration: number
 566
 567   @AllowNull(false)
 568   @Default(0)
 569   @IsInt
 570   @Min(0)
 571   @Column
 572   views: number
 573
 574   @AllowNull(false)
 575   @Default(0)
 576   @IsInt
 577   @Min(0)
 578   @Column
 579   likes: number
 580
 581   @AllowNull(false)
 582   @Default(0)
 583   @IsInt
 584   @Min(0)
 585   @Column
 586   dislikes: number
 587
 588   @AllowNull(false)
 589   @Column
 590   remote: boolean
 591
 592   @AllowNull(false)
 593   @Is('VideoUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
 594   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.URL.max))
 595   url: string
 596
 597   @AllowNull(false)
 598   @Column
 599   commentsEnabled: boolean
 600
 601   @AllowNull(false)
 602   @Column
 603   waitTranscoding: boolean
 604
 605   @AllowNull(false)
 606   @Default(null)
 607   @Is('VideoState', value => throwIfNotValid(value, isVideoStateValid, 'state'))
 608   @Column
 609   state: VideoState
 610
 611   @CreatedAt
 612   createdAt: Date
 613
 614   @UpdatedAt
 615   updatedAt: Date
 616
 617   @AllowNull(false)
 618   @Default(Sequelize.NOW)
 619   @Column
 620   publishedAt: Date
 621
 622   @ForeignKey(() => VideoChannelModel)
 623   @Column
 624   channelId: number
 625
 626   @BelongsTo(() => VideoChannelModel, {
 627     foreignKey: {
 628       allowNull: true
 629     },
 630     hooks: true
 631   })
 632   VideoChannel: VideoChannelModel
 633
 634   @BelongsToMany(() => TagModel, {
 635     foreignKey: 'videoId',
 636     through: () => VideoTagModel,
 637     onDelete: 'CASCADE'
 638   })
 639   Tags: TagModel[]
 640
 641   @HasMany(() => VideoAbuseModel, {
 642     foreignKey: {
 643       name: 'videoId',
 644       allowNull: false
 645     },
 646     onDelete: 'cascade'
 647   })
 648   VideoAbuses: VideoAbuseModel[]
 649
 650   @HasMany(() => VideoFileModel, {
 651     foreignKey: {
 652       name: 'videoId',
 653       allowNull: false
 654     },
 655     hooks: true,
 656     onDelete: 'cascade'
 657   })
 658   VideoFiles: VideoFileModel[]
 659
 660   @HasMany(() => VideoShareModel, {
 661     foreignKey: {
 662       name: 'videoId',
 663       allowNull: false
 664     },
 665     onDelete: 'cascade'
 666   })
 667   VideoShares: VideoShareModel[]
 668
 669   @HasMany(() => AccountVideoRateModel, {
 670     foreignKey: {
 671       name: 'videoId',
 672       allowNull: false
 673     },
 674     onDelete: 'cascade'
 675   })
 676   AccountVideoRates: AccountVideoRateModel[]
 677
 678   @HasMany(() => VideoCommentModel, {
 679     foreignKey: {
 680       name: 'videoId',
 681       allowNull: false
 682     },
 683     onDelete: 'cascade',
 684     hooks: true
 685   })
 686   VideoComments: VideoCommentModel[]
 687
 688   @HasMany(() => VideoViewModel, {
 689     foreignKey: {
 690       name: 'videoId',
 691       allowNull: false
 692     },
 693     onDelete: 'cascade'
 694   })
 695   VideoViews: VideoViewModel[]
 696
 697   @HasMany(() => UserVideoHistoryModel, {
 698     foreignKey: {
 699       name: 'videoId',
 700       allowNull: false
 701     },
 702     onDelete: 'cascade'
 703   })
 704   UserVideoHistories: UserVideoHistoryModel[]
 705
 706   @HasOne(() => ScheduleVideoUpdateModel, {
 707     foreignKey: {
 708       name: 'videoId',
 709       allowNull: false
 710     },
 711     onDelete: 'cascade'
 712   })
 713   ScheduleVideoUpdate: ScheduleVideoUpdateModel
 714
 715   @HasOne(() => VideoBlacklistModel, {
 716     foreignKey: {
 717       name: 'videoId',
 718       allowNull: false
 719     },
 720     onDelete: 'cascade'
 721   })
 722   VideoBlacklist: VideoBlacklistModel
 723
 724   @HasMany(() => VideoCaptionModel, {
 725     foreignKey: {
 726       name: 'videoId',
 727       allowNull: false
 728     },
 729     onDelete: 'cascade',
 730     hooks: true,
 731     [ 'separate' as any ]: true
 732   })
 733   VideoCaptions: VideoCaptionModel[]
 734
 735   @BeforeDestroy
 736   static async sendDelete (instance: VideoModel, options) {
 737     if (instance.isOwned()) {
 738       if (!instance.VideoChannel) {
 739         instance.VideoChannel = await instance.$get('VideoChannel', {
 740           include: [
 741             {
 742               model: AccountModel,
 743               include: [ ActorModel ]
 744             }
 745           ],
 746           transaction: options.transaction
 747         }) as VideoChannelModel
 748       }
 749
 750       return sendDeleteVideo(instance, options.transaction)
 751     }
 752
 753     return undefined
 754   }
 755
 756   @BeforeDestroy
 757   static async removeFiles (instance: VideoModel) {
 758     const tasks: Promise<any>[] = []
 759
 760     logger.info('Removing files of video %s.', instance.url)
 761
 762     tasks.push(instance.removeThumbnail())
 763
 764     if (instance.isOwned()) {
 765       if (!Array.isArray(instance.VideoFiles)) {
 766         instance.VideoFiles = await instance.$get('VideoFiles') as VideoFileModel[]
 767       }
 768
 769       tasks.push(instance.removePreview())
 770
 771       // Remove physical files and torrents
 772       instance.VideoFiles.forEach(file => {
 773         tasks.push(instance.removeFile(file))
 774         tasks.push(instance.removeTorrent(file))
 775       })
 776     }
 777
 778     // Do not wait video deletion because we could be in a transaction
 779     Promise.all(tasks)
 780            .catch(err => {
 781              logger.error('Some errors when removing files of video %s in before destroy hook.', instance.uuid, { err })
 782            })
 783
 784     return undefined
 785   }
 786
 787   static list () {
 788     return VideoModel.scope(ScopeNames.WITH_FILES).findAll()
 789   }
 790
 791   static listAllAndSharedByActorForOutbox (actorId: number, start: number, count: number) {
 792     function getRawQuery (select: string) {
 793       const queryVideo = 'SELECT ' + select + ' FROM "video" AS "Video" ' +
 794         'INNER JOIN "videoChannel" AS "VideoChannel" ON "VideoChannel"."id" = "Video"."channelId" ' +
 795         'INNER JOIN "account" AS "Account" ON "Account"."id" = "VideoChannel"."accountId" ' +
 796         'WHERE "Account"."actorId" = ' + actorId
 797       const queryVideoShare = 'SELECT ' + select + ' FROM "videoShare" AS "VideoShare" ' +
 798         'INNER JOIN "video" AS "Video" ON "Video"."id" = "VideoShare"."videoId" ' +
 799         'WHERE "VideoShare"."actorId" = ' + actorId
 800
 801       return `(${queryVideo}) UNION (${queryVideoShare})`
 802     }
 803
 804     const rawQuery = getRawQuery('"Video"."id"')
 805     const rawCountQuery = getRawQuery('COUNT("Video"."id") as "total"')
 806
 807     const query = {
 808       distinct: true,
 809       offset: start,
 810       limit: count,
 811       order: getVideoSort('createdAt', [ 'Tags', 'name', 'ASC' ]),
 812       where: {
 813         id: {
 814           [ Sequelize.Op.in ]: Sequelize.literal('(' + rawQuery + ')')
 815         },
 816         [ Sequelize.Op.or ]: [
 817           { privacy: VideoPrivacy.PUBLIC },
 818           { privacy: VideoPrivacy.UNLISTED }
 819         ]
 820       },
 821       include: [
 822         {
 823           attributes: [ 'language' ],
 824           model: VideoCaptionModel.unscoped(),
 825           required: false
 826         },
 827         {
 828           attributes: [ 'id', 'url' ],
 829           model: VideoShareModel.unscoped(),
 830           required: false,
 831           // We only want videos shared by this actor
 832           where: {
 833             [ Sequelize.Op.and ]: [
 834               {
 835                 id: {
 836                   [ Sequelize.Op.not ]: null
 837                 }
 838               },
 839               {
 840                 actorId
 841               }
 842             ]
 843           },
 844           include: [
 845             {
 846               attributes: [ 'id', 'url' ],
 847               model: ActorModel.unscoped()
 848             }
 849           ]
 850         },
 851         {
 852           model: VideoChannelModel.unscoped(),
 853           required: true,
 854           include: [
 855             {
 856               attributes: [ 'name' ],
 857               model: AccountModel.unscoped(),
 858               required: true,
 859               include: [
 860                 {
 861                   attributes: [ 'id', 'url', 'followersUrl' ],
 862                   model: ActorModel.unscoped(),
 863                   required: true
 864                 }
 865               ]
 866             },
 867             {
 868               attributes: [ 'id', 'url', 'followersUrl' ],
 869               model: ActorModel.unscoped(),
 870               required: true
 871             }
 872           ]
 873         },
 874         VideoFileModel,
 875         TagModel
 876       ]
 877     }
 878
 879     return Bluebird.all([
 880       // FIXME: typing issue
 881       VideoModel.findAll(query as any),
 882       VideoModel.sequelize.query(rawCountQuery, { type: Sequelize.QueryTypes.SELECT })
 883     ]).then(([ rows, totals ]) => {
 884       // totals: totalVideos + totalVideoShares
 885       let totalVideos = 0
 886       let totalVideoShares = 0
 887       if (totals[ 0 ]) totalVideos = parseInt(totals[ 0 ].total, 10)
 888       if (totals[ 1 ]) totalVideoShares = parseInt(totals[ 1 ].total, 10)
 889
 890       const total = totalVideos + totalVideoShares
 891       return {
 892         data: rows,
 893         total: total
 894       }
 895     })
 896   }
 897
 898   static listUserVideosForApi (accountId: number, start: number, count: number, sort: string, withFiles = false) {
 899     const query: IFindOptions<VideoModel> = {
 900       offset: start,
 901       limit: count,
 902       order: getVideoSort(sort),
 903       include: [
 904         {
 905           model: VideoChannelModel,
 906           required: true,
 907           include: [
 908             {
 909               model: AccountModel,
 910               where: {
 911                 id: accountId
 912               },
 913               required: true
 914             }
 915           ]
 916         },
 917         {
 918           model: ScheduleVideoUpdateModel,
 919           required: false
 920         },
 921         {
 922           model: VideoBlacklistModel,
 923           required: false
 924         }
 925       ]
 926     }
 927
 928     if (withFiles === true) {
 929       query.include.push({
 930         model: VideoFileModel.unscoped(),
 931         required: true
 932       })
 933     }
 934
 935     return VideoModel.findAndCountAll(query).then(({ rows, count }) => {
 936       return {
 937         data: rows,
 938         total: count
 939       }
 940     })
 941   }
 942
 943   static async listForApi (options: {
 944     start: number,
 945     count: number,
 946     sort: string,
 947     nsfw: boolean,
 948     includeLocalVideos: boolean,
 949     withFiles: boolean,
 950     categoryOneOf?: number[],
 951     licenceOneOf?: number[],
 952     languageOneOf?: string[],
 953     tagsOneOf?: string[],
 954     tagsAllOf?: string[],
 955     filter?: VideoFilter,
 956     accountId?: number,
 957     videoChannelId?: number,
 958     actorId?: number
 959     trendingDays?: number,
 960     userId?: number
 961   }, countVideos = true) {
 962     const query: IFindOptions<VideoModel> = {
 963       offset: options.start,
 964       limit: options.count,
 965       order: getVideoSort(options.sort)
 966     }
 967
 968     let trendingDays: number
 969     if (options.sort.endsWith('trending')) {
 970       trendingDays = CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
 971
 972       query.group = 'VideoModel.id'
 973     }
 974
 975     // actorId === null has a meaning, so just check undefined
 976     const actorId = options.actorId !== undefined ? options.actorId : (await getServerActor()).id
 977
 978     const queryOptions = {
 979       actorId,
 980       nsfw: options.nsfw,
 981       categoryOneOf: options.categoryOneOf,
 982       licenceOneOf: options.licenceOneOf,
 983       languageOneOf: options.languageOneOf,
 984       tagsOneOf: options.tagsOneOf,
 985       tagsAllOf: options.tagsAllOf,
 986       filter: options.filter,
 987       withFiles: options.withFiles,
 988       accountId: options.accountId,
 989       videoChannelId: options.videoChannelId,
 990       includeLocalVideos: options.includeLocalVideos,
 991       userId: options.userId,
 992       trendingDays
 993     }
 994
 995     return VideoModel.getAvailableForApi(query, queryOptions, countVideos)
 996   }
 997
 998   static async searchAndPopulateAccountAndServer (options: {
 999     includeLocalVideos: boolean
1000     search?: string
1001     start?: number
1002     count?: number
1003     sort?: string
1004     startDate?: string // ISO 8601
1005     endDate?: string // ISO 8601
1006     nsfw?: boolean
1007     categoryOneOf?: number[]
1008     licenceOneOf?: number[]
1009     languageOneOf?: string[]
1010     tagsOneOf?: string[]
1011     tagsAllOf?: string[]
1012     durationMin?: number // seconds
1013     durationMax?: number // seconds
1014     userId?: number
1015   }) {
1016     const whereAnd = []
1017
1018     if (options.startDate || options.endDate) {
1019       const publishedAtRange = {}
1020
1021       if (options.startDate) publishedAtRange[ Sequelize.Op.gte ] = options.startDate
1022       if (options.endDate) publishedAtRange[ Sequelize.Op.lte ] = options.endDate
1023
1024       whereAnd.push({ publishedAt: publishedAtRange })
1025     }
1026
1027     if (options.durationMin || options.durationMax) {
1028       const durationRange = {}
1029
1030       if (options.durationMin) durationRange[ Sequelize.Op.gte ] = options.durationMin
1031       if (options.durationMax) durationRange[ Sequelize.Op.lte ] = options.durationMax
1032
1033       whereAnd.push({ duration: durationRange })
1034     }
1035
1036     const attributesInclude = []
1037     const escapedSearch = VideoModel.sequelize.escape(options.search)
1038     const escapedLikeSearch = VideoModel.sequelize.escape('%' + options.search + '%')
1039     if (options.search) {
1040       whereAnd.push(
1041         {
1042           id: {
1043             [ Sequelize.Op.in ]: Sequelize.literal(
1044               '(' +
1045               'SELECT "video"."id" FROM "video" ' +
1046               'WHERE ' +
1047               'lower(immutable_unaccent("video"."name")) % lower(immutable_unaccent(' + escapedSearch + ')) OR ' +
1048               'lower(immutable_unaccent("video"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))' +
1049               'UNION ALL ' +
1050               'SELECT "video"."id" FROM "video" LEFT JOIN "videoTag" ON "videoTag"."videoId" = "video"."id" ' +
1051               'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
1052               'WHERE "tag"."name" = ' + escapedSearch +
1053               ')'
1054             )
1055           }
1056         }
1057       )
1058
1059       attributesInclude.push(createSimilarityAttribute('VideoModel.name', options.search))
1060     }
1061
1062     // Cannot search on similarity if we don't have a search
1063     if (!options.search) {
1064       attributesInclude.push(
1065         Sequelize.literal('0 as similarity')
1066       )
1067     }
1068
1069     const query: IFindOptions<VideoModel> = {
1070       attributes: {
1071         include: attributesInclude
1072       },
1073       offset: options.start,
1074       limit: options.count,
1075       order: getVideoSort(options.sort),
1076       where: {
1077         [ Sequelize.Op.and ]: whereAnd
1078       }
1079     }
1080
1081     const serverActor = await getServerActor()
1082     const queryOptions = {
1083       actorId: serverActor.id,
1084       includeLocalVideos: options.includeLocalVideos,
1085       nsfw: options.nsfw,
1086       categoryOneOf: options.categoryOneOf,
1087       licenceOneOf: options.licenceOneOf,
1088       languageOneOf: options.languageOneOf,
1089       tagsOneOf: options.tagsOneOf,
1090       tagsAllOf: options.tagsAllOf,
1091       userId: options.userId
1092     }
1093
1094     return VideoModel.getAvailableForApi(query, queryOptions)
1095   }
1096
1097   static load (id: number | string, t?: Sequelize.Transaction) {
1098     const where = VideoModel.buildWhereIdOrUUID(id)
1099     const options = {
1100       where,
1101       transaction: t
1102     }
1103
1104     return VideoModel.findOne(options)
1105   }
1106
1107   static loadOnlyId (id: number | string, t?: Sequelize.Transaction) {
1108     const where = VideoModel.buildWhereIdOrUUID(id)
1109
1110     const options = {
1111       attributes: [ 'id' ],
1112       where,
1113       transaction: t
1114     }
1115
1116     return VideoModel.findOne(options)
1117   }
1118
1119   static loadWithFile (id: number, t?: Sequelize.Transaction, logging?: boolean) {
1120     return VideoModel.scope(ScopeNames.WITH_FILES)
1121                      .findById(id, { transaction: t, logging })
1122   }
1123
1124   static loadByUUIDWithFile (uuid: string) {
1125     const options = {
1126       where: {
1127         uuid
1128       }
1129     }
1130
1131     return VideoModel
1132       .scope([ ScopeNames.WITH_FILES ])
1133       .findOne(options)
1134   }
1135
1136   static loadByUrl (url: string, transaction?: Sequelize.Transaction) {
1137     const query: IFindOptions<VideoModel> = {
1138       where: {
1139         url
1140       },
1141       transaction
1142     }
1143
1144     return VideoModel.findOne(query)
1145   }
1146
1147   static loadByUrlAndPopulateAccount (url: string, transaction?: Sequelize.Transaction) {
1148     const query: IFindOptions<VideoModel> = {
1149       where: {
1150         url
1151       },
1152       transaction
1153     }
1154
1155     return VideoModel.scope([ ScopeNames.WITH_ACCOUNT_DETAILS, ScopeNames.WITH_FILES ]).findOne(query)
1156   }
1157
1158   static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Sequelize.Transaction, userId?: number) {
1159     const where = VideoModel.buildWhereIdOrUUID(id)
1160
1161     const options = {
1162       order: [ [ 'Tags', 'name', 'ASC' ] ],
1163       where,
1164       transaction: t
1165     }
1166
1167     const scopes = [
1168       ScopeNames.WITH_TAGS,
1169       ScopeNames.WITH_BLACKLISTED,
1170       ScopeNames.WITH_FILES,
1171       ScopeNames.WITH_ACCOUNT_DETAILS,
1172       ScopeNames.WITH_SCHEDULED_UPDATE
1173     ]
1174
1175     if (userId) {
1176       scopes.push({ method: [ ScopeNames.WITH_USER_HISTORY, userId ] } as any) // FIXME: typings
1177     }
1178
1179     return VideoModel
1180       .scope(scopes)
1181       .findOne(options)
1182   }
1183
1184   static async getStats () {
1185     const totalLocalVideos = await VideoModel.count({
1186       where: {
1187         remote: false
1188       }
1189     })
1190     const totalVideos = await VideoModel.count()
1191
1192     let totalLocalVideoViews = await VideoModel.sum('views', {
1193       where: {
1194         remote: false
1195       }
1196     })
1197     // Sequelize could return null...
1198     if (!totalLocalVideoViews) totalLocalVideoViews = 0
1199
1200     return {
1201       totalLocalVideos,
1202       totalLocalVideoViews,
1203       totalVideos
1204     }
1205   }
1206
1207   static incrementViews (id: number, views: number) {
1208     return VideoModel.increment('views', {
1209       by: views,
1210       where: {
1211         id
1212       }
1213     })
1214   }
1215
1216   // threshold corresponds to how many video the field should have to be returned
1217   static async getRandomFieldSamples (field: 'category' | 'channelId', threshold: number, count: number) {
1218     const actorId = (await getServerActor()).id
1219
1220     const scopeOptions = {
1221       actorId,
1222       includeLocalVideos: true
1223     }
1224
1225     const query: IFindOptions<VideoModel> = {
1226       attributes: [ field ],
1227       limit: count,
1228       group: field,
1229       having: Sequelize.where(Sequelize.fn('COUNT', Sequelize.col(field)), {
1230         [ Sequelize.Op.gte ]: threshold
1231       }) as any, // FIXME: typings
1232       order: [ this.sequelize.random() ]
1233     }
1234
1235     return VideoModel.scope({ method: [ ScopeNames.AVAILABLE_FOR_LIST_IDS, scopeOptions ] })
1236                      .findAll(query)
1237                      .then(rows => rows.map(r => r[ field ]))
1238   }
1239
1240   static buildTrendingQuery (trendingDays: number) {
1241     return {
1242       attributes: [],
1243       subQuery: false,
1244       model: VideoViewModel,
1245       required: false,
1246       where: {
1247         startDate: {
1248           [ Sequelize.Op.gte ]: new Date(new Date().getTime() - (24 * 3600 * 1000) * trendingDays)
1249         }
1250       }
1251     }
1252   }
1253
1254   private static buildActorWhereWithFilter (filter?: VideoFilter) {
1255     if (filter && filter === 'local') {
1256       return {
1257         serverId: null
1258       }
1259     }
1260
1261     return {}
1262   }
1263
1264   private static async getAvailableForApi (
1265     query: IFindOptions<VideoModel>,
1266     options: AvailableForListIDsOptions & { userId?: number},
1267     countVideos = true
1268   ) {
1269     const idsScope = {
1270       method: [
1271         ScopeNames.AVAILABLE_FOR_LIST_IDS, options
1272       ]
1273     }
1274
1275     // Remove trending sort on count, because it uses a group by
1276     const countOptions = Object.assign({}, options, { trendingDays: undefined })
1277     const countQuery = Object.assign({}, query, { attributes: undefined, group: undefined })
1278     const countScope = {
1279       method: [
1280         ScopeNames.AVAILABLE_FOR_LIST_IDS, countOptions
1281       ]
1282     }
1283
1284     const [ count, rowsId ] = await Promise.all([
1285       countVideos ? VideoModel.scope(countScope).count(countQuery) : Promise.resolve(undefined),
1286       VideoModel.scope(idsScope).findAll(query)
1287     ])
1288     const ids = rowsId.map(r => r.id)
1289
1290     if (ids.length === 0) return { data: [], total: count }
1291
1292     // FIXME: typings
1293     const apiScope: any[] = [
1294       {
1295         method: [ ScopeNames.FOR_API, { ids, withFiles: options.withFiles } as ForAPIOptions ]
1296       }
1297     ]
1298
1299     if (options.userId) {
1300       apiScope.push({ method: [ ScopeNames.WITH_USER_HISTORY, options.userId ] })
1301     }
1302
1303     const secondQuery = {
1304       offset: 0,
1305       limit: query.limit,
1306       attributes: query.attributes,
1307       order: [ // Keep original order
1308         Sequelize.literal(
1309           ids.map(id => `"VideoModel".id = ${id} DESC`).join(', ')
1310         )
1311       ]
1312     }
1313     const rows = await VideoModel.scope(apiScope).findAll(secondQuery)
1314
1315     return {
1316       data: rows,
1317       total: count
1318     }
1319   }
1320
1321   static getCategoryLabel (id: number) {
1322     return VIDEO_CATEGORIES[ id ] || 'Misc'
1323   }
1324
1325   static getLicenceLabel (id: number) {
1326     return VIDEO_LICENCES[ id ] || 'Unknown'
1327   }
1328
1329   static getLanguageLabel (id: string) {
1330     return VIDEO_LANGUAGES[ id ] || 'Unknown'
1331   }
1332
1333   static getPrivacyLabel (id: number) {
1334     return VIDEO_PRIVACIES[ id ] || 'Unknown'
1335   }
1336
1337   static getStateLabel (id: number) {
1338     return VIDEO_STATES[ id ] || 'Unknown'
1339   }
1340
1341   static buildWhereIdOrUUID (id: number | string) {
1342     return validator.isInt('' + id) ? { id } : { uuid: id }
1343   }
1344
1345   getOriginalFile () {
1346     if (Array.isArray(this.VideoFiles) === false) return undefined
1347
1348     // The original file is the file that have the higher resolution
1349     return maxBy(this.VideoFiles, file => file.resolution)
1350   }
1351
1352   getVideoFilename (videoFile: VideoFileModel) {
1353     return this.uuid + '-' + videoFile.resolution + videoFile.extname
1354   }
1355
1356   getThumbnailName () {
1357     // We always have a copy of the thumbnail
1358     const extension = '.jpg'
1359     return this.uuid + extension
1360   }
1361
1362   getPreviewName () {
1363     const extension = '.jpg'
1364     return this.uuid + extension
1365   }
1366
1367   getTorrentFileName (videoFile: VideoFileModel) {
1368     const extension = '.torrent'
1369     return this.uuid + '-' + videoFile.resolution + extension
1370   }
1371
1372   isOwned () {
1373     return this.remote === false
1374   }
1375
1376   createPreview (videoFile: VideoFileModel) {
1377     return generateImageFromVideoFile(
1378       this.getVideoFilePath(videoFile),
1379       CONFIG.STORAGE.PREVIEWS_DIR,
1380       this.getPreviewName(),
1381       PREVIEWS_SIZE
1382     )
1383   }
1384
1385   createThumbnail (videoFile: VideoFileModel) {
1386     return generateImageFromVideoFile(
1387       this.getVideoFilePath(videoFile),
1388       CONFIG.STORAGE.THUMBNAILS_DIR,
1389       this.getThumbnailName(),
1390       THUMBNAILS_SIZE
1391     )
1392   }
1393
1394   getTorrentFilePath (videoFile: VideoFileModel) {
1395     return join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
1396   }
1397
1398   getVideoFilePath (videoFile: VideoFileModel) {
1399     return join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
1400   }
1401
1402   async createTorrentAndSetInfoHash (videoFile: VideoFileModel) {
1403     const options = {
1404       // Keep the extname, it's used by the client to stream the file inside a web browser
1405       name: `${this.name} ${videoFile.resolution}p${videoFile.extname}`,
1406       createdBy: 'PeerTube',
1407       announceList: [
1408         [ CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT + '/tracker/socket' ],
1409         [ CONFIG.WEBSERVER.URL + '/tracker/announce' ]
1410       ],
1411       urlList: [ CONFIG.WEBSERVER.URL + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile) ]
1412     }
1413
1414     const torrent = await createTorrentPromise(this.getVideoFilePath(videoFile), options)
1415
1416     const filePath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
1417     logger.info('Creating torrent %s.', filePath)
1418
1419     await writeFile(filePath, torrent)
1420
1421     const parsedTorrent = parseTorrent(torrent)
1422     videoFile.infoHash = parsedTorrent.infoHash
1423   }
1424
1425   getEmbedStaticPath () {
1426     return '/videos/embed/' + this.uuid
1427   }
1428
1429   getThumbnailStaticPath () {
1430     return join(STATIC_PATHS.THUMBNAILS, this.getThumbnailName())
1431   }
1432
1433   getPreviewStaticPath () {
1434     return join(STATIC_PATHS.PREVIEWS, this.getPreviewName())
1435   }
1436
1437   toFormattedJSON (options?: VideoFormattingJSONOptions): Video {
1438     return videoModelToFormattedJSON(this, options)
1439   }
1440
1441   toFormattedDetailsJSON (): VideoDetails {
1442     return videoModelToFormattedDetailsJSON(this)
1443   }
1444
1445   getFormattedVideoFilesJSON (): VideoFile[] {
1446     return videoFilesModelToFormattedJSON(this, this.VideoFiles)
1447   }
1448
1449   toActivityPubObject (): VideoTorrentObject {
1450     return videoModelToActivityPubObject(this)
1451   }
1452
1453   getTruncatedDescription () {
1454     if (!this.description) return null
1455
1456     const maxLength = CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
1457     return peertubeTruncate(this.description, maxLength)
1458   }
1459
1460   getOriginalFileResolution () {
1461     const originalFilePath = this.getVideoFilePath(this.getOriginalFile())
1462
1463     return getVideoFileResolution(originalFilePath)
1464   }
1465
1466   getDescriptionAPIPath () {
1467     return `/api/${API_VERSION}/videos/${this.uuid}/description`
1468   }
1469
1470   removeThumbnail () {
1471     const thumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
1472     return remove(thumbnailPath)
1473       .catch(err => logger.warn('Cannot delete thumbnail %s.', thumbnailPath, { err }))
1474   }
1475
1476   removePreview () {
1477     const previewPath = join(CONFIG.STORAGE.PREVIEWS_DIR + this.getPreviewName())
1478     return remove(previewPath)
1479       .catch(err => logger.warn('Cannot delete preview %s.', previewPath, { err }))
1480   }
1481
1482   removeFile (videoFile: VideoFileModel) {
1483     const filePath = join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
1484     return remove(filePath)
1485       .catch(err => logger.warn('Cannot delete file %s.', filePath, { err }))
1486   }
1487
1488   removeTorrent (videoFile: VideoFileModel) {
1489     const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
1490     return remove(torrentPath)
1491       .catch(err => logger.warn('Cannot delete torrent %s.', torrentPath, { err }))
1492   }
1493
1494   isOutdated () {
1495     if (this.isOwned()) return false
1496
1497     const now = Date.now()
1498     const createdAtTime = this.createdAt.getTime()
1499     const updatedAtTime = this.updatedAt.getTime()
1500
1501     return (now - createdAtTime) > ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL &&
1502       (now - updatedAtTime) > ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL
1503   }
1504
1505   getBaseUrls () {
1506     let baseUrlHttp
1507     let baseUrlWs
1508
1509     if (this.isOwned()) {
1510       baseUrlHttp = CONFIG.WEBSERVER.URL
1511       baseUrlWs = CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
1512     } else {
1513       baseUrlHttp = REMOTE_SCHEME.HTTP + '://' + this.VideoChannel.Account.Actor.Server.host
1514       baseUrlWs = REMOTE_SCHEME.WS + '://' + this.VideoChannel.Account.Actor.Server.host
1515     }
1516
1517     return { baseUrlHttp, baseUrlWs }
1518   }
1519
1520   generateMagnetUri (videoFile: VideoFileModel, baseUrlHttp: string, baseUrlWs: string) {
1521     const xs = this.getTorrentUrl(videoFile, baseUrlHttp)
1522     const announce = [ baseUrlWs + '/tracker/socket', baseUrlHttp + '/tracker/announce' ]
1523     let urlList = [ this.getVideoFileUrl(videoFile, baseUrlHttp) ]
1524
1525     const redundancies = videoFile.RedundancyVideos
1526     if (isArray(redundancies)) urlList = urlList.concat(redundancies.map(r => r.fileUrl))
1527
1528     const magnetHash = {
1529       xs,
1530       announce,
1531       urlList,
1532       infoHash: videoFile.infoHash,
1533       name: this.name
1534     }
1535
1536     return magnetUtil.encode(magnetHash)
1537   }
1538
1539   getThumbnailUrl (baseUrlHttp: string) {
1540     return baseUrlHttp + STATIC_PATHS.THUMBNAILS + this.getThumbnailName()
1541   }
1542
1543   getTorrentUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1544     return baseUrlHttp + STATIC_PATHS.TORRENTS + this.getTorrentFileName(videoFile)
1545   }
1546
1547   getTorrentDownloadUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1548     return baseUrlHttp + STATIC_DOWNLOAD_PATHS.TORRENTS + this.getTorrentFileName(videoFile)
1549   }
1550
1551   getVideoFileUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1552     return baseUrlHttp + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile)
1553   }
1554
1555   getVideoFileDownloadUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1556     return baseUrlHttp + STATIC_DOWNLOAD_PATHS.VIDEOS + this.getVideoFilename(videoFile)
1557   }
1558 }