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   downloadingEnabled: boolean
 604
 605   @AllowNull(false)
 606   @Column
 607   waitTranscoding: boolean
 608
 609   @AllowNull(false)
 610   @Default(null)
 611   @Is('VideoState', value => throwIfNotValid(value, isVideoStateValid, 'state'))
 612   @Column
 613   state: VideoState
 614
 615   @CreatedAt
 616   createdAt: Date
 617
 618   @UpdatedAt
 619   updatedAt: Date
 620
 621   @AllowNull(false)
 622   @Default(Sequelize.NOW)
 623   @Column
 624   publishedAt: Date
 625
 626   @ForeignKey(() => VideoChannelModel)
 627   @Column
 628   channelId: number
 629
 630   @BelongsTo(() => VideoChannelModel, {
 631     foreignKey: {
 632       allowNull: true
 633     },
 634     hooks: true
 635   })
 636   VideoChannel: VideoChannelModel
 637
 638   @BelongsToMany(() => TagModel, {
 639     foreignKey: 'videoId',
 640     through: () => VideoTagModel,
 641     onDelete: 'CASCADE'
 642   })
 643   Tags: TagModel[]
 644
 645   @HasMany(() => VideoAbuseModel, {
 646     foreignKey: {
 647       name: 'videoId',
 648       allowNull: false
 649     },
 650     onDelete: 'cascade'
 651   })
 652   VideoAbuses: VideoAbuseModel[]
 653
 654   @HasMany(() => VideoFileModel, {
 655     foreignKey: {
 656       name: 'videoId',
 657       allowNull: false
 658     },
 659     hooks: true,
 660     onDelete: 'cascade'
 661   })
 662   VideoFiles: VideoFileModel[]
 663
 664   @HasMany(() => VideoShareModel, {
 665     foreignKey: {
 666       name: 'videoId',
 667       allowNull: false
 668     },
 669     onDelete: 'cascade'
 670   })
 671   VideoShares: VideoShareModel[]
 672
 673   @HasMany(() => AccountVideoRateModel, {
 674     foreignKey: {
 675       name: 'videoId',
 676       allowNull: false
 677     },
 678     onDelete: 'cascade'
 679   })
 680   AccountVideoRates: AccountVideoRateModel[]
 681
 682   @HasMany(() => VideoCommentModel, {
 683     foreignKey: {
 684       name: 'videoId',
 685       allowNull: false
 686     },
 687     onDelete: 'cascade',
 688     hooks: true
 689   })
 690   VideoComments: VideoCommentModel[]
 691
 692   @HasMany(() => VideoViewModel, {
 693     foreignKey: {
 694       name: 'videoId',
 695       allowNull: false
 696     },
 697     onDelete: 'cascade'
 698   })
 699   VideoViews: VideoViewModel[]
 700
 701   @HasMany(() => UserVideoHistoryModel, {
 702     foreignKey: {
 703       name: 'videoId',
 704       allowNull: false
 705     },
 706     onDelete: 'cascade'
 707   })
 708   UserVideoHistories: UserVideoHistoryModel[]
 709
 710   @HasOne(() => ScheduleVideoUpdateModel, {
 711     foreignKey: {
 712       name: 'videoId',
 713       allowNull: false
 714     },
 715     onDelete: 'cascade'
 716   })
 717   ScheduleVideoUpdate: ScheduleVideoUpdateModel
 718
 719   @HasOne(() => VideoBlacklistModel, {
 720     foreignKey: {
 721       name: 'videoId',
 722       allowNull: false
 723     },
 724     onDelete: 'cascade'
 725   })
 726   VideoBlacklist: VideoBlacklistModel
 727
 728   @HasMany(() => VideoCaptionModel, {
 729     foreignKey: {
 730       name: 'videoId',
 731       allowNull: false
 732     },
 733     onDelete: 'cascade',
 734     hooks: true,
 735     [ 'separate' as any ]: true
 736   })
 737   VideoCaptions: VideoCaptionModel[]
 738
 739   @BeforeDestroy
 740   static async sendDelete (instance: VideoModel, options) {
 741     if (instance.isOwned()) {
 742       if (!instance.VideoChannel) {
 743         instance.VideoChannel = await instance.$get('VideoChannel', {
 744           include: [
 745             {
 746               model: AccountModel,
 747               include: [ ActorModel ]
 748             }
 749           ],
 750           transaction: options.transaction
 751         }) as VideoChannelModel
 752       }
 753
 754       return sendDeleteVideo(instance, options.transaction)
 755     }
 756
 757     return undefined
 758   }
 759
 760   @BeforeDestroy
 761   static async removeFiles (instance: VideoModel) {
 762     const tasks: Promise<any>[] = []
 763
 764     logger.info('Removing files of video %s.', instance.url)
 765
 766     tasks.push(instance.removeThumbnail())
 767
 768     if (instance.isOwned()) {
 769       if (!Array.isArray(instance.VideoFiles)) {
 770         instance.VideoFiles = await instance.$get('VideoFiles') as VideoFileModel[]
 771       }
 772
 773       tasks.push(instance.removePreview())
 774
 775       // Remove physical files and torrents
 776       instance.VideoFiles.forEach(file => {
 777         tasks.push(instance.removeFile(file))
 778         tasks.push(instance.removeTorrent(file))
 779       })
 780     }
 781
 782     // Do not wait video deletion because we could be in a transaction
 783     Promise.all(tasks)
 784            .catch(err => {
 785              logger.error('Some errors when removing files of video %s in before destroy hook.', instance.uuid, { err })
 786            })
 787
 788     return undefined
 789   }
 790
 791   static list () {
 792     return VideoModel.scope(ScopeNames.WITH_FILES).findAll()
 793   }
 794
 795   static listAllAndSharedByActorForOutbox (actorId: number, start: number, count: number) {
 796     function getRawQuery (select: string) {
 797       const queryVideo = 'SELECT ' + select + ' FROM "video" AS "Video" ' +
 798         'INNER JOIN "videoChannel" AS "VideoChannel" ON "VideoChannel"."id" = "Video"."channelId" ' +
 799         'INNER JOIN "account" AS "Account" ON "Account"."id" = "VideoChannel"."accountId" ' +
 800         'WHERE "Account"."actorId" = ' + actorId
 801       const queryVideoShare = 'SELECT ' + select + ' FROM "videoShare" AS "VideoShare" ' +
 802         'INNER JOIN "video" AS "Video" ON "Video"."id" = "VideoShare"."videoId" ' +
 803         'WHERE "VideoShare"."actorId" = ' + actorId
 804
 805       return `(${queryVideo}) UNION (${queryVideoShare})`
 806     }
 807
 808     const rawQuery = getRawQuery('"Video"."id"')
 809     const rawCountQuery = getRawQuery('COUNT("Video"."id") as "total"')
 810
 811     const query = {
 812       distinct: true,
 813       offset: start,
 814       limit: count,
 815       order: getVideoSort('createdAt', [ 'Tags', 'name', 'ASC' ]),
 816       where: {
 817         id: {
 818           [ Sequelize.Op.in ]: Sequelize.literal('(' + rawQuery + ')')
 819         },
 820         [ Sequelize.Op.or ]: [
 821           { privacy: VideoPrivacy.PUBLIC },
 822           { privacy: VideoPrivacy.UNLISTED }
 823         ]
 824       },
 825       include: [
 826         {
 827           attributes: [ 'language' ],
 828           model: VideoCaptionModel.unscoped(),
 829           required: false
 830         },
 831         {
 832           attributes: [ 'id', 'url' ],
 833           model: VideoShareModel.unscoped(),
 834           required: false,
 835           // We only want videos shared by this actor
 836           where: {
 837             [ Sequelize.Op.and ]: [
 838               {
 839                 id: {
 840                   [ Sequelize.Op.not ]: null
 841                 }
 842               },
 843               {
 844                 actorId
 845               }
 846             ]
 847           },
 848           include: [
 849             {
 850               attributes: [ 'id', 'url' ],
 851               model: ActorModel.unscoped()
 852             }
 853           ]
 854         },
 855         {
 856           model: VideoChannelModel.unscoped(),
 857           required: true,
 858           include: [
 859             {
 860               attributes: [ 'name' ],
 861               model: AccountModel.unscoped(),
 862               required: true,
 863               include: [
 864                 {
 865                   attributes: [ 'id', 'url', 'followersUrl' ],
 866                   model: ActorModel.unscoped(),
 867                   required: true
 868                 }
 869               ]
 870             },
 871             {
 872               attributes: [ 'id', 'url', 'followersUrl' ],
 873               model: ActorModel.unscoped(),
 874               required: true
 875             }
 876           ]
 877         },
 878         VideoFileModel,
 879         TagModel
 880       ]
 881     }
 882
 883     return Bluebird.all([
 884       // FIXME: typing issue
 885       VideoModel.findAll(query as any),
 886       VideoModel.sequelize.query(rawCountQuery, { type: Sequelize.QueryTypes.SELECT })
 887     ]).then(([ rows, totals ]) => {
 888       // totals: totalVideos + totalVideoShares
 889       let totalVideos = 0
 890       let totalVideoShares = 0
 891       if (totals[ 0 ]) totalVideos = parseInt(totals[ 0 ].total, 10)
 892       if (totals[ 1 ]) totalVideoShares = parseInt(totals[ 1 ].total, 10)
 893
 894       const total = totalVideos + totalVideoShares
 895       return {
 896         data: rows,
 897         total: total
 898       }
 899     })
 900   }
 901
 902   static listUserVideosForApi (accountId: number, start: number, count: number, sort: string, withFiles = false) {
 903     const query: IFindOptions<VideoModel> = {
 904       offset: start,
 905       limit: count,
 906       order: getVideoSort(sort),
 907       include: [
 908         {
 909           model: VideoChannelModel,
 910           required: true,
 911           include: [
 912             {
 913               model: AccountModel,
 914               where: {
 915                 id: accountId
 916               },
 917               required: true
 918             }
 919           ]
 920         },
 921         {
 922           model: ScheduleVideoUpdateModel,
 923           required: false
 924         },
 925         {
 926           model: VideoBlacklistModel,
 927           required: false
 928         }
 929       ]
 930     }
 931
 932     if (withFiles === true) {
 933       query.include.push({
 934         model: VideoFileModel.unscoped(),
 935         required: true
 936       })
 937     }
 938
 939     return VideoModel.findAndCountAll(query).then(({ rows, count }) => {
 940       return {
 941         data: rows,
 942         total: count
 943       }
 944     })
 945   }
 946
 947   static async listForApi (options: {
 948     start: number,
 949     count: number,
 950     sort: string,
 951     nsfw: boolean,
 952     includeLocalVideos: boolean,
 953     withFiles: boolean,
 954     categoryOneOf?: number[],
 955     licenceOneOf?: number[],
 956     languageOneOf?: string[],
 957     tagsOneOf?: string[],
 958     tagsAllOf?: string[],
 959     filter?: VideoFilter,
 960     accountId?: number,
 961     videoChannelId?: number,
 962     actorId?: number
 963     trendingDays?: number,
 964     userId?: number
 965   }, countVideos = true) {
 966     const query: IFindOptions<VideoModel> = {
 967       offset: options.start,
 968       limit: options.count,
 969       order: getVideoSort(options.sort)
 970     }
 971
 972     let trendingDays: number
 973     if (options.sort.endsWith('trending')) {
 974       trendingDays = CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
 975
 976       query.group = 'VideoModel.id'
 977     }
 978
 979     // actorId === null has a meaning, so just check undefined
 980     const actorId = options.actorId !== undefined ? options.actorId : (await getServerActor()).id
 981
 982     const queryOptions = {
 983       actorId,
 984       nsfw: options.nsfw,
 985       categoryOneOf: options.categoryOneOf,
 986       licenceOneOf: options.licenceOneOf,
 987       languageOneOf: options.languageOneOf,
 988       tagsOneOf: options.tagsOneOf,
 989       tagsAllOf: options.tagsAllOf,
 990       filter: options.filter,
 991       withFiles: options.withFiles,
 992       accountId: options.accountId,
 993       videoChannelId: options.videoChannelId,
 994       includeLocalVideos: options.includeLocalVideos,
 995       userId: options.userId,
 996       trendingDays
 997     }
 998
 999     return VideoModel.getAvailableForApi(query, queryOptions, countVideos)
1000   }
1001
1002   static async searchAndPopulateAccountAndServer (options: {
1003     includeLocalVideos: boolean
1004     search?: string
1005     start?: number
1006     count?: number
1007     sort?: string
1008     startDate?: string // ISO 8601
1009     endDate?: string // ISO 8601
1010     nsfw?: boolean
1011     categoryOneOf?: number[]
1012     licenceOneOf?: number[]
1013     languageOneOf?: string[]
1014     tagsOneOf?: string[]
1015     tagsAllOf?: string[]
1016     durationMin?: number // seconds
1017     durationMax?: number // seconds
1018     userId?: number
1019   }) {
1020     const whereAnd = []
1021
1022     if (options.startDate || options.endDate) {
1023       const publishedAtRange = {}
1024
1025       if (options.startDate) publishedAtRange[ Sequelize.Op.gte ] = options.startDate
1026       if (options.endDate) publishedAtRange[ Sequelize.Op.lte ] = options.endDate
1027
1028       whereAnd.push({ publishedAt: publishedAtRange })
1029     }
1030
1031     if (options.durationMin || options.durationMax) {
1032       const durationRange = {}
1033
1034       if (options.durationMin) durationRange[ Sequelize.Op.gte ] = options.durationMin
1035       if (options.durationMax) durationRange[ Sequelize.Op.lte ] = options.durationMax
1036
1037       whereAnd.push({ duration: durationRange })
1038     }
1039
1040     const attributesInclude = []
1041     const escapedSearch = VideoModel.sequelize.escape(options.search)
1042     const escapedLikeSearch = VideoModel.sequelize.escape('%' + options.search + '%')
1043     if (options.search) {
1044       whereAnd.push(
1045         {
1046           id: {
1047             [ Sequelize.Op.in ]: Sequelize.literal(
1048               '(' +
1049               'SELECT "video"."id" FROM "video" ' +
1050               'WHERE ' +
1051               'lower(immutable_unaccent("video"."name")) % lower(immutable_unaccent(' + escapedSearch + ')) OR ' +
1052               'lower(immutable_unaccent("video"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))' +
1053               'UNION ALL ' +
1054               'SELECT "video"."id" FROM "video" LEFT JOIN "videoTag" ON "videoTag"."videoId" = "video"."id" ' +
1055               'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
1056               'WHERE "tag"."name" = ' + escapedSearch +
1057               ')'
1058             )
1059           }
1060         }
1061       )
1062
1063       attributesInclude.push(createSimilarityAttribute('VideoModel.name', options.search))
1064     }
1065
1066     // Cannot search on similarity if we don't have a search
1067     if (!options.search) {
1068       attributesInclude.push(
1069         Sequelize.literal('0 as similarity')
1070       )
1071     }
1072
1073     const query: IFindOptions<VideoModel> = {
1074       attributes: {
1075         include: attributesInclude
1076       },
1077       offset: options.start,
1078       limit: options.count,
1079       order: getVideoSort(options.sort),
1080       where: {
1081         [ Sequelize.Op.and ]: whereAnd
1082       }
1083     }
1084
1085     const serverActor = await getServerActor()
1086     const queryOptions = {
1087       actorId: serverActor.id,
1088       includeLocalVideos: options.includeLocalVideos,
1089       nsfw: options.nsfw,
1090       categoryOneOf: options.categoryOneOf,
1091       licenceOneOf: options.licenceOneOf,
1092       languageOneOf: options.languageOneOf,
1093       tagsOneOf: options.tagsOneOf,
1094       tagsAllOf: options.tagsAllOf,
1095       userId: options.userId
1096     }
1097
1098     return VideoModel.getAvailableForApi(query, queryOptions)
1099   }
1100
1101   static load (id: number | string, t?: Sequelize.Transaction) {
1102     const where = VideoModel.buildWhereIdOrUUID(id)
1103     const options = {
1104       where,
1105       transaction: t
1106     }
1107
1108     return VideoModel.findOne(options)
1109   }
1110
1111   static loadOnlyId (id: number | string, t?: Sequelize.Transaction) {
1112     const where = VideoModel.buildWhereIdOrUUID(id)
1113
1114     const options = {
1115       attributes: [ 'id' ],
1116       where,
1117       transaction: t
1118     }
1119
1120     return VideoModel.findOne(options)
1121   }
1122
1123   static loadWithFile (id: number, t?: Sequelize.Transaction, logging?: boolean) {
1124     return VideoModel.scope(ScopeNames.WITH_FILES)
1125                      .findById(id, { transaction: t, logging })
1126   }
1127
1128   static loadByUUIDWithFile (uuid: string) {
1129     const options = {
1130       where: {
1131         uuid
1132       }
1133     }
1134
1135     return VideoModel
1136       .scope([ ScopeNames.WITH_FILES ])
1137       .findOne(options)
1138   }
1139
1140   static loadByUrl (url: string, transaction?: Sequelize.Transaction) {
1141     const query: IFindOptions<VideoModel> = {
1142       where: {
1143         url
1144       },
1145       transaction
1146     }
1147
1148     return VideoModel.findOne(query)
1149   }
1150
1151   static loadByUrlAndPopulateAccount (url: string, transaction?: Sequelize.Transaction) {
1152     const query: IFindOptions<VideoModel> = {
1153       where: {
1154         url
1155       },
1156       transaction
1157     }
1158
1159     return VideoModel.scope([ ScopeNames.WITH_ACCOUNT_DETAILS, ScopeNames.WITH_FILES ]).findOne(query)
1160   }
1161
1162   static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Sequelize.Transaction, userId?: number) {
1163     const where = VideoModel.buildWhereIdOrUUID(id)
1164
1165     const options = {
1166       order: [ [ 'Tags', 'name', 'ASC' ] ],
1167       where,
1168       transaction: t
1169     }
1170
1171     const scopes = [
1172       ScopeNames.WITH_TAGS,
1173       ScopeNames.WITH_BLACKLISTED,
1174       ScopeNames.WITH_FILES,
1175       ScopeNames.WITH_ACCOUNT_DETAILS,
1176       ScopeNames.WITH_SCHEDULED_UPDATE
1177     ]
1178
1179     if (userId) {
1180       scopes.push({ method: [ ScopeNames.WITH_USER_HISTORY, userId ] } as any) // FIXME: typings
1181     }
1182
1183     return VideoModel
1184       .scope(scopes)
1185       .findOne(options)
1186   }
1187
1188   static async getStats () {
1189     const totalLocalVideos = await VideoModel.count({
1190       where: {
1191         remote: false
1192       }
1193     })
1194     const totalVideos = await VideoModel.count()
1195
1196     let totalLocalVideoViews = await VideoModel.sum('views', {
1197       where: {
1198         remote: false
1199       }
1200     })
1201     // Sequelize could return null...
1202     if (!totalLocalVideoViews) totalLocalVideoViews = 0
1203
1204     return {
1205       totalLocalVideos,
1206       totalLocalVideoViews,
1207       totalVideos
1208     }
1209   }
1210
1211   static incrementViews (id: number, views: number) {
1212     return VideoModel.increment('views', {
1213       by: views,
1214       where: {
1215         id
1216       }
1217     })
1218   }
1219
1220   // threshold corresponds to how many video the field should have to be returned
1221   static async getRandomFieldSamples (field: 'category' | 'channelId', threshold: number, count: number) {
1222     const actorId = (await getServerActor()).id
1223
1224     const scopeOptions = {
1225       actorId,
1226       includeLocalVideos: true
1227     }
1228
1229     const query: IFindOptions<VideoModel> = {
1230       attributes: [ field ],
1231       limit: count,
1232       group: field,
1233       having: Sequelize.where(Sequelize.fn('COUNT', Sequelize.col(field)), {
1234         [ Sequelize.Op.gte ]: threshold
1235       }) as any, // FIXME: typings
1236       order: [ this.sequelize.random() ]
1237     }
1238
1239     return VideoModel.scope({ method: [ ScopeNames.AVAILABLE_FOR_LIST_IDS, scopeOptions ] })
1240                      .findAll(query)
1241                      .then(rows => rows.map(r => r[ field ]))
1242   }
1243
1244   static buildTrendingQuery (trendingDays: number) {
1245     return {
1246       attributes: [],
1247       subQuery: false,
1248       model: VideoViewModel,
1249       required: false,
1250       where: {
1251         startDate: {
1252           [ Sequelize.Op.gte ]: new Date(new Date().getTime() - (24 * 3600 * 1000) * trendingDays)
1253         }
1254       }
1255     }
1256   }
1257
1258   private static buildActorWhereWithFilter (filter?: VideoFilter) {
1259     if (filter && filter === 'local') {
1260       return {
1261         serverId: null
1262       }
1263     }
1264
1265     return {}
1266   }
1267
1268   private static async getAvailableForApi (
1269     query: IFindOptions<VideoModel>,
1270     options: AvailableForListIDsOptions & { userId?: number},
1271     countVideos = true
1272   ) {
1273     const idsScope = {
1274       method: [
1275         ScopeNames.AVAILABLE_FOR_LIST_IDS, options
1276       ]
1277     }
1278
1279     // Remove trending sort on count, because it uses a group by
1280     const countOptions = Object.assign({}, options, { trendingDays: undefined })
1281     const countQuery = Object.assign({}, query, { attributes: undefined, group: undefined })
1282     const countScope = {
1283       method: [
1284         ScopeNames.AVAILABLE_FOR_LIST_IDS, countOptions
1285       ]
1286     }
1287
1288     const [ count, rowsId ] = await Promise.all([
1289       countVideos ? VideoModel.scope(countScope).count(countQuery) : Promise.resolve(undefined),
1290       VideoModel.scope(idsScope).findAll(query)
1291     ])
1292     const ids = rowsId.map(r => r.id)
1293
1294     if (ids.length === 0) return { data: [], total: count }
1295
1296     // FIXME: typings
1297     const apiScope: any[] = [
1298       {
1299         method: [ ScopeNames.FOR_API, { ids, withFiles: options.withFiles } as ForAPIOptions ]
1300       }
1301     ]
1302
1303     if (options.userId) {
1304       apiScope.push({ method: [ ScopeNames.WITH_USER_HISTORY, options.userId ] })
1305     }
1306
1307     const secondQuery = {
1308       offset: 0,
1309       limit: query.limit,
1310       attributes: query.attributes,
1311       order: [ // Keep original order
1312         Sequelize.literal(
1313           ids.map(id => `"VideoModel".id = ${id} DESC`).join(', ')
1314         )
1315       ]
1316     }
1317     const rows = await VideoModel.scope(apiScope).findAll(secondQuery)
1318
1319     return {
1320       data: rows,
1321       total: count
1322     }
1323   }
1324
1325   static getCategoryLabel (id: number) {
1326     return VIDEO_CATEGORIES[ id ] || 'Misc'
1327   }
1328
1329   static getLicenceLabel (id: number) {
1330     return VIDEO_LICENCES[ id ] || 'Unknown'
1331   }
1332
1333   static getLanguageLabel (id: string) {
1334     return VIDEO_LANGUAGES[ id ] || 'Unknown'
1335   }
1336
1337   static getPrivacyLabel (id: number) {
1338     return VIDEO_PRIVACIES[ id ] || 'Unknown'
1339   }
1340
1341   static getStateLabel (id: number) {
1342     return VIDEO_STATES[ id ] || 'Unknown'
1343   }
1344
1345   static buildWhereIdOrUUID (id: number | string) {
1346     return validator.isInt('' + id) ? { id } : { uuid: id }
1347   }
1348
1349   getOriginalFile () {
1350     if (Array.isArray(this.VideoFiles) === false) return undefined
1351
1352     // The original file is the file that have the higher resolution
1353     return maxBy(this.VideoFiles, file => file.resolution)
1354   }
1355
1356   getVideoFilename (videoFile: VideoFileModel) {
1357     return this.uuid + '-' + videoFile.resolution + videoFile.extname
1358   }
1359
1360   getThumbnailName () {
1361     // We always have a copy of the thumbnail
1362     const extension = '.jpg'
1363     return this.uuid + extension
1364   }
1365
1366   getPreviewName () {
1367     const extension = '.jpg'
1368     return this.uuid + extension
1369   }
1370
1371   getTorrentFileName (videoFile: VideoFileModel) {
1372     const extension = '.torrent'
1373     return this.uuid + '-' + videoFile.resolution + extension
1374   }
1375
1376   isOwned () {
1377     return this.remote === false
1378   }
1379
1380   createPreview (videoFile: VideoFileModel) {
1381     return generateImageFromVideoFile(
1382       this.getVideoFilePath(videoFile),
1383       CONFIG.STORAGE.PREVIEWS_DIR,
1384       this.getPreviewName(),
1385       PREVIEWS_SIZE
1386     )
1387   }
1388
1389   createThumbnail (videoFile: VideoFileModel) {
1390     return generateImageFromVideoFile(
1391       this.getVideoFilePath(videoFile),
1392       CONFIG.STORAGE.THUMBNAILS_DIR,
1393       this.getThumbnailName(),
1394       THUMBNAILS_SIZE
1395     )
1396   }
1397
1398   getTorrentFilePath (videoFile: VideoFileModel) {
1399     return join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
1400   }
1401
1402   getVideoFilePath (videoFile: VideoFileModel) {
1403     return join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
1404   }
1405
1406   async createTorrentAndSetInfoHash (videoFile: VideoFileModel) {
1407     const options = {
1408       // Keep the extname, it's used by the client to stream the file inside a web browser
1409       name: `${this.name} ${videoFile.resolution}p${videoFile.extname}`,
1410       createdBy: 'PeerTube',
1411       announceList: [
1412         [ CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT + '/tracker/socket' ],
1413         [ CONFIG.WEBSERVER.URL + '/tracker/announce' ]
1414       ],
1415       urlList: [ CONFIG.WEBSERVER.URL + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile) ]
1416     }
1417
1418     const torrent = await createTorrentPromise(this.getVideoFilePath(videoFile), options)
1419
1420     const filePath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
1421     logger.info('Creating torrent %s.', filePath)
1422
1423     await writeFile(filePath, torrent)
1424
1425     const parsedTorrent = parseTorrent(torrent)
1426     videoFile.infoHash = parsedTorrent.infoHash
1427   }
1428
1429   getEmbedStaticPath () {
1430     return '/videos/embed/' + this.uuid
1431   }
1432
1433   getThumbnailStaticPath () {
1434     return join(STATIC_PATHS.THUMBNAILS, this.getThumbnailName())
1435   }
1436
1437   getPreviewStaticPath () {
1438     return join(STATIC_PATHS.PREVIEWS, this.getPreviewName())
1439   }
1440
1441   toFormattedJSON (options?: VideoFormattingJSONOptions): Video {
1442     return videoModelToFormattedJSON(this, options)
1443   }
1444
1445   toFormattedDetailsJSON (): VideoDetails {
1446     return videoModelToFormattedDetailsJSON(this)
1447   }
1448
1449   getFormattedVideoFilesJSON (): VideoFile[] {
1450     return videoFilesModelToFormattedJSON(this, this.VideoFiles)
1451   }
1452
1453   toActivityPubObject (): VideoTorrentObject {
1454     return videoModelToActivityPubObject(this)
1455   }
1456
1457   getTruncatedDescription () {
1458     if (!this.description) return null
1459
1460     const maxLength = CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
1461     return peertubeTruncate(this.description, maxLength)
1462   }
1463
1464   getOriginalFileResolution () {
1465     const originalFilePath = this.getVideoFilePath(this.getOriginalFile())
1466
1467     return getVideoFileResolution(originalFilePath)
1468   }
1469
1470   getDescriptionAPIPath () {
1471     return `/api/${API_VERSION}/videos/${this.uuid}/description`
1472   }
1473
1474   removeThumbnail () {
1475     const thumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
1476     return remove(thumbnailPath)
1477       .catch(err => logger.warn('Cannot delete thumbnail %s.', thumbnailPath, { err }))
1478   }
1479
1480   removePreview () {
1481     const previewPath = join(CONFIG.STORAGE.PREVIEWS_DIR + this.getPreviewName())
1482     return remove(previewPath)
1483       .catch(err => logger.warn('Cannot delete preview %s.', previewPath, { err }))
1484   }
1485
1486   removeFile (videoFile: VideoFileModel) {
1487     const filePath = join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
1488     return remove(filePath)
1489       .catch(err => logger.warn('Cannot delete file %s.', filePath, { err }))
1490   }
1491
1492   removeTorrent (videoFile: VideoFileModel) {
1493     const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
1494     return remove(torrentPath)
1495       .catch(err => logger.warn('Cannot delete torrent %s.', torrentPath, { err }))
1496   }
1497
1498   isOutdated () {
1499     if (this.isOwned()) return false
1500
1501     const now = Date.now()
1502     const createdAtTime = this.createdAt.getTime()
1503     const updatedAtTime = this.updatedAt.getTime()
1504
1505     return (now - createdAtTime) > ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL &&
1506       (now - updatedAtTime) > ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL
1507   }
1508
1509   getBaseUrls () {
1510     let baseUrlHttp
1511     let baseUrlWs
1512
1513     if (this.isOwned()) {
1514       baseUrlHttp = CONFIG.WEBSERVER.URL
1515       baseUrlWs = CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
1516     } else {
1517       baseUrlHttp = REMOTE_SCHEME.HTTP + '://' + this.VideoChannel.Account.Actor.Server.host
1518       baseUrlWs = REMOTE_SCHEME.WS + '://' + this.VideoChannel.Account.Actor.Server.host
1519     }
1520
1521     return { baseUrlHttp, baseUrlWs }
1522   }
1523
1524   generateMagnetUri (videoFile: VideoFileModel, baseUrlHttp: string, baseUrlWs: string) {
1525     const xs = this.getTorrentUrl(videoFile, baseUrlHttp)
1526     const announce = [ baseUrlWs + '/tracker/socket', baseUrlHttp + '/tracker/announce' ]
1527     let urlList = [ this.getVideoFileUrl(videoFile, baseUrlHttp) ]
1528
1529     const redundancies = videoFile.RedundancyVideos
1530     if (isArray(redundancies)) urlList = urlList.concat(redundancies.map(r => r.fileUrl))
1531
1532     const magnetHash = {
1533       xs,
1534       announce,
1535       urlList,
1536       infoHash: videoFile.infoHash,
1537       name: this.name
1538     }
1539
1540     return magnetUtil.encode(magnetHash)
1541   }
1542
1543   getThumbnailUrl (baseUrlHttp: string) {
1544     return baseUrlHttp + STATIC_PATHS.THUMBNAILS + this.getThumbnailName()
1545   }
1546
1547   getTorrentUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1548     return baseUrlHttp + STATIC_PATHS.TORRENTS + this.getTorrentFileName(videoFile)
1549   }
1550
1551   getTorrentDownloadUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1552     return baseUrlHttp + STATIC_DOWNLOAD_PATHS.TORRENTS + this.getTorrentFileName(videoFile)
1553   }
1554
1555   getVideoFileUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1556     return baseUrlHttp + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile)
1557   }
1558
1559   getVideoFileDownloadUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1560     return baseUrlHttp + STATIC_DOWNLOAD_PATHS.VIDEOS + this.getVideoFilename(videoFile)
1561   }
1562 }