+import { map } from 'bluebird'
import { isArray } from '@server/helpers/custom-validators/misc'
import { logger, loggerTagsFactory } from '@server/helpers/logger'
import { CRAWL_REQUEST_CONCURRENCY } from '@server/initializers/constants'
import { sequelizeTypescript } from '@server/initializers/database'
-import { createPlaylistMiniatureFromUrl } from '@server/lib/thumbnail'
+import { updatePlaylistMiniatureFromUrl } from '@server/lib/thumbnail'
import { VideoPlaylistModel } from '@server/models/video/video-playlist'
import { VideoPlaylistElementModel } from '@server/models/video/video-playlist-element'
import { FilteredModelAttributes } from '@server/types'
-import { MAccountDefault, MAccountId, MVideoPlaylist, MVideoPlaylistFull } from '@server/types/models'
-import { AttributesOnly } from '@shared/core-utils'
+import { MThumbnail, MVideoPlaylist, MVideoPlaylistFull, MVideoPlaylistVideosLength } from '@server/types/models'
import { PlaylistObject } from '@shared/models'
-import { getOrCreateActorAndServerAndModel } from '../actor'
+import { AttributesOnly } from '@shared/typescript-utils'
+import { getAPId } from '../activity'
+import { getOrCreateAPActor } from '../actors'
import { crawlCollectionPage } from '../crawl'
import { getOrCreateAPVideo } from '../videos'
import {
playlistObjectToDBAttributes
} from './shared'
-import Bluebird = require('bluebird')
-
const lTags = loggerTagsFactory('ap', 'video-playlist')
-async function createAccountPlaylists (playlistUrls: string[], account: MAccountDefault) {
- await Bluebird.map(playlistUrls, async playlistUrl => {
+async function createAccountPlaylists (playlistUrls: string[]) {
+ await map(playlistUrls, async playlistUrl => {
try {
const exists = await VideoPlaylistModel.doesPlaylistExist(playlistUrl)
if (exists === true) return
throw new Error(`Cannot refresh remote playlist ${playlistUrl}: invalid body.`)
}
- return createOrUpdateVideoPlaylist(playlistObject, account, playlistObject.to)
+ return createOrUpdateVideoPlaylist(playlistObject)
} catch (err) {
logger.warn('Cannot add playlist element %s.', playlistUrl, { err, ...lTags(playlistUrl) })
}
}, { concurrency: CRAWL_REQUEST_CONCURRENCY })
}
-async function createOrUpdateVideoPlaylist (playlistObject: PlaylistObject, byAccount: MAccountId, to: string[]) {
- const playlistAttributes = playlistObjectToDBAttributes(playlistObject, byAccount, to)
+async function createOrUpdateVideoPlaylist (playlistObject: PlaylistObject, to?: string[]) {
+ const playlistAttributes = playlistObjectToDBAttributes(playlistObject, to || playlistObject.to)
- await setVideoChannelIfNeeded(playlistObject, playlistAttributes)
+ await setVideoChannel(playlistObject, playlistAttributes)
- const [ upsertPlaylist ] = await VideoPlaylistModel.upsert<MVideoPlaylist>(playlistAttributes, { returning: true })
+ const [ upsertPlaylist ] = await VideoPlaylistModel.upsert<MVideoPlaylistVideosLength>(playlistAttributes, { returning: true })
const playlistElementUrls = await fetchElementUrls(playlistObject)
// Refetch playlist from DB since elements fetching could be long in time
const playlist = await VideoPlaylistModel.loadWithAccountAndChannel(upsertPlaylist.id, null)
- try {
- await updatePlaylistThumbnail(playlistObject, playlist)
- } catch (err) {
- logger.warn('Cannot update thumbnail of %s.', playlistObject.id, { err, ...lTags(playlistObject.id, playlist.uuid, playlist.url) })
- }
+ await updatePlaylistThumbnail(playlistObject, playlist)
+
+ const elementsLength = await rebuildVideoPlaylistElements(playlistElementUrls, playlist)
+ playlist.setVideosLength(elementsLength)
- return rebuildVideoPlaylistElements(playlistElementUrls, playlist)
+ return playlist
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
-async function setVideoChannelIfNeeded (playlistObject: PlaylistObject, playlistAttributes: AttributesOnly<VideoPlaylistModel>) {
- if (!isArray(playlistObject.attributedTo) || playlistObject.attributedTo.length !== 1) return
+async function setVideoChannel (playlistObject: PlaylistObject, playlistAttributes: AttributesOnly<VideoPlaylistModel>) {
+ if (!isArray(playlistObject.attributedTo) || playlistObject.attributedTo.length !== 1) {
+ throw new Error('Not attributed to for playlist object ' + getAPId(playlistObject))
+ }
- const actor = await getOrCreateActorAndServerAndModel(playlistObject.attributedTo[0])
+ const actor = await getOrCreateAPActor(playlistObject.attributedTo[0], 'all')
if (!actor.VideoChannel) {
logger.warn('Playlist "attributedTo" %s is not a video channel.', playlistObject.id, { playlistObject, ...lTags(playlistObject.id) })
}
playlistAttributes.videoChannelId = actor.VideoChannel.id
+ playlistAttributes.ownerAccountId = actor.VideoChannel.Account.id
}
async function fetchElementUrls (playlistObject: PlaylistObject) {
async function updatePlaylistThumbnail (playlistObject: PlaylistObject, playlist: MVideoPlaylistFull) {
if (playlistObject.icon) {
- const thumbnailModel = await createPlaylistMiniatureFromUrl({ downloadUrl: playlistObject.icon.url, playlist })
- await playlist.setAndSaveThumbnail(thumbnailModel, undefined)
+ let thumbnailModel: MThumbnail
+
+ try {
+ thumbnailModel = await updatePlaylistMiniatureFromUrl({ downloadUrl: playlistObject.icon.url, playlist })
+ await playlist.setAndSaveThumbnail(thumbnailModel, undefined)
+ } catch (err) {
+ logger.warn('Cannot set thumbnail of %s.', playlistObject.id, { err, ...lTags(playlistObject.id, playlist.uuid, playlist.url) })
+
+ if (thumbnailModel) await thumbnailModel.removeThumbnail()
+ }
return
}
logger.info('Rebuilt playlist %s with %s elements.', playlist.url, elementsToCreate.length, lTags(playlist.uuid, playlist.url))
- return undefined
+ return elementsToCreate.length
}
async function buildElementsDBAttributes (elementUrls: string[], playlist: MVideoPlaylist) {
const elementsToCreate: FilteredModelAttributes<VideoPlaylistElementModel>[] = []
- await Bluebird.map(elementUrls, async elementUrl => {
+ await map(elementUrls, async elementUrl => {
try {
const { elementObject } = await fetchRemotePlaylistElement(elementUrl)