]> git.immae.eu Git - github/Chocobozzz/PeerTube.git/blob - server/models/video/video-playlist.ts
Merge branch 'release/2.1.0' into develop
[github/Chocobozzz/PeerTube.git] / server / models / video / video-playlist.ts
1 import {
2 AllowNull,
3 BelongsTo,
4 Column,
5 CreatedAt,
6 DataType,
7 Default,
8 ForeignKey,
9 HasMany,
10 HasOne,
11 Is,
12 IsUUID,
13 Model,
14 Scopes,
15 Table,
16 UpdatedAt
17 } from 'sequelize-typescript'
18 import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
19 import { buildServerIdsFollowedBy, buildWhereIdOrUUID, getSort, isOutdated, throwIfNotValid } from '../utils'
20 import {
21 isVideoPlaylistDescriptionValid,
22 isVideoPlaylistNameValid,
23 isVideoPlaylistPrivacyValid
24 } from '../../helpers/custom-validators/video-playlists'
25 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
26 import {
27 ACTIVITY_PUB,
28 CONSTRAINTS_FIELDS,
29 STATIC_PATHS,
30 THUMBNAILS_SIZE,
31 VIDEO_PLAYLIST_PRIVACIES,
32 VIDEO_PLAYLIST_TYPES,
33 WEBSERVER
34 } from '../../initializers/constants'
35 import { VideoPlaylist } from '../../../shared/models/videos/playlist/video-playlist.model'
36 import { AccountModel, ScopeNames as AccountScopeNames, SummaryOptions } from '../account/account'
37 import { ScopeNames as VideoChannelScopeNames, VideoChannelModel } from './video-channel'
38 import { join } from 'path'
39 import { VideoPlaylistElementModel } from './video-playlist-element'
40 import { PlaylistObject } from '../../../shared/models/activitypub/objects/playlist-object'
41 import { activityPubCollectionPagination } from '../../helpers/activitypub'
42 import { VideoPlaylistType } from '../../../shared/models/videos/playlist/video-playlist-type.model'
43 import { ThumbnailModel } from './thumbnail'
44 import { ActivityIconObject } from '../../../shared/models/activitypub/objects'
45 import { FindOptions, literal, Op, ScopeOptions, Transaction, WhereOptions } from 'sequelize'
46 import * as Bluebird from 'bluebird'
47 import {
48 MVideoPlaylistAccountThumbnail,
49 MVideoPlaylistAP,
50 MVideoPlaylistFormattable,
51 MVideoPlaylistFull,
52 MVideoPlaylistFullSummary,
53 MVideoPlaylistIdWithElements
54 } from '../../typings/models/video/video-playlist'
55 import { MThumbnail } from '../../typings/models/video/thumbnail'
56
57 enum ScopeNames {
58 AVAILABLE_FOR_LIST = 'AVAILABLE_FOR_LIST',
59 WITH_VIDEOS_LENGTH = 'WITH_VIDEOS_LENGTH',
60 WITH_ACCOUNT_AND_CHANNEL_SUMMARY = 'WITH_ACCOUNT_AND_CHANNEL_SUMMARY',
61 WITH_ACCOUNT = 'WITH_ACCOUNT',
62 WITH_THUMBNAIL = 'WITH_THUMBNAIL',
63 WITH_ACCOUNT_AND_CHANNEL = 'WITH_ACCOUNT_AND_CHANNEL'
64 }
65
66 type AvailableForListOptions = {
67 followerActorId: number
68 type?: VideoPlaylistType
69 accountId?: number
70 videoChannelId?: number
71 listMyPlaylists?: boolean
72 search?: string
73 }
74
75 @Scopes(() => ({
76 [ScopeNames.WITH_THUMBNAIL]: {
77 include: [
78 {
79 model: ThumbnailModel,
80 required: false
81 }
82 ]
83 },
84 [ScopeNames.WITH_VIDEOS_LENGTH]: {
85 attributes: {
86 include: [
87 [
88 literal('(SELECT COUNT("id") FROM "videoPlaylistElement" WHERE "videoPlaylistId" = "VideoPlaylistModel"."id")'),
89 'videosLength'
90 ]
91 ]
92 }
93 } as FindOptions,
94 [ScopeNames.WITH_ACCOUNT]: {
95 include: [
96 {
97 model: AccountModel,
98 required: true
99 }
100 ]
101 },
102 [ScopeNames.WITH_ACCOUNT_AND_CHANNEL_SUMMARY]: {
103 include: [
104 {
105 model: AccountModel.scope(AccountScopeNames.SUMMARY),
106 required: true
107 },
108 {
109 model: VideoChannelModel.scope(VideoChannelScopeNames.SUMMARY),
110 required: false
111 }
112 ]
113 },
114 [ScopeNames.WITH_ACCOUNT_AND_CHANNEL]: {
115 include: [
116 {
117 model: AccountModel,
118 required: true
119 },
120 {
121 model: VideoChannelModel,
122 required: false
123 }
124 ]
125 },
126 [ScopeNames.AVAILABLE_FOR_LIST]: (options: AvailableForListOptions) => {
127
128 let whereActor: WhereOptions = {}
129
130 const whereAnd: WhereOptions[] = []
131
132 if (options.listMyPlaylists !== true) {
133 whereAnd.push({
134 privacy: VideoPlaylistPrivacy.PUBLIC
135 })
136
137 // Only list local playlists OR playlists that are on an instance followed by actorId
138 const inQueryInstanceFollow = buildServerIdsFollowedBy(options.followerActorId)
139
140 whereActor = {
141 [Op.or]: [
142 {
143 serverId: null
144 },
145 {
146 serverId: {
147 [Op.in]: literal(inQueryInstanceFollow)
148 }
149 }
150 ]
151 }
152 }
153
154 if (options.accountId) {
155 whereAnd.push({
156 ownerAccountId: options.accountId
157 })
158 }
159
160 if (options.videoChannelId) {
161 whereAnd.push({
162 videoChannelId: options.videoChannelId
163 })
164 }
165
166 if (options.type) {
167 whereAnd.push({
168 type: options.type
169 })
170 }
171
172 if (options.search) {
173 whereAnd.push({
174 name: {
175 [Op.iLike]: '%' + options.search + '%'
176 }
177 })
178 }
179
180 const where = {
181 [Op.and]: whereAnd
182 }
183
184 const accountScope = {
185 method: [ AccountScopeNames.SUMMARY, { whereActor } as SummaryOptions ]
186 }
187
188 return {
189 where,
190 include: [
191 {
192 model: AccountModel.scope(accountScope),
193 required: true
194 },
195 {
196 model: VideoChannelModel.scope(VideoChannelScopeNames.SUMMARY),
197 required: false
198 }
199 ]
200 } as FindOptions
201 }
202 }))
203
204 @Table({
205 tableName: 'videoPlaylist',
206 indexes: [
207 {
208 fields: [ 'ownerAccountId' ]
209 },
210 {
211 fields: [ 'videoChannelId' ]
212 },
213 {
214 fields: [ 'url' ],
215 unique: true
216 }
217 ]
218 })
219 export class VideoPlaylistModel extends Model<VideoPlaylistModel> {
220 @CreatedAt
221 createdAt: Date
222
223 @UpdatedAt
224 updatedAt: Date
225
226 @AllowNull(false)
227 @Is('VideoPlaylistName', value => throwIfNotValid(value, isVideoPlaylistNameValid, 'name'))
228 @Column
229 name: string
230
231 @AllowNull(true)
232 @Is('VideoPlaylistDescription', value => throwIfNotValid(value, isVideoPlaylistDescriptionValid, 'description', true))
233 @Column
234 description: string
235
236 @AllowNull(false)
237 @Is('VideoPlaylistPrivacy', value => throwIfNotValid(value, isVideoPlaylistPrivacyValid, 'privacy'))
238 @Column
239 privacy: VideoPlaylistPrivacy
240
241 @AllowNull(false)
242 @Is('VideoPlaylistUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
243 @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS.URL.max))
244 url: string
245
246 @AllowNull(false)
247 @Default(DataType.UUIDV4)
248 @IsUUID(4)
249 @Column(DataType.UUID)
250 uuid: string
251
252 @AllowNull(false)
253 @Default(VideoPlaylistType.REGULAR)
254 @Column
255 type: VideoPlaylistType
256
257 @ForeignKey(() => AccountModel)
258 @Column
259 ownerAccountId: number
260
261 @BelongsTo(() => AccountModel, {
262 foreignKey: {
263 allowNull: false
264 },
265 onDelete: 'CASCADE'
266 })
267 OwnerAccount: AccountModel
268
269 @ForeignKey(() => VideoChannelModel)
270 @Column
271 videoChannelId: number
272
273 @BelongsTo(() => VideoChannelModel, {
274 foreignKey: {
275 allowNull: true
276 },
277 onDelete: 'CASCADE'
278 })
279 VideoChannel: VideoChannelModel
280
281 @HasMany(() => VideoPlaylistElementModel, {
282 foreignKey: {
283 name: 'videoPlaylistId',
284 allowNull: false
285 },
286 onDelete: 'CASCADE'
287 })
288 VideoPlaylistElements: VideoPlaylistElementModel[]
289
290 @HasOne(() => ThumbnailModel, {
291 foreignKey: {
292 name: 'videoPlaylistId',
293 allowNull: true
294 },
295 onDelete: 'CASCADE',
296 hooks: true
297 })
298 Thumbnail: ThumbnailModel
299
300 static listForApi (options: {
301 followerActorId: number
302 start: number
303 count: number
304 sort: string
305 type?: VideoPlaylistType
306 accountId?: number
307 videoChannelId?: number
308 listMyPlaylists?: boolean
309 search?: string
310 }) {
311 const query = {
312 offset: options.start,
313 limit: options.count,
314 order: getSort(options.sort)
315 }
316
317 const scopes: (string | ScopeOptions)[] = [
318 {
319 method: [
320 ScopeNames.AVAILABLE_FOR_LIST,
321 {
322 type: options.type,
323 followerActorId: options.followerActorId,
324 accountId: options.accountId,
325 videoChannelId: options.videoChannelId,
326 listMyPlaylists: options.listMyPlaylists,
327 search: options.search
328 } as AvailableForListOptions
329 ]
330 },
331 ScopeNames.WITH_VIDEOS_LENGTH,
332 ScopeNames.WITH_THUMBNAIL
333 ]
334
335 return VideoPlaylistModel
336 .scope(scopes)
337 .findAndCountAll(query)
338 .then(({ rows, count }) => {
339 return { total: count, data: rows }
340 })
341 }
342
343 static listPublicUrlsOfForAP (accountId: number, start: number, count: number) {
344 const query = {
345 attributes: [ 'url' ],
346 offset: start,
347 limit: count,
348 where: {
349 ownerAccountId: accountId,
350 privacy: VideoPlaylistPrivacy.PUBLIC
351 }
352 }
353
354 return VideoPlaylistModel.findAndCountAll(query)
355 .then(({ rows, count }) => {
356 return { total: count, data: rows.map(p => p.url) }
357 })
358 }
359
360 static listPlaylistIdsOf (accountId: number, videoIds: number[]): Bluebird<MVideoPlaylistIdWithElements[]> {
361 const query = {
362 attributes: [ 'id' ],
363 where: {
364 ownerAccountId: accountId
365 },
366 include: [
367 {
368 attributes: [ 'id', 'videoId', 'startTimestamp', 'stopTimestamp' ],
369 model: VideoPlaylistElementModel.unscoped(),
370 where: {
371 videoId: {
372 [Op.in]: videoIds
373 }
374 },
375 required: true
376 }
377 ]
378 }
379
380 return VideoPlaylistModel.findAll(query)
381 }
382
383 static doesPlaylistExist (url: string) {
384 const query = {
385 attributes: [],
386 where: {
387 url
388 }
389 }
390
391 return VideoPlaylistModel
392 .findOne(query)
393 .then(e => !!e)
394 }
395
396 static loadWithAccountAndChannelSummary (id: number | string, transaction: Transaction): Bluebird<MVideoPlaylistFullSummary> {
397 const where = buildWhereIdOrUUID(id)
398
399 const query = {
400 where,
401 transaction
402 }
403
404 return VideoPlaylistModel
405 .scope([ ScopeNames.WITH_ACCOUNT_AND_CHANNEL_SUMMARY, ScopeNames.WITH_VIDEOS_LENGTH, ScopeNames.WITH_THUMBNAIL ])
406 .findOne(query)
407 }
408
409 static loadWithAccountAndChannel (id: number | string, transaction: Transaction): Bluebird<MVideoPlaylistFull> {
410 const where = buildWhereIdOrUUID(id)
411
412 const query = {
413 where,
414 transaction
415 }
416
417 return VideoPlaylistModel
418 .scope([ ScopeNames.WITH_ACCOUNT_AND_CHANNEL, ScopeNames.WITH_VIDEOS_LENGTH, ScopeNames.WITH_THUMBNAIL ])
419 .findOne(query)
420 }
421
422 static loadByUrlAndPopulateAccount (url: string): Bluebird<MVideoPlaylistAccountThumbnail> {
423 const query = {
424 where: {
425 url
426 }
427 }
428
429 return VideoPlaylistModel.scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_THUMBNAIL ]).findOne(query)
430 }
431
432 static getPrivacyLabel (privacy: VideoPlaylistPrivacy) {
433 return VIDEO_PLAYLIST_PRIVACIES[privacy] || 'Unknown'
434 }
435
436 static getTypeLabel (type: VideoPlaylistType) {
437 return VIDEO_PLAYLIST_TYPES[type] || 'Unknown'
438 }
439
440 static resetPlaylistsOfChannel (videoChannelId: number, transaction: Transaction) {
441 const query = {
442 where: {
443 videoChannelId
444 },
445 transaction
446 }
447
448 return VideoPlaylistModel.update({ privacy: VideoPlaylistPrivacy.PRIVATE, videoChannelId: null }, query)
449 }
450
451 async setAndSaveThumbnail (thumbnail: MThumbnail, t: Transaction) {
452 thumbnail.videoPlaylistId = this.id
453
454 this.Thumbnail = await thumbnail.save({ transaction: t })
455 }
456
457 hasThumbnail () {
458 return !!this.Thumbnail
459 }
460
461 hasGeneratedThumbnail () {
462 return this.hasThumbnail() && this.Thumbnail.automaticallyGenerated === true
463 }
464
465 generateThumbnailName () {
466 const extension = '.jpg'
467
468 return 'playlist-' + this.uuid + extension
469 }
470
471 getThumbnailUrl () {
472 if (!this.hasThumbnail()) return null
473
474 return WEBSERVER.URL + STATIC_PATHS.THUMBNAILS + this.Thumbnail.filename
475 }
476
477 getThumbnailStaticPath () {
478 if (!this.hasThumbnail()) return null
479
480 return join(STATIC_PATHS.THUMBNAILS, this.Thumbnail.filename)
481 }
482
483 setAsRefreshed () {
484 this.changed('updatedAt', true)
485
486 return this.save()
487 }
488
489 isOwned () {
490 return this.OwnerAccount.isOwned()
491 }
492
493 isOutdated () {
494 if (this.isOwned()) return false
495
496 return isOutdated(this, ACTIVITY_PUB.VIDEO_PLAYLIST_REFRESH_INTERVAL)
497 }
498
499 toFormattedJSON (this: MVideoPlaylistFormattable): VideoPlaylist {
500 return {
501 id: this.id,
502 uuid: this.uuid,
503 isLocal: this.isOwned(),
504
505 displayName: this.name,
506 description: this.description,
507 privacy: {
508 id: this.privacy,
509 label: VideoPlaylistModel.getPrivacyLabel(this.privacy)
510 },
511
512 thumbnailPath: this.getThumbnailStaticPath(),
513
514 type: {
515 id: this.type,
516 label: VideoPlaylistModel.getTypeLabel(this.type)
517 },
518
519 videosLength: this.get('videosLength') as number,
520
521 createdAt: this.createdAt,
522 updatedAt: this.updatedAt,
523
524 ownerAccount: this.OwnerAccount.toFormattedSummaryJSON(),
525 videoChannel: this.VideoChannel ? this.VideoChannel.toFormattedSummaryJSON() : null
526 }
527 }
528
529 toActivityPubObject (this: MVideoPlaylistAP, page: number, t: Transaction): Promise<PlaylistObject> {
530 const handler = (start: number, count: number) => {
531 return VideoPlaylistElementModel.listUrlsOfForAP(this.id, start, count, t)
532 }
533
534 let icon: ActivityIconObject
535 if (this.hasThumbnail()) {
536 icon = {
537 type: 'Image' as 'Image',
538 url: this.getThumbnailUrl(),
539 mediaType: 'image/jpeg' as 'image/jpeg',
540 width: THUMBNAILS_SIZE.width,
541 height: THUMBNAILS_SIZE.height
542 }
543 }
544
545 return activityPubCollectionPagination(this.url, handler, page)
546 .then(o => {
547 return Object.assign(o, {
548 type: 'Playlist' as 'Playlist',
549 name: this.name,
550 content: this.description,
551 uuid: this.uuid,
552 published: this.createdAt.toISOString(),
553 updated: this.updatedAt.toISOString(),
554 attributedTo: this.VideoChannel ? [ this.VideoChannel.Actor.url ] : [],
555 icon
556 })
557 })
558 }
559 }