X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Fvideo%2Fvideo.ts;h=a7923b477dfe82254c4abe914570a6a9d7863769;hb=04ed10b21e8e1339514faae0bb690e4d97c23b0a;hp=aa1878caac311566ae88dedbc5cf7bba4ae02349;hpb=b6a4fd6b099b3363ac59c06cfd81b54e1356d8bc;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/models/video/video.ts b/server/models/video/video.ts
index aa1878caa..a7923b477 100644
--- a/server/models/video/video.ts
+++ b/server/models/video/video.ts
@@ -1,5 +1,5 @@
 import * as Bluebird from 'bluebird'
-import { map, maxBy, truncate } from 'lodash'
+import { map, maxBy } from 'lodash'
 import * as magnetUtil from 'magnet-uri'
 import * as parseTorrent from 'parse-torrent'
 import { join } from 'path'
@@ -28,9 +28,13 @@ import {
 } from 'sequelize-typescript'
 import { VideoPrivacy, VideoResolution } from '../../../shared'
 import { VideoTorrentObject } from '../../../shared/models/activitypub/objects'
-import { Video, VideoDetails } from '../../../shared/models/videos'
+import { Video, VideoDetails, VideoFile } from '../../../shared/models/videos'
+import { VideoFilter } from '../../../shared/models/videos/video-query.type'
 import { activityPubCollection } from '../../helpers/activitypub'
