server/models/video/video.ts

   1 import * as Bluebird from 'bluebird'
   2 import { map, maxBy, truncate } from 'lodash'
   3 import * as magnetUtil from 'magnet-uri'
   4 import * as parseTorrent from 'parse-torrent'
   5 import { join } from 'path'
   6 import * as Sequelize from 'sequelize'
   7 import {
   8   AfterDestroy,
   9   AllowNull,
  10   BelongsTo,
  11   BelongsToMany,
  12   Column,
  13   CreatedAt,
  14   DataType,
  15   Default,
  16   ForeignKey,
  17   HasMany,
  18   IFindOptions,
  19   Is,
  20   IsInt,
  21   IsUUID,
  22   Min,
  23   Model,
  24   Scopes,
  25   Table,
  26   UpdatedAt
  27 } from 'sequelize-typescript'
  28 import { IIncludeOptions } from 'sequelize-typescript/lib/interfaces/IIncludeOptions'
  29 import { VideoPrivacy, VideoResolution } from '../../../shared'
  30 import { VideoTorrentObject } from '../../../shared/models/activitypub/objects'
  31 import { Video, VideoDetails } from '../../../shared/models/videos'
  32 import {
  33   activityPubCollection,
  34   createTorrentPromise,
  35   generateImageFromVideoFile,
  36   getVideoFileHeight,
  37   logger,
  38   renamePromise,
  39   statPromise,
  40   transcode,
  41   unlinkPromise,
  42   writeFilePromise
  43 } from '../../helpers'
  44 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub'
  45 import {
  46   isVideoCategoryValid,
  47   isVideoDescriptionValid,
  48   isVideoDurationValid,
  49   isVideoLanguageValid,
  50   isVideoLicenceValid,
  51   isVideoNameValid,
  52   isVideoNSFWValid,
  53   isVideoPrivacyValid
  54 } from '../../helpers/custom-validators/videos'
  55 import {
  56   API_VERSION,
  57   CONFIG,
  58   CONSTRAINTS_FIELDS,
  59   PREVIEWS_SIZE,
  60   REMOTE_SCHEME,
  61   STATIC_PATHS,
  62   THUMBNAILS_SIZE,
  63   VIDEO_CATEGORIES,
  64   VIDEO_LANGUAGES,
  65   VIDEO_LICENCES,
  66   VIDEO_PRIVACIES
  67 } from '../../initializers'
  68 import { getAnnounceActivityPubUrl } from '../../lib/activitypub'
  69 import { sendDeleteVideo } from '../../lib/activitypub/send'
  70 import { AccountModel } from '../account/account'
  71 import { AccountVideoRateModel } from '../account/account-video-rate'
  72 import { ActorModel } from '../activitypub/actor'
  73 import { ServerModel } from '../server/server'
  74 import { getSort, throwIfNotValid } from '../utils'
  75 import { TagModel } from './tag'
  76 import { VideoAbuseModel } from './video-abuse'
  77 import { VideoChannelModel } from './video-channel'
  78 import { VideoFileModel } from './video-file'
  79 import { VideoShareModel } from './video-share'
  80 import { VideoTagModel } from './video-tag'
  81
  82 enum ScopeNames {
  83   AVAILABLE_FOR_LIST = 'AVAILABLE_FOR_LIST',
  84   WITH_ACCOUNT = 'WITH_ACCOUNT',
  85   WITH_TAGS = 'WITH_TAGS',
  86   WITH_FILES = 'WITH_FILES',
  87   WITH_SHARES = 'WITH_SHARES',
  88   WITH_RATES = 'WITH_RATES'
  89 }
  90
  91 @Scopes({
  92   [ScopeNames.AVAILABLE_FOR_LIST]: {
  93     where: {
  94       id: {
  95         [Sequelize.Op.notIn]: Sequelize.literal(
  96           '(SELECT "videoBlacklist"."videoId" FROM "videoBlacklist")'
  97         )
  98       },
  99       privacy: VideoPrivacy.PUBLIC
 100     }
 101   },
 102   [ScopeNames.WITH_ACCOUNT]: {
 103     include: [
 104       {
 105         model: () => VideoChannelModel,
 106         required: true,
 107         include: [
 108           {
 109             model: () => AccountModel,
 110             required: true,
 111             include: [
 112               {
 113                 model: () => ActorModel,
 114                 required: true,
 115                 include: [
 116                   {
 117                     model: () => ServerModel,
 118                     required: false
 119                   }
 120                 ]
 121               }
 122             ]
 123           }
 124         ]
 125       }
 126     ]
 127   },
 128   [ScopeNames.WITH_TAGS]: {
 129     include: [ () => TagModel ]
 130   },
 131   [ScopeNames.WITH_FILES]: {
 132     include: [
 133       {
 134         model: () => VideoFileModel,
 135         required: true
 136       }
 137     ]
 138   },
 139   [ScopeNames.WITH_SHARES]: {
 140     include: [
 141       {
 142         model: () => VideoShareModel,
 143         include: [ () => ActorModel ]
 144       }
 145     ]
 146   },
 147   [ScopeNames.WITH_RATES]: {
 148     include: [
 149       {
 150         model: () => AccountVideoRateModel,
 151         include: [ () => AccountModel ]
 152       }
 153     ]
 154   }
 155 })
 156 @Table({
 157   tableName: 'video',
 158   indexes: [
 159     {
 160       fields: [ 'name' ]
 161     },
 162     {
 163       fields: [ 'createdAt' ]
 164     },
 165     {
 166       fields: [ 'duration' ]
 167     },
 168     {
 169       fields: [ 'views' ]
 170     },
 171     {
 172       fields: [ 'likes' ]
 173     },
 174     {
 175       fields: [ 'uuid' ]
 176     },
 177     {
 178       fields: [ 'channelId' ]
 179     }
 180   ]
 181 })
 182 export class VideoModel extends Model<VideoModel> {
 183
 184   @AllowNull(false)
 185   @Default(DataType.UUIDV4)
 186   @IsUUID(4)
 187   @Column(DataType.UUID)
 188   uuid: string
 189
 190   @AllowNull(false)
 191   @Is('VideoName', value => throwIfNotValid(value, isVideoNameValid, 'name'))
 192   @Column
 193   name: string
 194
 195   @AllowNull(true)
 196   @Default(null)
 197   @Is('VideoCategory', value => throwIfNotValid(value, isVideoCategoryValid, 'category'))
 198   @Column
 199   category: number
 200
 201   @AllowNull(true)
 202   @Default(null)
 203   @Is('VideoLicence', value => throwIfNotValid(value, isVideoLicenceValid, 'licence'))
 204   @Column
 205   licence: number
 206
 207   @AllowNull(true)
 208   @Default(null)
 209   @Is('VideoLanguage', value => throwIfNotValid(value, isVideoLanguageValid, 'language'))
 210   @Column
 211   language: number
 212
 213   @AllowNull(false)
 214   @Is('VideoPrivacy', value => throwIfNotValid(value, isVideoPrivacyValid, 'privacy'))
 215   @Column
 216   privacy: number
 217
 218   @AllowNull(false)
 219   @Is('VideoNSFW', value => throwIfNotValid(value, isVideoNSFWValid, 'NSFW boolean'))
 220   @Column
 221   nsfw: boolean
 222
 223   @AllowNull(true)
 224   @Default(null)
 225   @Is('VideoDescription', value => throwIfNotValid(value, isVideoDescriptionValid, 'description'))
 226   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.DESCRIPTION.max))
 227   description: string
 228
 229   @AllowNull(false)
 230   @Is('VideoDuration', value => throwIfNotValid(value, isVideoDurationValid, 'duration'))
 231   @Column
 232   duration: number
 233
 234   @AllowNull(false)
 235   @Default(0)
 236   @IsInt
 237   @Min(0)
 238   @Column
 239   views: number
 240
 241   @AllowNull(false)
 242   @Default(0)
 243   @IsInt
 244   @Min(0)
 245   @Column
 246   likes: number
 247
 248   @AllowNull(false)
 249   @Default(0)
 250   @IsInt
 251   @Min(0)
 252   @Column
 253   dislikes: number
 254
 255   @AllowNull(false)
 256   @Column
 257   remote: boolean
 258
 259   @AllowNull(false)
 260   @Is('VideoUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
 261   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.URL.max))
 262   url: string
 263
 264   @CreatedAt
 265   createdAt: Date
 266
 267   @UpdatedAt
 268   updatedAt: Date
 269
 270   @ForeignKey(() => VideoChannelModel)
 271   @Column
 272   channelId: number
 273
 274   @BelongsTo(() => VideoChannelModel, {
 275     foreignKey: {
 276       allowNull: true
 277     },
 278     onDelete: 'cascade'
 279   })
 280   VideoChannel: VideoChannelModel
 281
 282   @BelongsToMany(() => TagModel, {
 283     foreignKey: 'videoId',
 284     through: () => VideoTagModel,
 285     onDelete: 'CASCADE'
 286   })
 287   Tags: TagModel[]
 288
 289   @HasMany(() => VideoAbuseModel, {
 290     foreignKey: {
 291       name: 'videoId',
 292       allowNull: false
 293     },
 294     onDelete: 'cascade'
 295   })
 296   VideoAbuses: VideoAbuseModel[]
 297
 298   @HasMany(() => VideoFileModel, {
 299     foreignKey: {
 300       name: 'videoId',
 301       allowNull: false
 302     },
 303     onDelete: 'cascade'
 304   })
 305   VideoFiles: VideoFileModel[]
 306
 307   @HasMany(() => VideoShareModel, {
 308     foreignKey: {
 309       name: 'videoId',
 310       allowNull: false
 311     },
 312     onDelete: 'cascade'
 313   })
 314   VideoShares: VideoShareModel[]
 315
 316   @HasMany(() => AccountVideoRateModel, {
 317     foreignKey: {
 318       name: 'videoId',
 319       allowNull: false
 320     },
 321     onDelete: 'cascade'
 322   })
 323   AccountVideoRates: AccountVideoRateModel[]
 324
 325   @AfterDestroy
 326   static removeFilesAndSendDelete (instance: VideoModel) {
 327     const tasks = []
 328
 329     tasks.push(
 330       instance.removeThumbnail()
 331     )
 332
 333     if (instance.isOwned()) {
 334       tasks.push(
 335         instance.removePreview(),
 336         sendDeleteVideo(instance, undefined)
 337       )
 338
 339       // Remove physical files and torrents
 340       instance.VideoFiles.forEach(file => {
 341         tasks.push(instance.removeFile(file))
 342         tasks.push(instance.removeTorrent(file))
 343       })
 344     }
 345
 346     return Promise.all(tasks)
 347       .catch(err => {
 348         logger.error('Some errors when removing files of video %s in after destroy hook.', instance.uuid, err)
 349       })
 350   }
 351
 352   static list () {
 353     return VideoModel.scope(ScopeNames.WITH_FILES).findAll()
 354   }
 355
 356   static listAllAndSharedByActorForOutbox (actorId: number, start: number, count: number) {
 357     function getRawQuery (select: string) {
 358       const queryVideo = 'SELECT ' + select + ' FROM "video" AS "Video" ' +
 359         'INNER JOIN "videoChannel" AS "VideoChannel" ON "VideoChannel"."id" = "Video"."channelId" ' +
 360         'INNER JOIN "account" AS "Account" ON "Account"."id" = "VideoChannel"."accountId" ' +
 361         'WHERE "Account"."actorId" = ' + actorId
 362       const queryVideoShare = 'SELECT ' + select + ' FROM "videoShare" AS "VideoShare" ' +
 363         'INNER JOIN "video" AS "Video" ON "Video"."id" = "VideoShare"."videoId" ' +
 364         'WHERE "VideoShare"."actorId" = ' + actorId
 365
 366       return `(${queryVideo}) UNION (${queryVideoShare})`
 367     }
 368
 369     const rawQuery = getRawQuery('"Video"."id"')
 370     const rawCountQuery = getRawQuery('COUNT("Video"."id") as "total"')
 371
 372     const query = {
 373       distinct: true,
 374       offset: start,
 375       limit: count,
 376       order: [ getSort('createdAt'), [ 'Tags', 'name', 'ASC' ] ],
 377       where: {
 378         id: {
 379           [Sequelize.Op.in]: Sequelize.literal('(' + rawQuery + ')')
 380         }
 381       },
 382       include: [
 383         {
 384           model: VideoShareModel,
 385           required: false,
 386           where: {
 387             [Sequelize.Op.and]: [
 388               {
 389                 id: {
 390                   [Sequelize.Op.not]: null
 391                 }
 392               },
 393               {
 394                 actorId
 395               }
 396             ]
 397           },
 398           include: [
 399             {
 400               model: ActorModel,
 401               required: true
 402             }
 403           ]
 404         },
 405         {
 406           model: VideoChannelModel,
 407           required: true,
 408           include: [
 409             {
 410               model: AccountModel,
 411               required: true
 412             }
 413           ]
 414         },
 415         {
 416           model: AccountVideoRateModel,
 417           include: [ AccountModel ]
 418         },
 419         VideoFileModel,
 420         TagModel
 421       ]
 422     }
 423
 424     return Bluebird.all([
 425       // FIXME: typing issue
 426       VideoModel.findAll(query as any),
 427       VideoModel.sequelize.query(rawCountQuery, { type: Sequelize.QueryTypes.SELECT })
 428     ]).then(([ rows, totals ]) => {
 429       // totals: totalVideos + totalVideoShares
 430       let totalVideos = 0
 431       let totalVideoShares = 0
 432       if (totals[0]) totalVideos = parseInt(totals[0].total, 10)
 433       if (totals[1]) totalVideoShares = parseInt(totals[1].total, 10)
 434
 435       const total = totalVideos + totalVideoShares
 436       return {
 437         data: rows,
 438         total: total
 439       }
 440     })
 441   }
 442
 443   static listUserVideosForApi (userId: number, start: number, count: number, sort: string) {
 444     const query = {
 445       offset: start,
 446       limit: count,
 447       order: [ getSort(sort) ],
 448       include: [
 449         {
 450           model: VideoChannelModel,
 451           required: true,
 452           include: [
 453             {
 454               model: AccountModel,
 455               where: {
 456                 userId
 457               },
 458               required: true
 459             }
 460           ]
 461         }
 462       ]
 463     }
 464
 465     return VideoModel.findAndCountAll(query).then(({ rows, count }) => {
 466       return {
 467         data: rows,
 468         total: count
 469       }
 470     })
 471   }
 472
 473   static listForApi (start: number, count: number, sort: string) {
 474     const query = {
 475       offset: start,
 476       limit: count,
 477       order: [ getSort(sort) ]
 478     }
 479
 480     return VideoModel.scope([ ScopeNames.AVAILABLE_FOR_LIST, ScopeNames.WITH_ACCOUNT ])
 481       .findAndCountAll(query)
 482       .then(({ rows, count }) => {
 483         return {
 484           data: rows,
 485           total: count
 486         }
 487       })
 488   }
 489
 490   static load (id: number) {
 491     return VideoModel.findById(id)
 492   }
 493
 494   static loadByUrlAndPopulateAccount (url: string, t?: Sequelize.Transaction) {
 495     const query: IFindOptions<VideoModel> = {
 496       where: {
 497         url
 498       }
 499     }
 500
 501     if (t !== undefined) query.transaction = t
 502
 503     return VideoModel.scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_FILES ]).findOne(query)
 504   }
 505
 506   static loadByUUIDOrURL (uuid: string, url: string, t?: Sequelize.Transaction) {
 507     const query: IFindOptions<VideoModel> = {
 508       where: {
 509         [Sequelize.Op.or]: [
 510           { uuid },
 511           { url }
 512         ]
 513       }
 514     }
 515
 516     if (t !== undefined) query.transaction = t
 517
 518     return VideoModel.scope(ScopeNames.WITH_FILES).findOne(query)
 519   }
 520
 521   static loadAndPopulateAccountAndServerAndTags (id: number) {
 522     const options = {
 523       order: [ [ 'Tags', 'name', 'ASC' ] ]
 524     }
 525
 526     return VideoModel
 527       .scope([ ScopeNames.WITH_RATES, ScopeNames.WITH_SHARES, ScopeNames.WITH_TAGS, ScopeNames.WITH_FILES, ScopeNames.WITH_ACCOUNT ])
 528       .findById(id, options)
 529   }
 530
 531   static loadByUUID (uuid: string) {
 532     const options = {
 533       where: {
 534         uuid
 535       }
 536     }
 537
 538     return VideoModel
 539       .scope([ ScopeNames.WITH_FILES ])
 540       .findOne(options)
 541   }
 542
 543   static loadByUUIDAndPopulateAccountAndServerAndTags (uuid: string) {
 544     const options = {
 545       order: [ [ 'Tags', 'name', 'ASC' ] ],
 546       where: {
 547         uuid
 548       }
 549     }
 550
 551     return VideoModel
 552       .scope([ ScopeNames.WITH_RATES, ScopeNames.WITH_SHARES, ScopeNames.WITH_TAGS, ScopeNames.WITH_FILES, ScopeNames.WITH_ACCOUNT ])
 553       .findOne(options)
 554   }
 555
 556   static searchAndPopulateAccountAndServerAndTags (value: string, start: number, count: number, sort: string) {
 557     const serverInclude: IIncludeOptions = {
 558       model: ServerModel,
 559       required: false
 560     }
 561
 562     const accountInclude: IIncludeOptions = {
 563       model: AccountModel,
 564       include: [
 565         {
 566           model: ActorModel,
 567           required: true,
 568           include: [ serverInclude ]
 569         }
 570       ]
 571     }
 572
 573     const videoChannelInclude: IIncludeOptions = {
 574       model: VideoChannelModel,
 575       include: [ accountInclude ],
 576       required: true
 577     }
 578
 579     const tagInclude: IIncludeOptions = {
 580       model: TagModel
 581     }
 582
 583     const query: IFindOptions<VideoModel> = {
 584       distinct: true, // Because we have tags
 585       offset: start,
 586       limit: count,
 587       order: [ getSort(sort) ],
 588       where: {}
 589     }
 590
 591     // TODO: search on tags too
 592     // const escapedValue = Video['sequelize'].escape('%' + value + '%')
 593     // query.where['id'][Sequelize.Op.in] = Video['sequelize'].literal(
 594     //   `(SELECT "VideoTags"."videoId"
 595     //     FROM "Tags"
 596     //     INNER JOIN "VideoTags" ON "Tags"."id" = "VideoTags"."tagId"
 597     //     WHERE name ILIKE ${escapedValue}
 598     //    )`
 599     // )
 600
 601     // TODO: search on account too
 602     // accountInclude.where = {
 603     //   name: {
 604     //     [Sequelize.Op.iLike]: '%' + value + '%'
 605     //   }
 606     // }
 607     query.where['name'] = {
 608       [Sequelize.Op.iLike]: '%' + value + '%'
 609     }
 610
 611     query.include = [
 612       videoChannelInclude, tagInclude
 613     ]
 614
 615     return VideoModel.scope([ ScopeNames.AVAILABLE_FOR_LIST ])
 616       .findAndCountAll(query).then(({ rows, count }) => {
 617         return {
 618           data: rows,
 619           total: count
 620         }
 621       })
 622   }
 623
 624   getOriginalFile () {
 625     if (Array.isArray(this.VideoFiles) === false) return undefined
 626
 627     // The original file is the file that have the higher resolution
 628     return maxBy(this.VideoFiles, file => file.resolution)
 629   }
 630
 631   getVideoFilename (videoFile: VideoFileModel) {
 632     return this.uuid + '-' + videoFile.resolution + videoFile.extname
 633   }
 634
 635   getThumbnailName () {
 636     // We always have a copy of the thumbnail
 637     const extension = '.jpg'
 638     return this.uuid + extension
 639   }
 640
 641   getPreviewName () {
 642     const extension = '.jpg'
 643     return this.uuid + extension
 644   }
 645
 646   getTorrentFileName (videoFile: VideoFileModel) {
 647     const extension = '.torrent'
 648     return this.uuid + '-' + videoFile.resolution + extension
 649   }
 650
 651   isOwned () {
 652     return this.remote === false
 653   }
 654
 655   createPreview (videoFile: VideoFileModel) {
 656     const imageSize = PREVIEWS_SIZE.width + 'x' + PREVIEWS_SIZE.height
 657
 658     return generateImageFromVideoFile(
 659       this.getVideoFilePath(videoFile),
 660       CONFIG.STORAGE.PREVIEWS_DIR,
 661       this.getPreviewName(),
 662       imageSize
 663     )
 664   }
 665
 666   createThumbnail (videoFile: VideoFileModel) {
 667     const imageSize = THUMBNAILS_SIZE.width + 'x' + THUMBNAILS_SIZE.height
 668
 669     return generateImageFromVideoFile(
 670       this.getVideoFilePath(videoFile),
 671       CONFIG.STORAGE.THUMBNAILS_DIR,
 672       this.getThumbnailName(),
 673       imageSize
 674     )
 675   }
 676
 677   getVideoFilePath (videoFile: VideoFileModel) {
 678     return join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
 679   }
 680
 681   createTorrentAndSetInfoHash = async function (videoFile: VideoFileModel) {
 682     const options = {
 683       announceList: [
 684         [ CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT + '/tracker/socket' ]
 685       ],
 686       urlList: [
 687         CONFIG.WEBSERVER.URL + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile)
 688       ]
 689     }
 690
 691     const torrent = await createTorrentPromise(this.getVideoFilePath(videoFile), options)
 692
 693     const filePath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
 694     logger.info('Creating torrent %s.', filePath)
 695
 696     await writeFilePromise(filePath, torrent)
 697
 698     const parsedTorrent = parseTorrent(torrent)
 699     videoFile.infoHash = parsedTorrent.infoHash
 700   }
 701
 702   getEmbedPath () {
 703     return '/videos/embed/' + this.uuid
 704   }
 705
 706   getThumbnailPath () {
 707     return join(STATIC_PATHS.THUMBNAILS, this.getThumbnailName())
 708   }
 709
 710   getPreviewPath () {
 711     return join(STATIC_PATHS.PREVIEWS, this.getPreviewName())
 712   }
 713
 714   toFormattedJSON () {
 715     let serverHost
 716
 717     if (this.VideoChannel.Account.Actor.Server) {
 718       serverHost = this.VideoChannel.Account.Actor.Server.host
 719     } else {
 720       // It means it's our video
 721       serverHost = CONFIG.WEBSERVER.HOST
 722     }
 723
 724     return {
 725       id: this.id,
 726       uuid: this.uuid,
 727       name: this.name,
 728       category: this.category,
 729       categoryLabel: this.getCategoryLabel(),
 730       licence: this.licence,
 731       licenceLabel: this.getLicenceLabel(),
 732       language: this.language,
 733       languageLabel: this.getLanguageLabel(),
 734       nsfw: this.nsfw,
 735       description: this.getTruncatedDescription(),
 736       serverHost,
 737       isLocal: this.isOwned(),
 738       accountName: this.VideoChannel.Account.name,
 739       duration: this.duration,
 740       views: this.views,
 741       likes: this.likes,
 742       dislikes: this.dislikes,
 743       thumbnailPath: this.getThumbnailPath(),
 744       previewPath: this.getPreviewPath(),
 745       embedPath: this.getEmbedPath(),
 746       createdAt: this.createdAt,
 747       updatedAt: this.updatedAt
 748     } as Video
 749   }
 750
 751   toFormattedDetailsJSON () {
 752     const formattedJson = this.toFormattedJSON()
 753
 754     // Maybe our server is not up to date and there are new privacy settings since our version
 755     let privacyLabel = VIDEO_PRIVACIES[this.privacy]
 756     if (!privacyLabel) privacyLabel = 'Unknown'
 757
 758     const detailsJson = {
 759       privacyLabel,
 760       privacy: this.privacy,
 761       descriptionPath: this.getDescriptionPath(),
 762       channel: this.VideoChannel.toFormattedJSON(),
 763       account: this.VideoChannel.Account.toFormattedJSON(),
 764       tags: map<TagModel, string>(this.Tags, 'name'),
 765       files: []
 766     }
 767
 768     // Format and sort video files
 769     const { baseUrlHttp, baseUrlWs } = this.getBaseUrls()
 770     detailsJson.files = this.VideoFiles
 771       .map(videoFile => {
 772         let resolutionLabel = videoFile.resolution + 'p'
 773
 774         return {
 775           resolution: videoFile.resolution,
 776           resolutionLabel,
 777           magnetUri: this.generateMagnetUri(videoFile, baseUrlHttp, baseUrlWs),
 778           size: videoFile.size,
 779           torrentUrl: this.getTorrentUrl(videoFile, baseUrlHttp),
 780           fileUrl: this.getVideoFileUrl(videoFile, baseUrlHttp)
 781         }
 782       })
 783       .sort((a, b) => {
 784         if (a.resolution < b.resolution) return 1
 785         if (a.resolution === b.resolution) return 0
 786         return -1
 787       })
 788
 789     return Object.assign(formattedJson, detailsJson) as VideoDetails
 790   }
 791
 792   toActivityPubObject (): VideoTorrentObject {
 793     const { baseUrlHttp, baseUrlWs } = this.getBaseUrls()
 794     if (!this.Tags) this.Tags = []
 795
 796     const tag = this.Tags.map(t => ({
 797       type: 'Hashtag' as 'Hashtag',
 798       name: t.name
 799     }))
 800
 801     let language
 802     if (this.language) {
 803       language = {
 804         identifier: this.language + '',
 805         name: this.getLanguageLabel()
 806       }
 807     }
 808
 809     let category
 810     if (this.category) {
 811       category = {
 812         identifier: this.category + '',
 813         name: this.getCategoryLabel()
 814       }
 815     }
 816
 817     let licence
 818     if (this.licence) {
 819       licence = {
 820         identifier: this.licence + '',
 821         name: this.getLicenceLabel()
 822       }
 823     }
 824
 825     let likesObject
 826     let dislikesObject
 827
 828     if (Array.isArray(this.AccountVideoRates)) {
 829       const likes: string[] = []
 830       const dislikes: string[] = []
 831
 832       for (const rate of this.AccountVideoRates) {
 833         if (rate.type === 'like') {
 834           likes.push(rate.Account.Actor.url)
 835         } else if (rate.type === 'dislike') {
 836           dislikes.push(rate.Account.Actor.url)
 837         }
 838       }
 839
 840       likesObject = activityPubCollection(likes)
 841       dislikesObject = activityPubCollection(dislikes)
 842     }
 843
 844     let sharesObject
 845     if (Array.isArray(this.VideoShares)) {
 846       const shares: string[] = []
 847
 848       for (const videoShare of this.VideoShares) {
 849         const shareUrl = getAnnounceActivityPubUrl(this.url, videoShare.Actor)
 850         shares.push(shareUrl)
 851       }
 852
 853       sharesObject = activityPubCollection(shares)
 854     }
 855
 856     const url = []
 857     for (const file of this.VideoFiles) {
 858       url.push({
 859         type: 'Link',
 860         mimeType: 'video/' + file.extname.replace('.', ''),
 861         url: this.getVideoFileUrl(file, baseUrlHttp),
 862         width: file.resolution,
 863         size: file.size
 864       })
 865
 866       url.push({
 867         type: 'Link',
 868         mimeType: 'application/x-bittorrent',
 869         url: this.getTorrentUrl(file, baseUrlHttp),
 870         width: file.resolution
 871       })
 872
 873       url.push({
 874         type: 'Link',
 875         mimeType: 'application/x-bittorrent;x-scheme-handler/magnet',
 876         url: this.generateMagnetUri(file, baseUrlHttp, baseUrlWs),
 877         width: file.resolution
 878       })
 879     }
 880
 881     // Add video url too
 882     url.push({
 883       type: 'Link',
 884       mimeType: 'text/html',
 885       url: CONFIG.WEBSERVER.URL + '/videos/watch/' + this.uuid
 886     })
 887
 888     return {
 889       type: 'Video' as 'Video',
 890       id: this.url,
 891       name: this.name,
 892       // https://www.w3.org/TR/activitystreams-vocabulary/#dfn-duration
 893       duration: 'PT' + this.duration + 'S',
 894       uuid: this.uuid,
 895       tag,
 896       category,
 897       licence,
 898       language,
 899       views: this.views,
 900       nsfw: this.nsfw,
 901       published: this.createdAt.toISOString(),
 902       updated: this.updatedAt.toISOString(),
 903       mediaType: 'text/markdown',
 904       content: this.getTruncatedDescription(),
 905       icon: {
 906         type: 'Image',
 907         url: this.getThumbnailUrl(baseUrlHttp),
 908         mediaType: 'image/jpeg',
 909         width: THUMBNAILS_SIZE.width,
 910         height: THUMBNAILS_SIZE.height
 911       },
 912       url,
 913       likes: likesObject,
 914       dislikes: dislikesObject,
 915       shares: sharesObject,
 916       attributedTo: [
 917         {
 918           type: 'Group',
 919           id: this.VideoChannel.Actor.url
 920         }
 921       ]
 922     }
 923   }
 924
 925   getTruncatedDescription () {
 926     if (!this.description) return null
 927
 928     const options = {
 929       length: CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
 930     }
 931
 932     return truncate(this.description, options)
 933   }
 934
 935   optimizeOriginalVideofile = async function () {
 936     const videosDirectory = CONFIG.STORAGE.VIDEOS_DIR
 937     const newExtname = '.mp4'
 938     const inputVideoFile = this.getOriginalFile()
 939     const videoInputPath = join(videosDirectory, this.getVideoFilename(inputVideoFile))
 940     const videoOutputPath = join(videosDirectory, this.id + '-transcoded' + newExtname)
 941
 942     const transcodeOptions = {
 943       inputPath: videoInputPath,
 944       outputPath: videoOutputPath
 945     }
 946
 947     try {
 948       // Could be very long!
 949       await transcode(transcodeOptions)
 950
 951       await unlinkPromise(videoInputPath)
 952
 953       // Important to do this before getVideoFilename() to take in account the new file extension
 954       inputVideoFile.set('extname', newExtname)
 955
 956       await renamePromise(videoOutputPath, this.getVideoFilePath(inputVideoFile))
 957       const stats = await statPromise(this.getVideoFilePath(inputVideoFile))
 958
 959       inputVideoFile.set('size', stats.size)
 960
 961       await this.createTorrentAndSetInfoHash(inputVideoFile)
 962       await inputVideoFile.save()
 963
 964     } catch (err) {
 965       // Auto destruction...
 966       this.destroy().catch(err => logger.error('Cannot destruct video after transcoding failure.', err))
 967
 968       throw err
 969     }
 970   }
 971
 972   transcodeOriginalVideofile = async function (resolution: VideoResolution) {
 973     const videosDirectory = CONFIG.STORAGE.VIDEOS_DIR
 974     const extname = '.mp4'
 975
 976     // We are sure it's x264 in mp4 because optimizeOriginalVideofile was already executed
 977     const videoInputPath = join(videosDirectory, this.getVideoFilename(this.getOriginalFile()))
 978
 979     const newVideoFile = new VideoFileModel({
 980       resolution,
 981       extname,
 982       size: 0,
 983       videoId: this.id
 984     })
 985     const videoOutputPath = join(videosDirectory, this.getVideoFilename(newVideoFile))
 986
 987     const transcodeOptions = {
 988       inputPath: videoInputPath,
 989       outputPath: videoOutputPath,
 990       resolution
 991     }
 992
 993     await transcode(transcodeOptions)
 994
 995     const stats = await statPromise(videoOutputPath)
 996
 997     newVideoFile.set('size', stats.size)
 998
 999     await this.createTorrentAndSetInfoHash(newVideoFile)
1000
1001     await newVideoFile.save()
1002
1003     this.VideoFiles.push(newVideoFile)
1004   }
1005
1006   getOriginalFileHeight () {
1007     const originalFilePath = this.getVideoFilePath(this.getOriginalFile())
1008
1009     return getVideoFileHeight(originalFilePath)
1010   }
1011
1012   getDescriptionPath () {
1013     return `/api/${API_VERSION}/videos/${this.uuid}/description`
1014   }
1015
1016   getCategoryLabel () {
1017     let categoryLabel = VIDEO_CATEGORIES[this.category]
1018     if (!categoryLabel) categoryLabel = 'Misc'
1019
1020     return categoryLabel
1021   }
1022
1023   getLicenceLabel () {
1024     let licenceLabel = VIDEO_LICENCES[this.licence]
1025     if (!licenceLabel) licenceLabel = 'Unknown'
1026
1027     return licenceLabel
1028   }
1029
1030   getLanguageLabel () {
1031     let languageLabel = VIDEO_LANGUAGES[this.language]
1032     if (!languageLabel) languageLabel = 'Unknown'
1033
1034     return languageLabel
1035   }
1036
1037   removeThumbnail () {
1038     const thumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
1039     return unlinkPromise(thumbnailPath)
1040   }
1041
1042   removePreview () {
1043     // Same name than video thumbnail
1044     return unlinkPromise(CONFIG.STORAGE.PREVIEWS_DIR + this.getPreviewName())
1045   }
1046
1047   removeFile (videoFile: VideoFileModel) {
1048     const filePath = join(CONFIG.STORAGE.VIDEOS_DIR, this.getVideoFilename(videoFile))
1049     return unlinkPromise(filePath)
1050   }
1051
1052   removeTorrent (videoFile: VideoFileModel) {
1053     const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
1054     return unlinkPromise(torrentPath)
1055   }
1056
1057   private getBaseUrls () {
1058     let baseUrlHttp
1059     let baseUrlWs
1060
1061     if (this.isOwned()) {
1062       baseUrlHttp = CONFIG.WEBSERVER.URL
1063       baseUrlWs = CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
1064     } else {
1065       baseUrlHttp = REMOTE_SCHEME.HTTP + '://' + this.VideoChannel.Account.Actor.Server.host
1066       baseUrlWs = REMOTE_SCHEME.WS + '://' + this.VideoChannel.Account.Actor.Server.host
1067     }
1068
1069     return { baseUrlHttp, baseUrlWs }
1070   }
1071
1072   private getThumbnailUrl (baseUrlHttp: string) {
1073     return baseUrlHttp + STATIC_PATHS.THUMBNAILS + this.getThumbnailName()
1074   }
1075
1076   private getTorrentUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1077     return baseUrlHttp + STATIC_PATHS.TORRENTS + this.getTorrentFileName(videoFile)
1078   }
1079
1080   private getVideoFileUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
1081     return baseUrlHttp + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile)
1082   }
1083
1084   private generateMagnetUri (videoFile: VideoFileModel, baseUrlHttp: string, baseUrlWs: string) {
1085     const xs = this.getTorrentUrl(videoFile, baseUrlHttp)
1086     const announce = [ baseUrlWs + '/tracker/socket', baseUrlHttp + '/tracker/announce' ]
1087     const urlList = [ this.getVideoFileUrl(videoFile, baseUrlHttp) ]
1088
1089     const magnetHash = {
1090       xs,
1091       announce,
1092       urlList,
1093       infoHash: videoFile.infoHash,
1094       name: this.name
1095     }
1096
1097     return magnetUtil.encode(magnetHash)
1098   }
1099 }