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