server/models/video/video.ts

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