-import { createTorrentPromise, renamePromise, statPromise, unlinkPromise, writeFilePromise } from '../../helpers/core-utils'
+import {
+  createTorrentPromise, peertubeTruncate, renamePromise, statPromise, unlinkPromise,
+  writeFilePromise
+} from '../../helpers/core-utils'
 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
 import { isBooleanValid } from '../../helpers/custom-validators/misc'
 import {
@@ -40,9 +44,10 @@ import {
   isVideoLanguageValid,
   isVideoLicenceValid,
   isVideoNameValid,
-  isVideoPrivacyValid, isVideoSupportValid
+  isVideoPrivacyValid,
+  isVideoSupportValid
 } from '../../helpers/custom-validators/videos'
-import { generateImageFromVideoFile, getVideoFileHeight, transcode } from '../../helpers/ffmpeg-utils'
+import { generateImageFromVideoFile, getVideoFileResolution, transcode } from '../../helpers/ffmpeg-utils'
 import { logger } from '../../helpers/logger'
 import { getServerActor } from '../../helpers/utils'
 import {
@@ -90,14 +95,15 @@ enum ScopeNames {
 }
 
 @Scopes({
-  [ScopeNames.AVAILABLE_FOR_LIST]: (actorId: number) => ({
-    where: {
-      id: {
-        [Sequelize.Op.notIn]: Sequelize.literal(
-          '(SELECT "videoBlacklist"."videoId" FROM "videoBlacklist")'
-        ),
-        [ Sequelize.Op.in ]: Sequelize.literal(
-          '(' +
+  [ScopeNames.AVAILABLE_FOR_LIST]: (actorId: number, filter?: VideoFilter, withFiles?: boolean) => {
+    const query: IFindOptions<VideoModel> = {
+      where: {
+        id: {
+          [Sequelize.Op.notIn]: Sequelize.literal(
+            '(SELECT "videoBlacklist"."videoId" FROM "videoBlacklist")'
+          ),
+          [ Sequelize.Op.in ]: Sequelize.literal(
+            '(' +
             'SELECT "videoShare"."videoId" AS "id" FROM "videoShare" ' +
             'INNER JOIN "actorFollow" ON "actorFollow"."targetActorId" = "videoShare"."actorId" ' +
             'WHERE "actorFollow"."actorId" = ' + parseInt(actorId.toString(), 10) +
@@ -108,39 +114,55 @@ enum ScopeNames {
             'INNER JOIN "actor" ON "account"."actorId" = "actor"."id" ' +
             'LEFT JOIN "actorFollow" ON "actorFollow"."targetActorId" = "actor"."id" ' +
             'WHERE "actor"."serverId" IS NULL OR "actorFollow"."actorId" = ' + parseInt(actorId.toString(), 10) +
-          ')'
-        )
+            ')'
+          )
+        },
+        privacy: VideoPrivacy.PUBLIC
       },
-      privacy: VideoPrivacy.PUBLIC
-    },
-    include: [
-      {
-        attributes: [ 'name', 'description' ],
-        model: VideoChannelModel.unscoped(),
-        required: true,
-        include: [
-          {
-            attributes: [ 'name' ],
-            model: AccountModel.unscoped(),
-            required: true,
-            include: [
-              {
-                attributes: [ 'serverId' ],
-                model: ActorModel.unscoped(),
-                required: true,
-                include: [
-                  {
-                    attributes: [ 'host' ],
-                    model: ServerModel.unscoped()
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }),
+      include: [
+        {
+          attributes: [ 'name', 'description' ],
+          model: VideoChannelModel.unscoped(),
+          required: true,
+          include: [
+            {
+              attributes: [ 'name' ],
+              model: AccountModel.unscoped(),
+              required: true,
+              include: [
+                {
+                  attributes: [ 'preferredUsername', 'url', 'serverId', 'avatarId' ],
+                  model: ActorModel.unscoped(),
+                  required: true,
+                  where: VideoModel.buildActorWhereWithFilter(filter),
+                  include: [
+                    {
+                      attributes: [ 'host' ],
+                      model: ServerModel.unscoped(),
+                      required: false
+                    },
+                    {
+                      model: AvatarModel.unscoped(),
+                      required: false
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+
+    if (withFiles === true) {
+      query.include.push({
+        model: VideoFileModel.unscoped(),
+        required: true
+      })
+    }
+
+    return query
+  },
   [ScopeNames.WITH_ACCOUNT_DETAILS]: {
     include: [
       {
@@ -195,7 +217,7 @@ enum ScopeNames {
   [ScopeNames.WITH_FILES]: {
     include: [
       {
-        model: () => VideoFileModel,
+        model: () => VideoFileModel.unscoped(),
         required: true
       }
     ]
@@ -203,8 +225,7 @@ enum ScopeNames {
   [ScopeNames.WITH_SHARES]: {
     include: [
       {
-        model: () => VideoShareModel,
-        include: [ () => ActorModel ]
+        model: () => VideoShareModel.unscoped()
       }
     ]
   },
@@ -212,14 +233,25 @@ enum ScopeNames {
     include: [
       {
         model: () => AccountVideoRateModel,
-        include: [ () => AccountModel ]
+        include: [
+          {
+            model: () => AccountModel.unscoped(),
+            required: true,
+            include: [
+              {
+                attributes: [ 'url' ],
+                model: () => ActorModel.unscoped()
+              }
+            ]
+          }
+        ]
       }
     ]
   },
   [ScopeNames.WITH_COMMENTS]: {
     include: [
       {
-        model: () => VideoCommentModel
+        model: () => VideoCommentModel.unscoped()
       }
     ]
   }
@@ -355,6 +387,11 @@ export class VideoModel extends Model<VideoModel> {
   @UpdatedAt
   updatedAt: Date
 
+  @AllowNull(false)
+  @Default(Sequelize.NOW)
+  @Column
+  publishedAt: Date
+
   @ForeignKey(() => VideoChannelModel)
   @Column
   channelId: number
@@ -465,7 +502,7 @@ export class VideoModel extends Model<VideoModel> {
 
     return Promise.all(tasks)
       .catch(err => {
-        logger.error('Some errors when removing files of video %s in after destroy hook.', instance.uuid, err)
+        logger.error('Some errors when removing files of video %s in after destroy hook.', instance.uuid, { err })
       })
   }
 
@@ -493,7 +530,7 @@ export class VideoModel extends Model<VideoModel> {
       distinct: true,
       offset: start,
       limit: count,
-      order: [ getSort('createdAt'), [ 'Tags', 'name', 'ASC' ] ],
+      order: getSort('createdAt', [ 'Tags', 'name', 'ASC' ]),
       where: {
         id: {
           [Sequelize.Op.in]: Sequelize.literal('(' + rawQuery + ')')
@@ -603,11 +640,11 @@ export class VideoModel extends Model<VideoModel> {
     })
   }
 
-  static listUserVideosForApi (userId: number, start: number, count: number, sort: string) {
-    const query = {
+  static listAccountVideosForApi (accountId: number, start: number, count: number, sort: string, withFiles = false) {
+    const query: IFindOptions<VideoModel> = {
       offset: start,
       limit: count,
-      order: [ getSort(sort) ],
+      order: getSort(sort),
       include: [
         {
           model: VideoChannelModel,
@@ -616,7 +653,7 @@ export class VideoModel extends Model<VideoModel> {
             {
               model: AccountModel,
               where: {
-                userId
+                id: accountId
               },
               required: true
             }
@@ -625,6 +662,13 @@ export class VideoModel extends Model<VideoModel> {
       ]
     }
 
+    if (withFiles === true) {
+      query.include.push({
+        model: VideoFileModel.unscoped(),
+        required: true
+      })
+    }
+
     return VideoModel.findAndCountAll(query).then(({ rows, count }) => {
       return {
         data: rows,
@@ -633,16 +677,16 @@ export class VideoModel extends Model<VideoModel> {
     })
   }
 
-  static async listForApi (start: number, count: number, sort: string) {
+  static async listForApi (start: number, count: number, sort: string, filter?: VideoFilter, withFiles = false) {
     const query = {
       offset: start,
       limit: count,
-      order: [ getSort(sort) ]
+      order: getSort(sort)
     }
 
     const serverActor = await getServerActor()
 
-    return VideoModel.scope({ method: [ ScopeNames.AVAILABLE_FOR_LIST, serverActor.id ] })
+    return VideoModel.scope({ method: [ ScopeNames.AVAILABLE_FOR_LIST, serverActor.id, filter, withFiles ] })
       .findAndCountAll(query)
       .then(({ rows, count }) => {
         return {
@@ -652,22 +696,37 @@ export class VideoModel extends Model<VideoModel> {
       })
   }
 
-  static async searchAndPopulateAccountAndServerAndTags (value: string, start: number, count: number, sort: string) {
+  static async searchAndPopulateAccountAndServer (value: string, start: number, count: number, sort: string) {
     const query: IFindOptions<VideoModel> = {
       offset: start,
       limit: count,
-      order: [ getSort(sort) ],
+      order: getSort(sort),
       where: {
-        name: {
-          [Sequelize.Op.iLike]: '%' + value + '%'
-        }
+        [Sequelize.Op.or]: [
+          {
+            name: {
+              [ Sequelize.Op.iLike ]: '%' + value + '%'
+            }
+          },
+          {
+            preferredUsername: Sequelize.where(Sequelize.col('preferredUsername'), {
+              [ Sequelize.Op.iLike ]: '%' + value + '%'
+            })
+          },
+          {
+            host: Sequelize.where(Sequelize.col('host'), {
+              [ Sequelize.Op.iLike ]: '%' + value + '%'
+            })
+          }
+        ]
       }
     }
 
     const serverActor = await getServerActor()
 
     return VideoModel.scope({ method: [ ScopeNames.AVAILABLE_FOR_LIST, serverActor.id ] })
-      .findAndCountAll(query).then(({ rows, count }) => {
+      .findAndCountAll(query)
+      .then(({ rows, count }) => {
         return {
           data: rows,
           total: count
@@ -761,6 +820,60 @@ export class VideoModel extends Model<VideoModel> {
       .findOne(options)
   }
 
+  static async getStats () {
+    const totalLocalVideos = await VideoModel.count({
+      where: {
+        remote: false
+      }
+    })
+    const totalVideos = await VideoModel.count()
+
+    let totalLocalVideoViews = await VideoModel.sum('views', {
+      where: {
+        remote: false
+      }
+    })
+    // Sequelize could return null...
+    if (!totalLocalVideoViews) totalLocalVideoViews = 0
+
+    return {
+      totalLocalVideos,
+      totalLocalVideoViews,
+      totalVideos
+    }
+  }
+
+  private static buildActorWhereWithFilter (filter?: VideoFilter) {
+    if (filter && filter === 'local') {
+      return {
+        serverId: null
+      }
+    }
+
+    return {}
+  }
+
+  private static getCategoryLabel (id: number) {
+    let categoryLabel = VIDEO_CATEGORIES[id]
+    if (!categoryLabel) categoryLabel = 'Misc'
+
+    return categoryLabel
+  }
+
+  private static getLicenceLabel (id: number) {
+    let licenceLabel = VIDEO_LICENCES[id]
+    if (!licenceLabel) licenceLabel = 'Unknown'
+
+    return licenceLabel
+  }
+
+  private static getLanguageLabel (id: number) {
+    let languageLabel = VIDEO_LANGUAGES[id]
+    if (!languageLabel) languageLabel = 'Unknown'
+
+    return languageLabel
+  }
+
   getOriginalFile () {
     if (Array.isArray(this.VideoFiles) === false) return undefined
 
@@ -793,24 +906,20 @@ export class VideoModel extends Model<VideoModel> {
   }
 
   createPreview (videoFile: VideoFileModel) {
-    const imageSize = PREVIEWS_SIZE.width + 'x' + PREVIEWS_SIZE.height
-
     return generateImageFromVideoFile(
       this.getVideoFilePath(videoFile),
       CONFIG.STORAGE.PREVIEWS_DIR,
       this.getPreviewName(),
-      imageSize
+      PREVIEWS_SIZE
     )
   }
 
   createThumbnail (videoFile: VideoFileModel) {
-    const imageSize = THUMBNAILS_SIZE.width + 'x' + THUMBNAILS_SIZE.height
-
     return generateImageFromVideoFile(
       this.getVideoFilePath(videoFile),
       CONFIG.STORAGE.THUMBNAILS_DIR,
       this.getThumbnailName(),
-      imageSize
+      THUMBNAILS_SIZE
     )
   }
 
@@ -853,30 +962,27 @@ export class VideoModel extends Model<VideoModel> {
   }
 
   toFormattedJSON (): Video {
-    let serverHost
-
-    if (this.VideoChannel.Account.Actor.Server) {
-      serverHost = this.VideoChannel.Account.Actor.Server.host
-    } else {
-      // It means it's our video
-      serverHost = CONFIG.WEBSERVER.HOST
-    }
+    const formattedAccount = this.VideoChannel.Account.toFormattedJSON()
 
     return {
       id: this.id,
       uuid: this.uuid,
       name: this.name,
-      category: this.category,
-      categoryLabel: this.getCategoryLabel(),
-      licence: this.licence,
-      licenceLabel: this.getLicenceLabel(),
-      language: this.language,
-      languageLabel: this.getLanguageLabel(),
+      category: {
+        id: this.category,
+        label: VideoModel.getCategoryLabel(this.category)
+      },
+      licence: {
+        id: this.licence,
+        label: VideoModel.getLicenceLabel(this.licence)
+      },
+      language: {
+        id: this.language,
+        label: VideoModel.getLanguageLabel(this.language)
+      },
       nsfw: this.nsfw,
       description: this.getTruncatedDescription(),
-      serverHost,
       isLocal: this.isOwned(),
-      accountName: this.VideoChannel.Account.name,
       duration: this.duration,
       views: this.views,
       likes: this.likes,
@@ -885,7 +991,15 @@ export class VideoModel extends Model<VideoModel> {
       previewPath: this.getPreviewPath(),
       embedPath: this.getEmbedPath(),
       createdAt: this.createdAt,
-      updatedAt: this.updatedAt
+      updatedAt: this.updatedAt,
+      publishedAt: this.publishedAt,
+      account: {
+        name: formattedAccount.name,
+        displayName: formattedAccount.displayName,
+        url: formattedAccount.url,
+        host: formattedAccount.host,
+        avatar: formattedAccount.avatar
+      }
     }
   }
 
@@ -897,39 +1011,48 @@ export class VideoModel extends Model<VideoModel> {
     if (!privacyLabel) privacyLabel = 'Unknown'
 
     const detailsJson = {
-      privacyLabel,
-      privacy: this.privacy,
+      privacy: {
+        id: this.privacy,
+        label: privacyLabel
+      },
       support: this.support,
       descriptionPath: this.getDescriptionPath(),
       channel: this.VideoChannel.toFormattedJSON(),
       account: this.VideoChannel.Account.toFormattedJSON(),
-      tags: map<TagModel, string>(this.Tags, 'name'),
+      tags: map(this.Tags, 'name'),
       commentsEnabled: this.commentsEnabled,
       files: []
     }
 
     // Format and sort video files
+    detailsJson.files = this.getFormattedVideoFilesJSON()
+
+    return Object.assign(formattedJson, detailsJson)
+  }
+
+  getFormattedVideoFilesJSON (): VideoFile[] {
     const { baseUrlHttp, baseUrlWs } = this.getBaseUrls()
-    detailsJson.files = this.VideoFiles
-      .map(videoFile => {
-        let resolutionLabel = videoFile.resolution + 'p'
 
-        return {
-          resolution: videoFile.resolution,
-          resolutionLabel,
-          magnetUri: this.generateMagnetUri(videoFile, baseUrlHttp, baseUrlWs),
-          size: videoFile.size,
-          torrentUrl: this.getTorrentUrl(videoFile, baseUrlHttp),
-          fileUrl: this.getVideoFileUrl(videoFile, baseUrlHttp)
-        }
-      })
-      .sort((a, b) => {
-        if (a.resolution < b.resolution) return 1
-        if (a.resolution === b.resolution) return 0
-        return -1
-      })
+    return this.VideoFiles
+        .map(videoFile => {
+          let resolutionLabel = videoFile.resolution + 'p'
 
-    return Object.assign(formattedJson, detailsJson)
+          return {
+            resolution: {
+              id: videoFile.resolution,
+              label: resolutionLabel
+            },
+            magnetUri: this.generateMagnetUri(videoFile, baseUrlHttp, baseUrlWs),
+            size: videoFile.size,
+            torrentUrl: this.getTorrentUrl(videoFile, baseUrlHttp),
+            fileUrl: this.getVideoFileUrl(videoFile, baseUrlHttp)
+          } as VideoFile
+        })
+        .sort((a, b) => {
+          if (a.resolution.id < b.resolution.id) return 1
+          if (a.resolution.id === b.resolution.id) return 0
+          return -1
+        })
   }
 
   toActivityPubObject (): VideoTorrentObject {
@@ -945,7 +1068,7 @@ export class VideoModel extends Model<VideoModel> {
     if (this.language) {
       language = {
         identifier: this.language + '',
-        name: this.getLanguageLabel()
+        name: VideoModel.getLanguageLabel(this.language)
       }
     }
 
@@ -953,7 +1076,7 @@ export class VideoModel extends Model<VideoModel> {
     if (this.category) {
       category = {
         identifier: this.category + '',
-        name: this.getCategoryLabel()
+        name: VideoModel.getCategoryLabel(this.category)
       }
     }
 
@@ -961,7 +1084,7 @@ export class VideoModel extends Model<VideoModel> {
     if (this.licence) {
       licence = {
         identifier: this.licence + '',
-        name: this.getLicenceLabel()
+        name: VideoModel.getLicenceLabel(this.licence)
       }
     }
 
@@ -1029,7 +1152,7 @@ export class VideoModel extends Model<VideoModel> {
       views: this.views,
       sensitive: this.nsfw,
       commentsEnabled: this.commentsEnabled,
-      published: this.createdAt.toISOString(),
+      published: this.publishedAt.toISOString(),
       updated: this.updatedAt.toISOString(),
       mediaType: 'text/markdown',
       content: this.getTruncatedDescription(),
@@ -1047,13 +1170,13 @@ export class VideoModel extends Model<VideoModel> {
       shares: sharesObject,
       comments: commentsObject,
       attributedTo: [
-        {
-          type: 'Group',
-          id: this.VideoChannel.Actor.url
-        },
         {
           type: 'Person',
           id: this.VideoChannel.Account.Actor.url
+        },
+        {
+          type: 'Group',
+          id: this.VideoChannel.Actor.url
         }
       ]
     }
@@ -1100,11 +1223,8 @@ export class VideoModel extends Model<VideoModel> {
   getTruncatedDescription () {
     if (!this.description) return null
 
-    const options = {
-      length: CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
-    }
-
-    return truncate(this.description, options)
+    const maxLength = CONSTRAINTS_FIELDS.VIDEOS.TRUNCATED_DESCRIPTION.max
+    return peertubeTruncate(this.description, maxLength)
   }
 
   optimizeOriginalVideofile = async function () {
@@ -1119,10 +1239,10 @@ export class VideoModel extends Model<VideoModel> {
       outputPath: videoOutputPath
     }
 
-    try {
-      // Could be very long!
-      await transcode(transcodeOptions)
+    // Could be very long!
+    await transcode(transcodeOptions)
 
+    try {
       await unlinkPromise(videoInputPath)
 
       // Important to do this before getVideoFilename() to take in account the new file extension
@@ -1138,13 +1258,13 @@ export class VideoModel extends Model<VideoModel> {
 
     } catch (err) {
       // Auto destruction...
-      this.destroy().catch(err => logger.error('Cannot destruct video after transcoding failure.', err))
+      this.destroy().catch(err => logger.error('Cannot destruct video after transcoding failure.', { err }))
 
       throw err
     }
   }
 
-  transcodeOriginalVideofile = async function (resolution: VideoResolution) {
+  transcodeOriginalVideofile = async function (resolution: VideoResolution, isPortraitMode: boolean) {
     const videosDirectory = CONFIG.STORAGE.VIDEOS_DIR
     const extname = '.mp4'
 
@@ -1162,7 +1282,8 @@ export class VideoModel extends Model<VideoModel> {
     const transcodeOptions = {
       inputPath: videoInputPath,
       outputPath: videoOutputPath,
-      resolution
+      resolution,
+      isPortraitMode
     }
 
     await transcode(transcodeOptions)
@@ -1178,37 +1299,16 @@ export class VideoModel extends Model<VideoModel> {
     this.VideoFiles.push(newVideoFile)
   }
 
-  getOriginalFileHeight () {
+  getOriginalFileResolution () {
     const originalFilePath = this.getVideoFilePath(this.getOriginalFile())
 
-    return getVideoFileHeight(originalFilePath)
+    return getVideoFileResolution(originalFilePath)
   }
 
   getDescriptionPath () {
     return `/api/${API_VERSION}/videos/${this.uuid}/description`
   }
 
-  getCategoryLabel () {
-    let categoryLabel = VIDEO_CATEGORIES[this.category]
-    if (!categoryLabel) categoryLabel = 'Misc'
-
-    return categoryLabel
-  }
-
-  getLicenceLabel () {
-    let licenceLabel = VIDEO_LICENCES[this.licence]
-    if (!licenceLabel) licenceLabel = 'Unknown'
-
-    return licenceLabel
-  }
-
-  getLanguageLabel () {
-    let languageLabel = VIDEO_LANGUAGES[this.language]
-    if (!languageLabel) languageLabel = 'Unknown'
-
-    return languageLabel
-  }
-
   removeThumbnail () {
     const thumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
     return unlinkPromise(thumbnailPath)