import { generateMagnetUri } from '@server/helpers/webtorrent'
-import { getLocalVideoFileMetadataUrl } from '@server/lib/video-paths'
-import { VideoFile } from '@shared/models/videos/video-file.model'
+import { getLocalVideoFileMetadataUrl } from '@server/lib/video-urls'
+import { VideoViews } from '@server/lib/video-views'
+import { uuidToShort } from '@shared/core-utils'
+import { VideoFile, VideosCommonQueryAfterSanitize } from '@shared/models'
import { ActivityTagObject, ActivityUrlObject, VideoObject } from '../../../../shared/models/activitypub/objects'
-import { Video, VideoDetails } from '../../../../shared/models/videos'
+import { Video, VideoDetails, VideoInclude } from '../../../../shared/models/videos'
import { VideoStreamingPlaylist } from '../../../../shared/models/videos/video-streaming-playlist.model'
import { isArray } from '../../../helpers/custom-validators/misc'
-import { MIMETYPES, WEBSERVER } from '../../../initializers/constants'
+import {
+ MIMETYPES,
+ VIDEO_CATEGORIES,
+ VIDEO_LANGUAGES,
+ VIDEO_LICENCES,
+ VIDEO_PRIVACIES,
+ VIDEO_STATES,
+ WEBSERVER
+} from '../../../initializers/constants'
import {
getLocalVideoCommentsActivityPubUrl,
getLocalVideoDislikesActivityPubUrl,
getLocalVideoSharesActivityPubUrl
} from '../../../lib/activitypub/url'
import {
+ MServer,
MStreamingPlaylistRedundanciesOpt,
MVideo,
MVideoAP,
MVideoFormattableDetails
} from '../../../types/models'
import { MVideoFileRedundanciesOpt } from '../../../types/models/video/video-file'
-import { VideoModel } from '../video'
import { VideoCaptionModel } from '../video-caption'
export type VideoFormattingJSONOptions = {
completeDescription?: boolean
- additionalAttributes: {
+
+ additionalAttributes?: {
state?: boolean
waitTranscoding?: boolean
scheduledUpdate?: boolean
blacklistInfo?: boolean
+ files?: boolean
+ blockedOwner?: boolean
}
}
-function videoModelToFormattedJSON (video: MVideoFormattable, options?: VideoFormattingJSONOptions): Video {
+function guessAdditionalAttributesFromQuery (query: VideosCommonQueryAfterSanitize): VideoFormattingJSONOptions {
+ if (!query || !query.include) return {}
+
+ return {
+ additionalAttributes: {
+ state: !!(query.include & VideoInclude.NOT_PUBLISHED_STATE),
+ waitTranscoding: !!(query.include & VideoInclude.NOT_PUBLISHED_STATE),
+ scheduledUpdate: !!(query.include & VideoInclude.NOT_PUBLISHED_STATE),
+ blacklistInfo: !!(query.include & VideoInclude.BLACKLISTED),
+ files: !!(query.include & VideoInclude.FILES),
+ blockedOwner: !!(query.include & VideoInclude.BLOCKED_OWNER)
+ }
+ }
+}
+
+function videoModelToFormattedJSON (video: MVideoFormattable, options: VideoFormattingJSONOptions = {}): Video {
const userHistory = isArray(video.UserVideoHistories) ? video.UserVideoHistories[0] : undefined
const videoObject: Video = {
id: video.id,
uuid: video.uuid,
+ shortUUID: uuidToShort(video.uuid),
+
+ url: video.url,
+
name: video.name,
category: {
id: video.category,
- label: VideoModel.getCategoryLabel(video.category)
+ label: getCategoryLabel(video.category)
},
licence: {
id: video.licence,
- label: VideoModel.getLicenceLabel(video.licence)
+ label: getLicenceLabel(video.licence)
},
language: {
id: video.language,
- label: VideoModel.getLanguageLabel(video.language)
+ label: getLanguageLabel(video.language)
},
privacy: {
id: video.privacy,
- label: VideoModel.getPrivacyLabel(video.privacy)
+ label: getPrivacyLabel(video.privacy)
},
nsfw: video.nsfw,
pluginData: (video as any).pluginData
}
- if (options) {
- if (options.additionalAttributes.state === true) {
- videoObject.state = {
- id: video.state,
- label: VideoModel.getStateLabel(video.state)
- }
- }
+ if (video.isLive) {
+ videoObject.viewers = VideoViews.Instance.getViewers(video)
+ }
- if (options.additionalAttributes.waitTranscoding === true) {
- videoObject.waitTranscoding = video.waitTranscoding
+ const add = options.additionalAttributes
+ if (add?.state === true) {
+ videoObject.state = {
+ id: video.state,
+ label: getStateLabel(video.state)
}
+ }
- if (options.additionalAttributes.scheduledUpdate === true && video.ScheduleVideoUpdate) {
- videoObject.scheduledUpdate = {
- updateAt: video.ScheduleVideoUpdate.updateAt,
- privacy: video.ScheduleVideoUpdate.privacy || undefined
- }
- }
+ if (add?.waitTranscoding === true) {
+ videoObject.waitTranscoding = video.waitTranscoding
+ }
- if (options.additionalAttributes.blacklistInfo === true) {
- videoObject.blacklisted = !!video.VideoBlacklist
- videoObject.blacklistedReason = video.VideoBlacklist ? video.VideoBlacklist.reason : null
+ if (add?.scheduledUpdate === true && video.ScheduleVideoUpdate) {
+ videoObject.scheduledUpdate = {
+ updateAt: video.ScheduleVideoUpdate.updateAt,
+ privacy: video.ScheduleVideoUpdate.privacy || undefined
}
}
+ if (add?.blacklistInfo === true) {
+ videoObject.blacklisted = !!video.VideoBlacklist
+ videoObject.blacklistedReason = video.VideoBlacklist ? video.VideoBlacklist.reason : null
+ }
+
+ if (add?.blockedOwner === true) {
+ videoObject.blockedOwner = video.VideoChannel.Account.isBlocked()
+
+ const server = video.VideoChannel.Account.Actor.Server as MServer
+ videoObject.blockedServer = !!(server?.isBlocked())
+ }
+
+ if (add?.files === true) {
+ videoObject.streamingPlaylists = streamingPlaylistsModelToFormattedJSON(video, video.VideoStreamingPlaylists)
+ videoObject.files = videoFilesModelToFormattedJSON(video, video.VideoFiles)
+ }
+
return videoObject
}
function videoModelToFormattedDetailsJSON (video: MVideoFormattableDetails): VideoDetails {
- const formattedJson = video.toFormattedJSON({
+ const videoJSON = video.toFormattedJSON({
additionalAttributes: {
scheduledUpdate: true,
- blacklistInfo: true
+ blacklistInfo: true,
+ files: true
}
- })
+ }) as Video & Required<Pick<Video, 'files' | 'streamingPlaylists'>>
const tags = video.Tags ? video.Tags.map(t => t.name) : []
- const streamingPlaylists = streamingPlaylistsModelToFormattedJSON(video, video.VideoStreamingPlaylists)
-
- const detailsJson = {
+ const detailsJSON = {
support: video.support,
descriptionPath: video.getDescriptionAPIPath(),
channel: video.VideoChannel.toFormattedJSON(),
waitTranscoding: video.waitTranscoding,
state: {
id: video.state,
- label: VideoModel.getStateLabel(video.state)
+ label: getStateLabel(video.state)
},
- trackerUrls: video.getTrackerUrls(),
-
- files: [],
- streamingPlaylists
+ trackerUrls: video.getTrackerUrls()
}
- // Format and sort video files
- detailsJson.files = videoFilesModelToFormattedJSON(video, video.VideoFiles)
-
- return Object.assign(formattedJson, detailsJson)
+ return Object.assign(videoJSON, detailsJSON)
}
function streamingPlaylistsModelToFormattedJSON (
- video: MVideoFormattableDetails,
+ video: MVideoFormattable,
playlists: MStreamingPlaylistRedundanciesOpt[]
): VideoStreamingPlaylist[] {
if (isArray(playlists) === false) return []
return {
id: playlist.id,
type: playlist.type,
- playlistUrl: playlist.playlistUrl,
- segmentsSha256Url: playlist.segmentsSha256Url,
+ playlistUrl: playlist.getMasterPlaylistUrl(video),
+ segmentsSha256Url: playlist.getSha256SegmentsUrl(video),
redundancies,
files
}
}
function videoFilesModelToFormattedJSON (
- video: MVideoFormattableDetails,
+ video: MVideoFormattable,
videoFiles: MVideoFileRedundanciesOpt[],
includeMagnet = true
): VideoFile[] {
? video.getTrackerUrls()
: []
- return [ ...videoFiles ]
+ return (videoFiles || [])
.filter(f => !f.isLive())
.sort(sortByResolutionDesc)
.map(videoFile => {
return {
resolution: {
id: videoFile.resolution,
- label: videoFile.resolution + 'p'
+ label: videoFile.resolution === 0 ? 'Audio' : `${videoFile.resolution}p`
},
magnetUri: includeMagnet && videoFile.hasTorrent()
) {
const trackerUrls = video.getTrackerUrls()
- const sortedFiles = [ ...files ]
+ const sortedFiles = (files || [])
.filter(f => !f.isLive())
.sort(sortByResolutionDesc)
if (video.language) {
language = {
identifier: video.language,
- name: VideoModel.getLanguageLabel(video.language)
+ name: getLanguageLabel(video.language)
}
}
if (video.category) {
category = {
identifier: video.category + '',
- name: VideoModel.getCategoryLabel(video.category)
+ name: getCategoryLabel(video.category)
}
}
if (video.licence) {
licence = {
identifier: video.licence + '',
- name: VideoModel.getLicenceLabel(video.licence)
+ name: getLicenceLabel(video.licence)
}
}
type: 'Link',
name: 'sha256',
mediaType: 'application/json' as 'application/json',
- href: playlist.segmentsSha256Url
+ href: playlist.getSha256SegmentsUrl(video)
})
addVideoFilesInAPAcc(tag, video, playlist.VideoFiles || [])
url.push({
type: 'Link',
mediaType: 'application/x-mpegURL' as 'application/x-mpegURL',
- href: playlist.playlistUrl,
+ href: playlist.getMasterPlaylistUrl(video),
tag
})
}
return 'PT' + duration + 'S'
}
+function getCategoryLabel (id: number) {
+ return VIDEO_CATEGORIES[id] || 'Misc'
+}
+
+function getLicenceLabel (id: number) {
+ return VIDEO_LICENCES[id] || 'Unknown'
+}
+
+function getLanguageLabel (id: string) {
+ return VIDEO_LANGUAGES[id] || 'Unknown'
+}
+
+function getPrivacyLabel (id: number) {
+ return VIDEO_PRIVACIES[id] || 'Unknown'
+}
+
+function getStateLabel (id: number) {
+ return VIDEO_STATES[id] || 'Unknown'
+}
+
export {
videoModelToFormattedJSON,
videoModelToFormattedDetailsJSON,
videoFilesModelToFormattedJSON,
videoModelToActivityPubObject,
- getActivityStreamDuration
+ getActivityStreamDuration,
+
+ guessAdditionalAttributesFromQuery,
+
+ getCategoryLabel,
+ getLicenceLabel,
+ getLanguageLabel,
+ getPrivacyLabel,
+ getStateLabel
}
projects / github / Chocobozzz / PeerTube.git / blobdiff