interesting
/
PeerTube
mirror of https://github.com/Chocobozzz/PeerTube.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add url field in caption and use it for thumbnails

This commit is contained in:
Chocobozzz 2020-01-30 11:53:38 +01:00
parent 215304eaa0
commit ca6d36227a
No known key found for this signature in database
GPG Key ID: 583A612D890159BE
20 changed files with 160 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/controllers/api/videos/captions.ts
View File

@ -66,7 +66,7 @@ async function addVideoCaption (req: express.Request, res: express.Response) {
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)

13
server/helpers/activitypub.ts
View File

@ -2,11 +2,11 @@ import * as Bluebird from 'bluebird'
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, {
@ -167,6 +167,12 @@ function checkUrlsSameHost (url1: string, url2: string) {
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 {
@ -174,5 +180,6 @@ export {
getAPId,
activityPubContextify,
activityPubCollectionPagination,
buildSignedActivity
buildSignedActivity,
buildRemoteVideoBaseUrl
}

2
server/helpers/core-utils.ts
View File

@ -199,6 +199,8 @@ function sha1 (str: string | Buffer, encoding: HexBase64Latin1Encoding = 'hex')
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) => {

26
server/helpers/custom-validators/activitypub/videos.ts
View File

@ -51,6 +51,10 @@ function sanitizeAndCheckVideoTorrentObject (video: any) {
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
@ -73,7 +77,6 @@ function sanitizeAndCheckVideoTorrentObject (video: any) {
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
}
@ -132,6 +135,8 @@ function setValidRemoteCaptions (video: any) {
if (Array.isArray(video.subtitleLanguage) === false) return false
video.subtitleLanguage = video.subtitleLanguage.filter(caption => {
if (!isActivityPubUrlValid(caption.url)) caption.url = null
return isRemoteStringIdentifierValid(caption)
})
@ -150,12 +155,19 @@ function isRemoteVideoContentValid (mediaType: string, content: string) {
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) {

8
server/initializers/constants.ts
View File

@ -14,7 +14,7 @@ import { CONFIG, registerConfigChangedHandler } from './config'
// ---------------------------------------------------------------------------
const LAST_MIGRATION_VERSION = 475
const LAST_MIGRATION_VERSION = 480
// ---------------------------------------------------------------------------
@ -541,11 +541,13 @@ let STATIC_MAX_AGE = {
// 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,

27
server/initializers/migrations/0480-caption-file-url.ts Normal file
View File

@ -0,0 +1,27 @@
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
}

68
server/lib/activitypub/videos.ts
View File

@ -6,7 +6,8 @@ import {
ActivityHashTagObject,
ActivityMagnetUrlObject,
ActivityPlaylistSegmentHashesObject,
ActivityPlaylistUrlObject, ActivityTagObject,
ActivityPlaylistUrlObject,
ActivityTagObject,
ActivityUrlObject,
ActivityVideoUrlObject,
VideoState
@ -17,14 +18,14 @@ import { sanitizeAndCheckVideoTorrentObject } from '../../helpers/custom-validat
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'
@ -40,7 +41,7 @@ import { ActivitypubHttpFetcherPayload } from '../job-queue/handlers/activitypub
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'
@ -71,6 +72,7 @@ import {
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
@ -131,19 +133,6 @@ async function fetchRemoteVideoDescription (video: MVideoAccountLight) {
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)
@ -173,7 +162,7 @@ async function syncVideoExternalAttributes (video: MVideo, fetchedVideo: VideoTo
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' })
}
@ -183,7 +172,7 @@ async function syncVideoExternalAttributes (video: MVideo, fetchedVideo: VideoTo
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' })
}
@ -193,7 +182,7 @@ async function syncVideoExternalAttributes (video: MVideo, fetchedVideo: VideoTo
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' })
}
@ -203,7 +192,7 @@ async function syncVideoExternalAttributes (video: MVideo, fetchedVideo: VideoTo
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' })
}
@ -284,7 +273,7 @@ async function updateVideoFromAP (options: {
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 })
}
@ -327,8 +316,7 @@ async function updateVideoFromAP (options: {
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)
@ -391,7 +379,7 @@ async function updateVideoFromAP (options: {
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)
}
@ -483,7 +471,6 @@ export {
federateVideoIfNeeded,
fetchRemoteVideo,
getOrCreateVideoAndAccountAndChannel,
fetchRemoteVideoStaticFile,
fetchRemoteVideoDescription,
getOrCreateVideoChannelFromVideoObject
}
@ -519,7 +506,7 @@ async function createVideo (videoObject: VideoTorrentObject, channel: MChannelAc
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) {
@ -534,9 +521,12 @@ async function createVideo (videoObject: VideoTorrentObject, channel: MChannelAc
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
@ -567,7 +557,7 @@ async function createVideo (videoObject: VideoTorrentObject, channel: MChannelAc
// 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)
@ -721,3 +711,19 @@ function streamingPlaylistActivityUrlToDBAttributes (video: MVideoId, videoObjec
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')
}

7
server/lib/files-cache/videos-caption-cache.ts
View File

@ -5,7 +5,7 @@ import { VideoCaptionModel } from '../../models/video/video-caption'
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 }
@ -46,11 +46,10 @@ class VideosCaptionCache extends AbstractVideoStaticFileCache <GetPathParam> {
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 }
}

12
server/lib/files-cache/videos-preview-cache.ts
View File

@ -2,8 +2,8 @@ import { join } from 'path'
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> {
@ -32,11 +32,11 @@ 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 }
}

4
server/lib/job-queue/handlers/video-views.ts
View File

@ -23,6 +23,8 @@ async function processVideosViews () {
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)
@ -52,8 +54,6 @@ async function processVideosViews () {
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 })
}

1
server/lib/job-queue/job-queue.ts
View File

@ -136,7 +136,6 @@ class JobQueue {
const filteredJobTypes = this.filterJobTypes(jobType)
// TODO: optimize
for (const jobType of filteredJobTypes) {
const queue = this.queues[ jobType ]
if (queue === undefined) {

13
server/models/video/thumbnail.ts
View File

@ -19,6 +19,8 @@ import { CONFIG } from '../../initializers/config'
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',
@ -126,11 +128,14 @@ export class ThumbnailModel extends Model<ThumbnailModel> {
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 () {

26
server/models/video/video-caption.ts
View File

@ -4,7 +4,7 @@ import {
BeforeDestroy,
BelongsTo,
Column,
CreatedAt,
CreatedAt, DataType,
ForeignKey,
Is,
Model,
@ -16,13 +16,14 @@ import { buildWhereIdOrUUID, throwIfNotValid } from '../utils'
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'
@ -64,6 +65,10 @@ export class VideoCaptionModel extends Model<VideoCaptionModel> {
@Column
language: string
@AllowNull(true)
@Column(DataType.STRING(CONSTRAINTS_FIELDS.COMMONS.URL.max))
fileUrl: string
@ForeignKey(() => VideoModel)
@Column
videoId: number
@ -114,10 +119,11 @@ export class VideoCaptionModel extends Model<VideoCaptionModel> {
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 })
@ -175,4 +181,14 @@ export class VideoCaptionModel extends Model<VideoCaptionModel> {
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())
}
}

15
server/models/video/video-format-utils.ts
View File

@ -307,11 +307,12 @@ function videoModelToActivityPubObject (video: MVideoAP): VideoTorrentObject {
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',
@ -336,13 +337,13 @@ function videoModelToActivityPubObject (video: MVideoAP): VideoTorrentObject {
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),

2
server/models/video/video.ts
View File

@ -1121,7 +1121,7 @@ export class VideoModel extends Model<VideoModel> {
},
include: [
{
attributes: [ 'language' ],
attributes: [ 'language', 'fileUrl' ],
model: VideoCaptionModel.unscoped(),
required: false
},

1
server/typings/models/video/video-caption.ts
View File

@ -11,6 +11,7 @@ export type MVideoCaption = Omit<VideoCaptionModel, 'Video'>
// ############################################################################
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'>>

4
server/typings/models/video/video.ts
View File

@ -9,7 +9,7 @@ import {
MChannelUserId
} from './video-channels'
import { MTag } from './tag'
import { MVideoCaptionLanguage } from './video-caption'
import { MVideoCaptionLanguage, MVideoCaptionLanguageUrl } from './video-caption'
import {
MStreamingPlaylistFiles,
MStreamingPlaylistRedundancies,
@ -140,7 +140,7 @@ export type MVideoAP = MVideo &
Use<'Tags', MTag[]> &
Use<'VideoChannel', MChannelAccountLight> &
Use<'VideoStreamingPlaylists', MStreamingPlaylistFiles[]> &
Use<'VideoCaptions', MVideoCaptionLanguage[]> &
Use<'VideoCaptions', MVideoCaptionLanguageUrl[]> &
Use<'VideoBlacklist', MVideoBlacklistUnfederated> &
Use<'VideoFiles', MVideoFileRedundanciesOpt[]> &
Use<'Thumbnails', MThumbnail[]>

1
shared/models/activitypub/objects/common-objects.ts
View File

@ -1,6 +1,7 @@
export interface ActivityIdentifierObject {
identifier: string
name: string
url?: string
}
export interface ActivityIconObject {

4
shared/models/activitypub/objects/video-torrent-object.ts
View File

@ -30,7 +30,9 @@ export interface VideoTorrentObject {
mediaType: 'text/markdown'
content: string
support: string
icon: ActivityIconObject
icon: ActivityIconObject[]
url: ActivityUrlObject[]
likes: string
dislikes: string

6
shared/models/users/user-role.ts
View File

@ -7,15 +7,13 @@ export enum UserRole {
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
],