await moveAndProcessCaptionFile(videoCaptionPhysicalFile, videoCaption)
await sequelizeTypescript.transaction(async t => {
- await VideoCaptionModel.insertOrReplaceLanguage(video.id, req.params.captionLanguage, t)
+ await VideoCaptionModel.insertOrReplaceLanguage(video.id, req.params.captionLanguage, null, t)
// Update video update
await federateVideoIfNeeded(video, false, t)
import validator from 'validator'
import { ResultList } from '../../shared/models'
import { Activity } from '../../shared/models/activitypub'
-import { ACTIVITY_PUB } from '../initializers/constants'
+import { ACTIVITY_PUB, REMOTE_SCHEME } from '../initializers/constants'
import { signJsonLDObject } from './peertube-crypto'
import { pageToStartAndCount } from './core-utils'
import { parse } from 'url'
-import { MActor } from '../typings/models'
+import { MActor, MVideoAccountLight } from '../typings/models'
function activityPubContextify <T> (data: T) {
return Object.assign(data, {
return idHost && actorHost && idHost.toLowerCase() === actorHost.toLowerCase()
}
+function buildRemoteVideoBaseUrl (video: MVideoAccountLight, path: string) {
+ const host = video.VideoChannel.Account.Actor.Server.host
+
+ return REMOTE_SCHEME.HTTP + '://' + host + path
+}
+
// ---------------------------------------------------------------------------
export {
getAPId,
activityPubContextify,
activityPubCollectionPagination,
- buildSignedActivity
+ buildSignedActivity,
+ buildRemoteVideoBaseUrl
}
return createHash('sha1').update(str).digest(encoding)
}
+
+
function execShell (command: string, options?: ExecOptions) {
return new Promise<{ err?: Error, stdout: string, stderr: string }>((res, rej) => {
exec(command, options, (err, stdout, stderr) => {
logger.debug('Video has invalid captions', { video })
return false
}
+ if (!setValidRemoteIcon(video)) {
+ logger.debug('Video has invalid icons', { video })
+ return false
+ }
// Default attributes
if (!isVideoStateValid(video.state)) video.state = VideoState.PUBLISHED
isDateValid(video.updated) &&
(!video.originallyPublishedAt || isDateValid(video.originallyPublishedAt)) &&
(!video.content || isRemoteVideoContentValid(video.mediaType, video.content)) &&
- isRemoteVideoIconValid(video.icon) &&
video.url.length !== 0 &&
video.attributedTo.length !== 0
}
if (Array.isArray(video.subtitleLanguage) === false) return false
video.subtitleLanguage = video.subtitleLanguage.filter(caption => {
+ if (!isActivityPubUrlValid(caption.url)) caption.url = null
+
return isRemoteStringIdentifierValid(caption)
})
return mediaType === 'text/markdown' && isVideoTruncatedDescriptionValid(content)
}
-function isRemoteVideoIconValid (icon: any) {
- return icon.type === 'Image' &&
- isActivityPubUrlValid(icon.url) &&
- icon.mediaType === 'image/jpeg' &&
- validator.isInt(icon.width + '', { min: 0 }) &&
- validator.isInt(icon.height + '', { min: 0 })
+function setValidRemoteIcon (video: any) {
+ if (video.icon && !isArray(video.icon)) video.icon = [ video.icon ]
+ if (!video.icon) video.icon = []
+
+ video.icon = video.icon.filter(icon => {
+ return icon.type === 'Image' &&
+ isActivityPubUrlValid(icon.url) &&
+ icon.mediaType === 'image/jpeg' &&
+ validator.isInt(icon.width + '', { min: 0 }) &&
+ validator.isInt(icon.height + '', { min: 0 })
+ })
+
+ return video.icon.length !== 0
}
function setValidRemoteVideoUrls (video: any) {
// ---------------------------------------------------------------------------
-const LAST_MIGRATION_VERSION = 475
+const LAST_MIGRATION_VERSION = 480
// ---------------------------------------------------------------------------
// Videos thumbnail size
const THUMBNAILS_SIZE = {
width: 223,
- height: 122
+ height: 122,
+ minWidth: 150
}
const PREVIEWS_SIZE = {
width: 850,
- height: 480
+ height: 480,
+ minWidth: 400
}
const AVATARS_SIZE = {
width: 120,
--- /dev/null
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+ transaction: Sequelize.Transaction,
+ queryInterface: Sequelize.QueryInterface,
+ sequelize: Sequelize.Sequelize,
+ db: any
+}): Promise<void> {
+ {
+ const data = {
+ type: Sequelize.STRING,
+ allowNull: true,
+ defaultValue: null
+ }
+
+ await utils.queryInterface.addColumn('videoCaption', 'fileUrl', data)
+ }
+}
+
+function down (options) {
+ throw new Error('Not implemented.')
+}
+
+export {
+ up,
+ down
+}
ActivityHashTagObject,
ActivityMagnetUrlObject,
ActivityPlaylistSegmentHashesObject,
- ActivityPlaylistUrlObject, ActivityTagObject,
+ ActivityPlaylistUrlObject,
+ ActivityTagObject,
ActivityUrlObject,
ActivityVideoUrlObject,
VideoState
import { isVideoFileInfoHashValid } from '../../helpers/custom-validators/videos'
import { deleteNonExistingModels, resetSequelizeInstance, retryTransactionWrapper } from '../../helpers/database-utils'
import { logger } from '../../helpers/logger'
-import { doRequest, doRequestAndSaveToFile } from '../../helpers/requests'
+import { doRequest } from '../../helpers/requests'
import {
ACTIVITY_PUB,
MIMETYPES,
P2P_MEDIA_LOADER_PEER_VERSION,
PREVIEWS_SIZE,
REMOTE_SCHEME,
- STATIC_PATHS
+ STATIC_PATHS, THUMBNAILS_SIZE
} from '../../initializers/constants'
import { TagModel } from '../../models/video/tag'
import { VideoModel } from '../../models/video/video'
import { createRates } from './video-rates'
import { addVideoShares, shareVideoByServerAndChannel } from './share'
import { fetchVideoByUrl, VideoFetchByUrlType } from '../../helpers/video'
-import { checkUrlsSameHost, getAPId } from '../../helpers/activitypub'
+import { buildRemoteVideoBaseUrl, checkUrlsSameHost, getAPId } from '../../helpers/activitypub'
import { Notifier } from '../notifier'
import { VideoStreamingPlaylistModel } from '../../models/video/video-streaming-playlist'
import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
MVideoThumbnail
} from '../../typings/models'
import { MThumbnail } from '../../typings/models/video/thumbnail'
+import { maxBy, minBy } from 'lodash'
async function federateVideoIfNeeded (videoArg: MVideoAPWithoutCaption, isNewVideo: boolean, transaction?: sequelize.Transaction) {
const video = videoArg as MVideoAP
return body.description ? body.description : ''
}
-function fetchRemoteVideoStaticFile (video: MVideoAccountLight, path: string, destPath: string) {
- const url = buildRemoteBaseUrl(video, path)
-
- // We need to provide a callback, if no we could have an uncaught exception
- return doRequestAndSaveToFile({ uri: url }, destPath)
-}
-
-function buildRemoteBaseUrl (video: MVideoAccountLight, path: string) {
- const host = video.VideoChannel.Account.Actor.Server.host
-
- return REMOTE_SCHEME.HTTP + '://' + host + path
-}
-
function getOrCreateVideoChannelFromVideoObject (videoObject: VideoTorrentObject) {
const channel = videoObject.attributedTo.find(a => a.type === 'Group')
if (!channel) throw new Error('Cannot find associated video channel to video ' + videoObject.url)
const cleaner = crawlStartDate => AccountVideoRateModel.cleanOldRatesOf(video.id, 'like' as 'like', crawlStartDate)
await crawlCollectionPage<string>(fetchedVideo.likes, handler, cleaner)
- .catch(err => logger.error('Cannot add likes of video %s.', video.uuid, { err }))
+ .catch(err => logger.error('Cannot add likes of video %s.', video.uuid, { err, rootUrl: fetchedVideo.likes }))
} else {
jobPayloads.push({ uri: fetchedVideo.likes, videoId: video.id, type: 'video-likes' as 'video-likes' })
}
const cleaner = crawlStartDate => AccountVideoRateModel.cleanOldRatesOf(video.id, 'dislike' as 'dislike', crawlStartDate)
await crawlCollectionPage<string>(fetchedVideo.dislikes, handler, cleaner)
- .catch(err => logger.error('Cannot add dislikes of video %s.', video.uuid, { err }))
+ .catch(err => logger.error('Cannot add dislikes of video %s.', video.uuid, { err, rootUrl: fetchedVideo.dislikes }))
} else {
jobPayloads.push({ uri: fetchedVideo.dislikes, videoId: video.id, type: 'video-dislikes' as 'video-dislikes' })
}
const cleaner = crawlStartDate => VideoShareModel.cleanOldSharesOf(video.id, crawlStartDate)
await crawlCollectionPage<string>(fetchedVideo.shares, handler, cleaner)
- .catch(err => logger.error('Cannot add shares of video %s.', video.uuid, { err }))
+ .catch(err => logger.error('Cannot add shares of video %s.', video.uuid, { err, rootUrl: fetchedVideo.shares }))
} else {
jobPayloads.push({ uri: fetchedVideo.shares, videoId: video.id, type: 'video-shares' as 'video-shares' })
}
const cleaner = crawlStartDate => VideoCommentModel.cleanOldCommentsOf(video.id, crawlStartDate)
await crawlCollectionPage<string>(fetchedVideo.comments, handler, cleaner)
- .catch(err => logger.error('Cannot add comments of video %s.', video.uuid, { err }))
+ .catch(err => logger.error('Cannot add comments of video %s.', video.uuid, { err, rootUrl: fetchedVideo.comments }))
} else {
jobPayloads.push({ uri: fetchedVideo.comments, videoId: video.id, type: 'video-comments' as 'video-comments' })
}
let thumbnailModel: MThumbnail
try {
- thumbnailModel = await createVideoMiniatureFromUrl(videoObject.icon.url, video, ThumbnailType.MINIATURE)
+ thumbnailModel = await createVideoMiniatureFromUrl(getThumbnailFromIcons(videoObject).url, video, ThumbnailType.MINIATURE)
} catch (err) {
logger.warn('Cannot generate thumbnail of %s.', videoObject.id, { err })
}
if (thumbnailModel) await videoUpdated.addAndSaveThumbnail(thumbnailModel, t)
- // FIXME: use icon URL instead
- const previewUrl = buildRemoteBaseUrl(videoUpdated, join(STATIC_PATHS.PREVIEWS, videoUpdated.getPreview().filename))
+ const previewUrl = videoUpdated.getPreview().getFileUrl(videoUpdated)
const previewModel = createPlaceholderThumbnail(previewUrl, video, ThumbnailType.PREVIEW, PREVIEWS_SIZE)
await videoUpdated.addAndSaveThumbnail(previewModel, t)
await VideoCaptionModel.deleteAllCaptionsOfRemoteVideo(videoUpdated.id, t)
const videoCaptionsPromises = videoObject.subtitleLanguage.map(c => {
- return VideoCaptionModel.insertOrReplaceLanguage(videoUpdated.id, c.identifier, t)
+ return VideoCaptionModel.insertOrReplaceLanguage(videoUpdated.id, c.identifier, c.url, t)
})
await Promise.all(videoCaptionsPromises)
}
federateVideoIfNeeded,
fetchRemoteVideo,
getOrCreateVideoAndAccountAndChannel,
- fetchRemoteVideoStaticFile,
fetchRemoteVideoDescription,
getOrCreateVideoChannelFromVideoObject
}
const videoData = await videoActivityObjectToDBAttributes(channel, videoObject, videoObject.to)
const video = VideoModel.build(videoData) as MVideoThumbnail
- const promiseThumbnail = createVideoMiniatureFromUrl(videoObject.icon.url, video, ThumbnailType.MINIATURE)
+ const promiseThumbnail = createVideoMiniatureFromUrl(getThumbnailFromIcons(videoObject).url, video, ThumbnailType.MINIATURE)
let thumbnailModel: MThumbnail
if (waitThumbnail === true) {
if (thumbnailModel) await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
- // FIXME: use icon URL instead
- const previewUrl = buildRemoteBaseUrl(videoCreated, join(STATIC_PATHS.PREVIEWS, video.generatePreviewName()))
- const previewModel = createPlaceholderThumbnail(previewUrl, video, ThumbnailType.PREVIEW, PREVIEWS_SIZE)
+ const previewIcon = getPreviewFromIcons(videoObject)
+ const previewUrl = previewIcon
+ ? previewIcon.url
+ : buildRemoteVideoBaseUrl(videoCreated, join(STATIC_PATHS.PREVIEWS, video.generatePreviewName()))
+ const previewModel = createPlaceholderThumbnail(previewUrl, videoCreated, ThumbnailType.PREVIEW, PREVIEWS_SIZE)
+
if (thumbnailModel) await videoCreated.addAndSaveThumbnail(previewModel, t)
// Process files
// Process captions
const videoCaptionsPromises = videoObject.subtitleLanguage.map(c => {
- return VideoCaptionModel.insertOrReplaceLanguage(videoCreated.id, c.identifier, t)
+ return VideoCaptionModel.insertOrReplaceLanguage(videoCreated.id, c.identifier, c.url, t)
})
await Promise.all(videoCaptionsPromises)
return attributes
}
+
+function getThumbnailFromIcons (videoObject: VideoTorrentObject) {
+ let validIcons = videoObject.icon.filter(i => i.width > THUMBNAILS_SIZE.minWidth)
+ // Fallback if there are not valid icons
+ if (validIcons.length === 0) validIcons = videoObject.icon
+
+ return minBy(validIcons, 'width')
+}
+
+function getPreviewFromIcons (videoObject: VideoTorrentObject) {
+ const validIcons = videoObject.icon.filter(i => i.width > PREVIEWS_SIZE.minWidth)
+
+ // FIXME: don't put a fallback here for compatibility with PeerTube <2.2
+
+ return maxBy(validIcons, 'width')
+}
import { AbstractVideoStaticFileCache } from './abstract-video-static-file-cache'
import { CONFIG } from '../../initializers/config'
import { logger } from '../../helpers/logger'
-import { fetchRemoteVideoStaticFile } from '../activitypub'
+import { doRequestAndSaveToFile } from '@server/helpers/requests'
type GetPathParam = { videoId: string, language: string }
const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
if (!video) return undefined
- // FIXME: use URL
- const remoteStaticPath = videoCaption.getCaptionStaticPath()
+ const remoteUrl = videoCaption.getFileUrl(video)
const destPath = join(FILES_CACHE.VIDEO_CAPTIONS.DIRECTORY, videoCaption.getCaptionName())
- await fetchRemoteVideoStaticFile(video, remoteStaticPath, destPath)
+ await doRequestAndSaveToFile({ uri: remoteUrl }, destPath)
return { isOwned: false, path: destPath }
}
import { FILES_CACHE, STATIC_PATHS } from '../../initializers/constants'
import { VideoModel } from '../../models/video/video'
import { AbstractVideoStaticFileCache } from './abstract-video-static-file-cache'
-import { CONFIG } from '../../initializers/config'
-import { fetchRemoteVideoStaticFile } from '../activitypub'
+import { doRequestAndSaveToFile } from '@server/helpers/requests'
+import { buildRemoteVideoBaseUrl } from '@server/helpers/activitypub'
class VideosPreviewCache extends AbstractVideoStaticFileCache <string> {
if (video.isOwned()) throw new Error('Cannot load remote preview of owned video.')
- // FIXME: use URL
- const remoteStaticPath = join(STATIC_PATHS.PREVIEWS, video.getPreview().filename)
- const destPath = join(FILES_CACHE.PREVIEWS.DIRECTORY, video.getPreview().filename)
+ const preview = video.getPreview()
+ const destPath = join(FILES_CACHE.PREVIEWS.DIRECTORY, preview.filename)
- await fetchRemoteVideoStaticFile(video, remoteStaticPath, destPath)
+ const remoteUrl = preview.getFileUrl(video)
+ await doRequestAndSaveToFile({ uri: remoteUrl }, destPath)
return { isOwned: false, path: destPath }
}
for (const videoId of videoIds) {
try {
const views = await Redis.Instance.getVideoViews(videoId, hour)
+ await Redis.Instance.deleteVideoViews(videoId, hour)
+
if (views) {
logger.debug('Adding %d views to video %d in hour %d.', views, videoId, hour)
logger.error('Cannot create video views for video %d in hour %d.', videoId, hour, { err })
}
}
-
- await Redis.Instance.deleteVideoViews(videoId, hour)
} catch (err) {
logger.error('Cannot update video views of video %d in hour %d.', videoId, hour, { err })
}
const filteredJobTypes = this.filterJobTypes(jobType)
- // TODO: optimize
for (const jobType of filteredJobTypes) {
const queue = this.queues[ jobType ]
if (queue === undefined) {
import { VideoModel } from './video'
import { VideoPlaylistModel } from './video-playlist'
import { ThumbnailType } from '../../../shared/models/videos/thumbnail.type'
+import { MVideoAccountLight } from '@server/typings/models'
+import { buildRemoteVideoBaseUrl } from '@server/helpers/activitypub'
@Table({
tableName: 'thumbnail',
return videoUUID + '.jpg'
}
- getFileUrl (isLocal: boolean) {
- if (isLocal === false) return this.fileUrl
+ getFileUrl (video: MVideoAccountLight) {
+ const staticPath = ThumbnailModel.types[this.type].staticPath + this.filename
- const staticPath = ThumbnailModel.types[this.type].staticPath
- return WEBSERVER.URL + staticPath + this.filename
+ if (video.isOwned()) return WEBSERVER.URL + staticPath
+ if (this.fileUrl) return this.fileUrl
+
+ // Fallback if we don't have a file URL
+ return buildRemoteVideoBaseUrl(video, staticPath)
}
getPath () {
BeforeDestroy,
BelongsTo,
Column,
- CreatedAt,
+ CreatedAt, DataType,
ForeignKey,
Is,
Model,
import { VideoModel } from './video'
import { isVideoCaptionLanguageValid } from '../../helpers/custom-validators/video-captions'
import { VideoCaption } from '../../../shared/models/videos/caption/video-caption.model'
-import { LAZY_STATIC_PATHS, VIDEO_LANGUAGES } from '../../initializers/constants'
+import { CONSTRAINTS_FIELDS, LAZY_STATIC_PATHS, STATIC_PATHS, VIDEO_LANGUAGES, WEBSERVER } from '../../initializers/constants'
import { join } from 'path'
import { logger } from '../../helpers/logger'
import { remove } from 'fs-extra'
import { CONFIG } from '../../initializers/config'
import * as Bluebird from 'bluebird'
-import { MVideoCaptionFormattable, MVideoCaptionVideo } from '@server/typings/models'
+import { MVideo, MVideoAccountLight, MVideoCaptionFormattable, MVideoCaptionVideo } from '@server/typings/models'
+import { buildRemoteVideoBaseUrl } from '@server/helpers/activitypub'
export enum ScopeNames {
WITH_VIDEO_UUID_AND_REMOTE = 'WITH_VIDEO_UUID_AND_REMOTE'
@Column
language: string
+ @AllowNull(true)
+ @Column(DataType.STRING(CONSTRAINTS_FIELDS.COMMONS.URL.max))
+ fileUrl: string
+
@ForeignKey(() => VideoModel)
@Column
videoId: number
return VideoCaptionModel.findOne(query)
}
- static insertOrReplaceLanguage (videoId: number, language: string, transaction: Transaction) {
+ static insertOrReplaceLanguage (videoId: number, language: string, fileUrl: string, transaction: Transaction) {
const values = {
videoId,
- language
+ language,
+ fileUrl
}
return VideoCaptionModel.upsert(values, { transaction, returning: true })
removeCaptionFile (this: MVideoCaptionFormattable) {
return remove(CONFIG.STORAGE.CAPTIONS_DIR + this.getCaptionName())
}
+
+ getFileUrl (video: MVideoAccountLight) {
+ if (!this.Video) this.Video = video as VideoModel
+
+ if (video.isOwned()) return WEBSERVER.URL + this.getCaptionStaticPath()
+ if (this.fileUrl) return this.fileUrl
+
+ // Fallback if we don't have a file URL
+ return buildRemoteVideoBaseUrl(video, this.getCaptionStaticPath())
+ }
}
for (const caption of video.VideoCaptions) {
subtitleLanguage.push({
identifier: caption.language,
- name: VideoCaptionModel.getLanguageLabel(caption.language)
+ name: VideoCaptionModel.getLanguageLabel(caption.language),
+ url: caption.getFileUrl(video)
})
}
- const miniature = video.getMiniature()
+ const icons = [ video.getMiniature(), video.getPreview() ]
return {
type: 'Video' as 'Video',
content: video.getTruncatedDescription(),
support: video.support,
subtitleLanguage,
- icon: {
+ icon: icons.map(i => ({
type: 'Image',
- url: miniature.getFileUrl(video.isOwned()),
+ url: i.getFileUrl(video),
mediaType: 'image/jpeg',
- width: miniature.width,
- height: miniature.height
- },
+ width: i.width,
+ height: i.height
+ })),
url,
likes: getVideoLikesActivityPubUrl(video),
dislikes: getVideoDislikesActivityPubUrl(video),
},
include: [
{
- attributes: [ 'language' ],
+ attributes: [ 'language', 'fileUrl' ],
model: VideoCaptionModel.unscoped(),
required: false
},
// ############################################################################
export type MVideoCaptionLanguage = Pick<MVideoCaption, 'language'>
+export type MVideoCaptionLanguageUrl = Pick<MVideoCaption, 'language' | 'fileUrl' | 'getFileUrl'>
export type MVideoCaptionVideo = MVideoCaption &
Use<'Video', Pick<MVideo, 'id' | 'remote' | 'uuid'>>
MChannelUserId
} from './video-channels'
import { MTag } from './tag'
-import { MVideoCaptionLanguage } from './video-caption'
+import { MVideoCaptionLanguage, MVideoCaptionLanguageUrl } from './video-caption'
import {
MStreamingPlaylistFiles,
MStreamingPlaylistRedundancies,
Use<'Tags', MTag[]> &
Use<'VideoChannel', MChannelAccountLight> &
Use<'VideoStreamingPlaylists', MStreamingPlaylistFiles[]> &
- Use<'VideoCaptions', MVideoCaptionLanguage[]> &
+ Use<'VideoCaptions', MVideoCaptionLanguageUrl[]> &
Use<'VideoBlacklist', MVideoBlacklistUnfederated> &
Use<'VideoFiles', MVideoFileRedundanciesOpt[]> &
Use<'Thumbnails', MThumbnail[]>
export interface ActivityIdentifierObject {
identifier: string
name: string
+ url?: string
}
export interface ActivityIconObject {
mediaType: 'text/markdown'
content: string
support: string
- icon: ActivityIconObject
+
+ icon: ActivityIconObject[]
+
url: ActivityUrlObject[]
likes: string
dislikes: string
USER = 2
}
-// TODO: use UserRole for key once https://github.com/Microsoft/TypeScript/issues/13042 is fixed
-export const USER_ROLE_LABELS: { [ id: number ]: string } = {
+export const USER_ROLE_LABELS: { [ id in UserRole ]: string } = {
[UserRole.USER]: 'User',
[UserRole.MODERATOR]: 'Moderator',
[UserRole.ADMINISTRATOR]: 'Administrator'
}
-// TODO: use UserRole for key once https://github.com/Microsoft/TypeScript/issues/13042 is fixed
-const userRoleRights: { [ id: number ]: UserRight[] } = {
+const userRoleRights: { [ id in UserRole ]: UserRight[] } = {
[UserRole.ADMINISTRATOR]: [
UserRight.ALL
],
projects / oweals / peertube.git / commitdiff