Stricter models typing

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

diff --git a/server/models/video/video-playlist-element.ts b/server/models/video/video-playlist-element.ts
index bed6f8eafd6446ebe271fc06d86c73923262e52e..e6906cb19202c6b70b59c8386a86ae8d8e39adc5 100644 (file)
--- a/server/models/video/video-playlist-element.ts
+++ b/server/models/video/video-playlist-element.ts
@@ -1,3 +1,4 @@
+import { AggregateOptions, Op, ScopeOptions, Sequelize, Transaction } from 'sequelize'
 import {
   AllowNull,
   BelongsTo,
@@ -13,18 +14,25 @@ import {
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { ForAPIOptions, ScopeNames as VideoScopeNames, VideoModel } from './video'
-import { VideoPlaylistModel } from './video-playlist'
-import { getSort, throwIfNotValid } from '../utils'
-import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
-import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
+import validator from 'validator'
+import { MUserAccountId } from '@server/types/models'
+import {
+  MVideoPlaylistElement,
+  MVideoPlaylistElementAP,
+  MVideoPlaylistElementFormattable,
+  MVideoPlaylistElementVideoUrlPlaylistPrivacy,
+  MVideoPlaylistVideoThumbnail
+} from '@server/types/models/video/video-playlist-element'
 import { PlaylistElementObject } from '../../../shared/models/activitypub/objects/playlist-element-object'
-import * as validator from 'validator'
-import { AggregateOptions, Op, ScopeOptions, Sequelize, Transaction } from 'sequelize'
-import { UserModel } from '../account/user'
+import { VideoPrivacy } from '../../../shared/models/videos'
 import { VideoPlaylistElement, VideoPlaylistElementType } from '../../../shared/models/videos/playlist/video-playlist-element.model'
+import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { AccountModel } from '../account/account'
-import { VideoPrivacy } from '../../../shared/models/videos'
+import { getSort, throwIfNotValid } from '../utils'
+import { ForAPIOptions, ScopeNames as VideoScopeNames, VideoModel } from './video'
+import { VideoPlaylistModel } from './video-playlist'
+import { AttributesOnly } from '@shared/core-utils'
 
 @Table({
   tableName: 'videoPlaylistElement',
@@ -35,25 +43,21 @@ import { VideoPrivacy } from '../../../shared/models/videos'
     {
       fields: [ 'videoId' ]
     },
-    {
-      fields: [ 'videoPlaylistId', 'videoId' ],
-      unique: true
-    },
     {
       fields: [ 'url' ],
       unique: true
     }
   ]
 })
-export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel> {
+export class VideoPlaylistElementModel extends Model<Partial<AttributesOnly<VideoPlaylistElementModel>>> {
   @CreatedAt
   createdAt: Date
 
   @UpdatedAt
   updatedAt: Date
 
-  @AllowNull(false)
-  @Is('VideoPlaylistUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
+  @AllowNull(true)
+  @Is('VideoPlaylistUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS.URL.max))
   url: string
 
@@ -112,11 +116,11 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
   }
 
   static listForApi (options: {
-    start: number,
-    count: number,
-    videoPlaylistId: number,
-    serverAccount: AccountModel,
-    user?: UserModel
+    start: number
+    count: number
+    videoPlaylistId: number
+    serverAccount: AccountModel
+    user?: MUserAccountId
   }) {
     const accountIds = [ options.serverAccount.id ]
     const videoScope: (ScopeOptions | string)[] = [
@@ -162,7 +166,7 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
     ]).then(([ total, data ]) => ({ total, data }))
   }
 
-  static loadByPlaylistAndVideo (videoPlaylistId: number, videoId: number) {
+  static loadByPlaylistAndVideo (videoPlaylistId: number, videoId: number): Promise<MVideoPlaylistElement> {
     const query = {
       where: {
         videoPlaylistId,
@@ -173,13 +177,15 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
     return VideoPlaylistElementModel.findOne(query)
   }
 
-  static loadById (playlistElementId: number) {
+  static loadById (playlistElementId: number | string): Promise<MVideoPlaylistElement> {
     return VideoPlaylistElementModel.findByPk(playlistElementId)
   }
 
-  static loadByPlaylistAndVideoForAP (playlistId: number | string, videoId: number | string) {
+  static loadByPlaylistAndElementIdForAP (
+    playlistId: number | string,
+    playlistElementId: number
+  ): Promise<MVideoPlaylistElementVideoUrlPlaylistPrivacy> {
     const playlistWhere = validator.isUUID('' + playlistId) ? { uuid: playlistId } : { id: playlistId }
-    const videoWhere = validator.isUUID('' + videoId) ? { uuid: videoId } : { id: videoId }
 
     const query = {
       include: [
@@ -190,10 +196,12 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
         },
         {
           attributes: [ 'url' ],
-          model: VideoModel.unscoped(),
-          where: videoWhere
+          model: VideoModel.unscoped()
         }
-      ]
+      ],
+      where: {
+        id: playlistElementId
+      }
     }
 
     return VideoPlaylistElementModel.findOne(query)
@@ -218,6 +226,24 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
       })
   }
 
+  static loadFirstElementWithVideoThumbnail (videoPlaylistId: number): Promise<MVideoPlaylistVideoThumbnail> {
+    const query = {
+      order: getSort('position'),
+      where: {
+        videoPlaylistId
+      },
+      include: [
+        {
+          model: VideoModel.scope(VideoScopeNames.WITH_THUMBNAILS),
+          required: true
+        }
+      ]
+    }
+
+    return VideoPlaylistElementModel
+      .findOne(query)
+  }
+
   static getNextPositionOf (videoPlaylistId: number, transaction?: Transaction) {
     const query: AggregateOptions<number> = {
       where: {
@@ -249,7 +275,8 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
       validate: false // We use a literal to update the position
     }
 
-    return VideoPlaylistElementModel.update({ position: Sequelize.literal(`${newPosition} + "position" - ${firstPosition}`) }, query)
+    const positionQuery = Sequelize.literal(`${newPosition} + "position" - ${firstPosition}`)
+    return VideoPlaylistElementModel.update({ position: positionQuery as any }, query)
   }
 
   static increasePositionOf (
@@ -272,7 +299,7 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
     return VideoPlaylistElementModel.increment({ position: by }, query)
   }
 
-  getType (displayNSFW?: boolean, accountId?: number) {
+  getType (this: MVideoPlaylistElementFormattable, displayNSFW?: boolean, accountId?: number) {
     const video = this.Video
 
     if (!video) return VideoPlaylistElementType.DELETED
@@ -280,7 +307,10 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
     // Owned video, don't filter it
     if (accountId && video.VideoChannel.Account.id === accountId) return VideoPlaylistElementType.REGULAR
 
-    if (video.privacy === VideoPrivacy.PRIVATE) return VideoPlaylistElementType.PRIVATE
+    // Internal video?
+    if (video.privacy === VideoPrivacy.INTERNAL && accountId) return VideoPlaylistElementType.REGULAR
+
+    if (video.privacy === VideoPrivacy.PRIVATE || video.privacy === VideoPrivacy.INTERNAL) return VideoPlaylistElementType.PRIVATE
 
     if (video.isBlacklisted() || video.isBlocked()) return VideoPlaylistElementType.UNAVAILABLE
     if (video.nsfw === true && displayNSFW === false) return VideoPlaylistElementType.UNAVAILABLE
@@ -288,14 +318,17 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
     return VideoPlaylistElementType.REGULAR
   }
 
-  getVideoElement (displayNSFW?: boolean, accountId?: number) {
+  getVideoElement (this: MVideoPlaylistElementFormattable, displayNSFW?: boolean, accountId?: number) {
     if (!this.Video) return null
     if (this.getType(displayNSFW, accountId) !== VideoPlaylistElementType.REGULAR) return null
 
     return this.Video.toFormattedJSON()
   }
 
-  toFormattedJSON (options: { displayNSFW?: boolean, accountId?: number } = {}): VideoPlaylistElement {
+  toFormattedJSON (
+    this: MVideoPlaylistElementFormattable,
+    options: { displayNSFW?: boolean, accountId?: number } = {}
+  ): VideoPlaylistElement {
     return {
       id: this.id,
       position: this.position,
@@ -308,7 +341,7 @@ export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel>
     }
   }
 
-  toActivityPubObject (): PlaylistElementObject {
+  toActivityPubObject (this: MVideoPlaylistElementAP): PlaylistElementObject {
     const base: PlaylistElementObject = {
       id: this.url,
       type: 'PlaylistElement',