Add internal privacy mode

[github/Chocobozzz/PeerTube.git] / server / models / video / video.ts

diff --git a/server/models/video/video.ts b/server/models/video/video.ts
index f84a90992498853e3c4ac2da6bd967bb7ba13468..7e18af497fce86694d34fad5aa999ad2e68e6b8d 100644 (file)
--- a/server/models/video/video.ts
+++ b/server/models/video/video.ts
@@ -1,5 +1,5 @@
 import * as Bluebird from 'bluebird'
-import { maxBy } from 'lodash'
+import { maxBy, minBy } from 'lodash'
 import { join } from 'path'
 import {
   CountOptions,
@@ -59,8 +59,6 @@ import {
   ACTIVITY_PUB,
   API_VERSION,
   CONSTRAINTS_FIELDS,
-  HLS_REDUNDANCY_DIRECTORY,
-  HLS_STREAMING_PLAYLIST_DIRECTORY,
   LAZY_STATIC_PATHS,
   REMOTE_SCHEME,
   STATIC_DOWNLOAD_PATHS,
@@ -143,7 +141,8 @@ import {
 import { MVideoFile, MVideoFileStreamingPlaylistVideo } from '../../typings/models/video/video-file'
 import { MThumbnail } from '../../typings/models/video/thumbnail'
 import { VideoFile } from '@shared/models/videos/video-file.model'
-import { getTorrentFileName, getTorrentFilePath, getVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
+import { getHLSDirectory, getTorrentFileName, getTorrentFilePath, getVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
+import * as validator from 'validator'
 
 // FIXME: Define indexes here because there is an issue with TS and Sequelize.literal when called directly in the annotation
 const indexes: (ModelIndexesOptions & { where?: WhereOptions })[] = [
@@ -349,9 +348,8 @@ export type AvailableForListIDsOptions = {
 
     // Only list public/published videos
     if (!options.filter || options.filter !== 'all-local') {
-      const privacyWhere = {
-        // Always list public videos
-        privacy: VideoPrivacy.PUBLIC,
+
+      const publishWhere = {
         // Always list published videos, or videos that are being transcoded but on which we don't want to wait for transcoding
         [ Op.or ]: [
           {
@@ -365,8 +363,26 @@ export type AvailableForListIDsOptions = {
           }
         ]
       }
+      whereAnd.push(publishWhere)
+
+      // List internal videos if the user is logged in
+      if (options.user) {
+        const privacyWhere = {
+          [Op.or]: [
+            {
+              privacy: VideoPrivacy.INTERNAL
+            },
+            {
+              privacy: VideoPrivacy.PUBLIC
+            }
+          ]
+        }
 
-      whereAnd.push(privacyWhere)
+        whereAnd.push(privacyWhere)
+      } else { // Or only public videos
+        const privacyWhere = { privacy: VideoPrivacy.PUBLIC }
+        whereAnd.push(privacyWhere)
+      }
     }
 
     if (options.videoPlaylistId) {
@@ -1352,24 +1368,35 @@ export class VideoModel extends Model<VideoModel> {
     const escapedSearch = VideoModel.sequelize.escape(options.search)
     const escapedLikeSearch = VideoModel.sequelize.escape('%' + options.search + '%')
     if (options.search) {
-      whereAnd.push(
-        {
-          id: {
-            [ Op.in ]: Sequelize.literal(
-              '(' +
-              'SELECT "video"."id" FROM "video" ' +
-              'WHERE ' +
-              'lower(immutable_unaccent("video"."name")) % lower(immutable_unaccent(' + escapedSearch + ')) OR ' +
-              'lower(immutable_unaccent("video"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))' +
-              'UNION ALL ' +
-              'SELECT "video"."id" FROM "video" LEFT JOIN "videoTag" ON "videoTag"."videoId" = "video"."id" ' +
-              'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
-              'WHERE "tag"."name" = ' + escapedSearch +
-              ')'
-            )
-          }
+      const trigramSearch = {
+        id: {
+          [ Op.in ]: Sequelize.literal(
+            '(' +
+            'SELECT "video"."id" FROM "video" ' +
+            'WHERE ' +
+            'lower(immutable_unaccent("video"."name")) % lower(immutable_unaccent(' + escapedSearch + ')) OR ' +
+            'lower(immutable_unaccent("video"."name")) LIKE lower(immutable_unaccent(' + escapedLikeSearch + '))' +
+            'UNION ALL ' +
+            'SELECT "video"."id" FROM "video" LEFT JOIN "videoTag" ON "videoTag"."videoId" = "video"."id" ' +
+            'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
+            'WHERE "tag"."name" = ' + escapedSearch +
+            ')'
+          )
         }
-      )
+      }
+
+      if (validator.isUUID(options.search)) {
+        whereAnd.push({
+          [Op.or]: [
+            trigramSearch,
+            {
+              uuid: options.search
+            }
+          ]
+        })
+      } else {
+        whereAnd.push(trigramSearch)
+      }
 
       attributesInclude.push(createSimilarityAttribute('VideoModel.name', options.search))
     }
@@ -1763,6 +1790,10 @@ export class VideoModel extends Model<VideoModel> {
     }
   }
 
+  private static isPrivacyForFederation (privacy: VideoPrivacy) {
+    return privacy === VideoPrivacy.PUBLIC || privacy === VideoPrivacy.UNLISTED
+  }
+
   static getCategoryLabel (id: number) {
     return VIDEO_CATEGORIES[ id ] || 'Misc'
   }
@@ -1792,9 +1823,9 @@ export class VideoModel extends Model<VideoModel> {
       this.VideoChannel.Account.isBlocked()
   }
 
-  getMaxQualityFile <T extends MVideoWithFile> (this: T): MVideoFileVideo | MVideoFileStreamingPlaylistVideo {
+  getQualityFileBy <T extends MVideoWithFile> (this: T, fun: (files: MVideoFile[], it: (file: MVideoFile) => number) => MVideoFile) {
     if (Array.isArray(this.VideoFiles) && this.VideoFiles.length !== 0) {
-      const file = maxBy(this.VideoFiles, file => file.resolution)
+      const file = fun(this.VideoFiles, file => file.resolution)
 
       return Object.assign(file, { Video: this })
     }
@@ -1803,13 +1834,21 @@ export class VideoModel extends Model<VideoModel> {
     if (Array.isArray(this.VideoStreamingPlaylists) && this.VideoStreamingPlaylists.length !== 0) {
       const streamingPlaylistWithVideo = Object.assign(this.VideoStreamingPlaylists[0], { Video: this })
 
-      const file = maxBy(streamingPlaylistWithVideo.VideoFiles, file => file.resolution)
+      const file = fun(streamingPlaylistWithVideo.VideoFiles, file => file.resolution)
       return Object.assign(file, { VideoStreamingPlaylist: streamingPlaylistWithVideo })
     }
 
     return undefined
   }
 
+  getMaxQualityFile <T extends MVideoWithFile> (this: T): MVideoFileVideo | MVideoFileStreamingPlaylistVideo {
+    return this.getQualityFileBy(maxBy)
+  }
+
+  getMinQualityFile <T extends MVideoWithFile> (this: T): MVideoFileVideo | MVideoFileStreamingPlaylistVideo {
+    return this.getQualityFileBy(minBy)
+  }
+
   getWebTorrentFile <T extends MVideoWithFile> (this: T, resolution: number): MVideoFileVideo {
     if (Array.isArray(this.VideoFiles) === false) return undefined
 
@@ -1950,11 +1989,10 @@ export class VideoModel extends Model<VideoModel> {
   }
 
   removeStreamingPlaylist (isRedundancy = false) {
-    const baseDir = isRedundancy ? HLS_REDUNDANCY_DIRECTORY : HLS_STREAMING_PLAYLIST_DIRECTORY
+    const directoryPath = getHLSDirectory(this, isRedundancy)
 
-    const filePath = join(baseDir, this.uuid)
-    return remove(filePath)
-      .catch(err => logger.warn('Cannot delete playlist directory %s.', filePath, { err }))
+    return remove(directoryPath)
+      .catch(err => logger.warn('Cannot delete playlist directory %s.', directoryPath, { err }))
   }
 
   isOutdated () {
@@ -1963,12 +2001,38 @@ export class VideoModel extends Model<VideoModel> {
     return isOutdated(this, ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL)
   }
 
+  hasPrivacyForFederation () {
+    return VideoModel.isPrivacyForFederation(this.privacy)
+  }
+
+  isNewVideo (newPrivacy: VideoPrivacy) {
+    return this.hasPrivacyForFederation() === false && VideoModel.isPrivacyForFederation(newPrivacy) === true
+  }
+
   setAsRefreshed () {
     this.changed('updatedAt', true)
 
     return this.save()
   }
 
+  requiresAuth () {
+    return this.privacy === VideoPrivacy.PRIVATE || this.privacy === VideoPrivacy.INTERNAL || !!this.VideoBlacklist
+  }
+
+  setPrivacy (newPrivacy: VideoPrivacy) {
+    if (this.privacy === VideoPrivacy.PRIVATE && newPrivacy !== VideoPrivacy.PRIVATE) {
+      this.publishedAt = new Date()
+    }
+
+    this.privacy = newPrivacy
+  }
+
+  isConfidential () {
+    return this.privacy === VideoPrivacy.PRIVATE ||
+      this.privacy === VideoPrivacy.UNLISTED ||
+      this.privacy === VideoPrivacy.INTERNAL
+  }
+
   async publishIfNeededAndSave (t: Transaction) {
     if (this.state !== VideoState.PUBLISHED) {
       this.state = VideoState.PUBLISHED