aboutsummaryrefslogtreecommitdiffhomepage
path: root/server/controllers/feeds
diff options
context:
space:
mode:
authorChocobozzz <me@florianbigard.com>2023-07-31 14:34:36 +0200
committerChocobozzz <me@florianbigard.com>2023-08-11 15:02:33 +0200
commit3a4992633ee62d5edfbb484d9c6bcb3cf158489d (patch)
treee4510b39bdac9c318fdb4b47018d08f15368b8f0 /server/controllers/feeds
parent04d1da5621d25d59bd5fa1543b725c497bf5d9a8 (diff)
downloadPeerTube-3a4992633ee62d5edfbb484d9c6bcb3cf158489d.tar.gz
PeerTube-3a4992633ee62d5edfbb484d9c6bcb3cf158489d.tar.zst
PeerTube-3a4992633ee62d5edfbb484d9c6bcb3cf158489d.zip
Migrate server to ESM
Sorry for the very big commit that may lead to git log issues and merge conflicts, but it's a major step forward: * Server can be faster at startup because imports() are async and we can easily lazy import big modules * Angular doesn't seem to support ES import (with .js extension), so we had to correctly organize peertube into a monorepo: * Use yarn workspace feature * Use typescript reference projects for dependencies * Shared projects have been moved into "packages", each one is now a node module (with a dedicated package.json/tsconfig.json) * server/tools have been moved into apps/ and is now a dedicated app bundled and published on NPM so users don't have to build peertube cli tools manually * server/tests have been moved into packages/ so we don't compile them every time we want to run the server * Use isolatedModule option: * Had to move from const enum to const (https://www.typescriptlang.org/docs/handbook/enums.html#objects-vs-enums) * Had to explictely specify "type" imports when used in decorators * Prefer tsx (that uses esbuild under the hood) instead of ts-node to load typescript files (tests with mocha or scripts): * To reduce test complexity as esbuild doesn't support decorator metadata, we only test server files that do not import server models * We still build tests files into js files for a faster CI * Remove unmaintained peertube CLI import script * Removed some barrels to speed up execution (less imports)
Diffstat (limited to 'server/controllers/feeds')
-rw-r--r--server/controllers/feeds/comment-feeds.ts96
-rw-r--r--server/controllers/feeds/index.ts25
-rw-r--r--server/controllers/feeds/shared/common-feed-utils.ts149
-rw-r--r--server/controllers/feeds/shared/index.ts2
-rw-r--r--server/controllers/feeds/shared/video-feed-utils.ts66
-rw-r--r--server/controllers/feeds/video-feeds.ts189
-rw-r--r--server/controllers/feeds/video-podcast-feeds.ts313
7 files changed, 0 insertions, 840 deletions
diff --git a/server/controllers/feeds/comment-feeds.ts b/server/controllers/feeds/comment-feeds.ts
deleted file mode 100644
index c013662ea..000000000
--- a/server/controllers/feeds/comment-feeds.ts
+++ /dev/null
@@ -1,96 +0,0 @@
1import express from 'express'
2import { toSafeHtml } from '@server/helpers/markdown'
3import { cacheRouteFactory } from '@server/middlewares'
4import { CONFIG } from '../../initializers/config'
5import { ROUTE_CACHE_LIFETIME, WEBSERVER } from '../../initializers/constants'
6import {
7 asyncMiddleware,
8 feedsFormatValidator,
9 setFeedFormatContentType,
10 videoCommentsFeedsValidator,
11 feedsAccountOrChannelFiltersValidator
12} from '../../middlewares'
13import { VideoCommentModel } from '../../models/video/video-comment'
14import { buildFeedMetadata, initFeed, sendFeed } from './shared'
15
16const commentFeedsRouter = express.Router()
17
18// ---------------------------------------------------------------------------
19
20const { middleware: cacheRouteMiddleware } = cacheRouteFactory({
21 headerBlacklist: [ 'Content-Type' ]
22})
23
24// ---------------------------------------------------------------------------
25
26commentFeedsRouter.get('/video-comments.:format',
27 feedsFormatValidator,
28 setFeedFormatContentType,
29 cacheRouteMiddleware(ROUTE_CACHE_LIFETIME.FEEDS),
30 asyncMiddleware(feedsAccountOrChannelFiltersValidator),
31 asyncMiddleware(videoCommentsFeedsValidator),
32 asyncMiddleware(generateVideoCommentsFeed)
33)
34
35// ---------------------------------------------------------------------------
36
37export {
38 commentFeedsRouter
39}
40
41// ---------------------------------------------------------------------------
42
43async function generateVideoCommentsFeed (req: express.Request, res: express.Response) {
44 const start = 0
45 const video = res.locals.videoAll
46 const account = res.locals.account
47 const videoChannel = res.locals.videoChannel
48
49 const comments = await VideoCommentModel.listForFeed({
50 start,
51 count: CONFIG.FEEDS.COMMENTS.COUNT,
52 videoId: video ? video.id : undefined,
53 accountId: account ? account.id : undefined,
54 videoChannelId: videoChannel ? videoChannel.id : undefined
55 })
56
57 const { name, description, imageUrl, link } = await buildFeedMetadata({ video, account, videoChannel })
58
59 const feed = initFeed({
60 name,
61 description,
62 imageUrl,
63 isPodcast: false,
64 link,
65 resourceType: 'video-comments',
66 queryString: new URL(WEBSERVER.URL + req.originalUrl).search
67 })
68
69 // Adding video items to the feed, one at a time
70 for (const comment of comments) {
71 const localLink = WEBSERVER.URL + comment.getCommentStaticPath()
72
73 let title = comment.Video.name
74 const author: { name: string, link: string }[] = []
75
76 if (comment.Account) {
77 title += ` - ${comment.Account.getDisplayName()}`
78 author.push({
79 name: comment.Account.getDisplayName(),
80 link: comment.Account.Actor.url
81 })
82 }
83
84 feed.addItem({
85 title,
86 id: localLink,
87 link: localLink,
88 content: toSafeHtml(comment.text),
89 author,
90 date: comment.createdAt
91 })
92 }
93
94 // Now the feed generation is done, let's send it!
95 return sendFeed(feed, req, res)
96}
diff --git a/server/controllers/feeds/index.ts b/server/controllers/feeds/index.ts
deleted file mode 100644
index 19352318d..000000000
--- a/server/controllers/feeds/index.ts
+++ /dev/null
@@ -1,25 +0,0 @@
1import express from 'express'
2import { CONFIG } from '@server/initializers/config'
3import { buildRateLimiter } from '@server/middlewares'
4import { commentFeedsRouter } from './comment-feeds'
5import { videoFeedsRouter } from './video-feeds'
6import { videoPodcastFeedsRouter } from './video-podcast-feeds'
7
8const feedsRouter = express.Router()
9
10const feedsRateLimiter = buildRateLimiter({
11 windowMs: CONFIG.RATES_LIMIT.FEEDS.WINDOW_MS,
12 max: CONFIG.RATES_LIMIT.FEEDS.MAX
13})
14
15feedsRouter.use('/feeds', feedsRateLimiter)
16
17feedsRouter.use('/feeds', commentFeedsRouter)
18feedsRouter.use('/feeds', videoFeedsRouter)
19feedsRouter.use('/feeds', videoPodcastFeedsRouter)
20
21// ---------------------------------------------------------------------------
22
23export {
24 feedsRouter
25}
diff --git a/server/controllers/feeds/shared/common-feed-utils.ts b/server/controllers/feeds/shared/common-feed-utils.ts
deleted file mode 100644
index 9e2f8adbb..000000000
--- a/server/controllers/feeds/shared/common-feed-utils.ts
+++ /dev/null
@@ -1,149 +0,0 @@
1import express from 'express'
2import { Feed } from '@peertube/feed'
3import { CustomTag, CustomXMLNS, Person } from '@peertube/feed/lib/typings'
4import { mdToOneLinePlainText } from '@server/helpers/markdown'
5import { CONFIG } from '@server/initializers/config'
6import { WEBSERVER } from '@server/initializers/constants'
7import { getBiggestActorImage } from '@server/lib/actor-image'
8import { UserModel } from '@server/models/user/user'
9import { MAccountDefault, MChannelBannerAccountDefault, MUser, MVideoFullLight } from '@server/types/models'
10import { pick } from '@shared/core-utils'
11import { ActorImageType } from '@shared/models'
12
13export function initFeed (parameters: {
14 name: string
15 description: string
16 imageUrl: string
17 isPodcast: boolean
18 link?: string
19 locked?: { isLocked: boolean, email: string }
20 author?: {
21 name: string
22 link: string
23 imageUrl: string
24 }
25 person?: Person[]
26 resourceType?: 'videos' | 'video-comments'
27 queryString?: string
28 medium?: string
29 stunServers?: string[]
30 trackers?: string[]
31 customXMLNS?: CustomXMLNS[]
32 customTags?: CustomTag[]
33}) {
34 const webserverUrl = WEBSERVER.URL
35 const { name, description, link, imageUrl, isPodcast, resourceType, queryString, medium } = parameters
36
37 return new Feed({
38 title: name,
39 description: mdToOneLinePlainText(description),
40 // updated: TODO: somehowGetLatestUpdate, // optional, default = today
41 id: link || webserverUrl,
42 link: link || webserverUrl,
43 image: imageUrl,
44 favicon: webserverUrl + '/client/assets/images/favicon.png',
45 copyright: `All rights reserved, unless otherwise specified in the terms specified at ${webserverUrl}/about` +
46 ` and potential licenses granted by each content's rightholder.`,
47 generator: `Toraifōsu`, // ^.~
48 medium: medium || 'video',
49 feedLinks: {
50 json: `${webserverUrl}/feeds/${resourceType}.json${queryString}`,
51 atom: `${webserverUrl}/feeds/${resourceType}.atom${queryString}`,
52 rss: isPodcast
53 ? `${webserverUrl}/feeds/podcast/videos.xml${queryString}`
54 : `${webserverUrl}/feeds/${resourceType}.xml${queryString}`
55 },
56
57 ...pick(parameters, [ 'stunServers', 'trackers', 'customXMLNS', 'customTags', 'author', 'person', 'locked' ])
58 })
59}
60
61export function sendFeed (feed: Feed, req: express.Request, res: express.Response) {
62 const format = req.params.format
63
64 if (format === 'atom' || format === 'atom1') {
65 return res.send(feed.atom1()).end()
66 }
67
68 if (format === 'json' || format === 'json1') {
69 return res.send(feed.json1()).end()
70 }
71
72 if (format === 'rss' || format === 'rss2') {
73 return res.send(feed.rss2()).end()
74 }
75
76 // We're in the ambiguous '.xml' case and we look at the format query parameter
77 if (req.query.format === 'atom' || req.query.format === 'atom1') {
78 return res.send(feed.atom1()).end()
79 }
80
81 return res.send(feed.rss2()).end()
82}
83
84export async function buildFeedMetadata (options: {
85 videoChannel?: MChannelBannerAccountDefault
86 account?: MAccountDefault
87 video?: MVideoFullLight
88}) {
89 const { video, videoChannel, account } = options
90
91 let imageUrl = WEBSERVER.URL + '/client/assets/images/icons/icon-96x96.png'
92 let accountImageUrl: string
93 let name: string
94 let userName: string
95 let description: string
96 let email: string
97 let link: string
98 let accountLink: string
99 let user: MUser
100
101 if (videoChannel) {
102 name = videoChannel.getDisplayName()
103 description = videoChannel.description
104 link = videoChannel.getClientUrl()
105 accountLink = videoChannel.Account.getClientUrl()
106
107 if (videoChannel.Actor.hasImage(ActorImageType.AVATAR)) {
108 const videoChannelAvatar = getBiggestActorImage(videoChannel.Actor.Avatars)
109 imageUrl = WEBSERVER.URL + videoChannelAvatar.getStaticPath()
110 }
111
112 if (videoChannel.Account.Actor.hasImage(ActorImageType.AVATAR)) {
113 const accountAvatar = getBiggestActorImage(videoChannel.Account.Actor.Avatars)
114 accountImageUrl = WEBSERVER.URL + accountAvatar.getStaticPath()
115 }
116
117 user = await UserModel.loadById(videoChannel.Account.userId)
118 userName = videoChannel.Account.getDisplayName()
119 } else if (account) {
120 name = account.getDisplayName()
121 description = account.description
122 link = account.getClientUrl()
123 accountLink = link
124
125 if (account.Actor.hasImage(ActorImageType.AVATAR)) {
126 const accountAvatar = getBiggestActorImage(account.Actor.Avatars)
127 imageUrl = WEBSERVER.URL + accountAvatar?.getStaticPath()
128 accountImageUrl = imageUrl
129 }
130
131 user = await UserModel.loadById(account.userId)
132 } else if (video) {
133 name = video.name
134 description = video.description
135 link = video.url
136 } else {
137 name = CONFIG.INSTANCE.NAME
138 description = CONFIG.INSTANCE.DESCRIPTION
139 link = WEBSERVER.URL
140 }
141
142 // If the user is local, has a verified email address, and allows it to be publicly displayed
143 // Return it so the owner can prove ownership of their feed
144 if (user && !user.pluginAuth && user.emailVerified && user.emailPublic) {
145 email = user.email
146 }
147
148 return { name, userName, description, imageUrl, accountImageUrl, email, link, accountLink }
149}
diff --git a/server/controllers/feeds/shared/index.ts b/server/controllers/feeds/shared/index.ts
deleted file mode 100644
index 0136c8477..000000000
--- a/server/controllers/feeds/shared/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
1export * from './video-feed-utils'
2export * from './common-feed-utils'
diff --git a/server/controllers/feeds/shared/video-feed-utils.ts b/server/controllers/feeds/shared/video-feed-utils.ts
deleted file mode 100644
index b154e04fa..000000000
--- a/server/controllers/feeds/shared/video-feed-utils.ts
+++ /dev/null
@@ -1,66 +0,0 @@
1import { mdToOneLinePlainText, toSafeHtml } from '@server/helpers/markdown'
2import { CONFIG } from '@server/initializers/config'
3import { WEBSERVER } from '@server/initializers/constants'
4import { getServerActor } from '@server/models/application/application'
5import { getCategoryLabel } from '@server/models/video/formatter'
6import { DisplayOnlyForFollowerOptions } from '@server/models/video/sql/video'
7import { VideoModel } from '@server/models/video/video'
8import { MThumbnail, MUserDefault } from '@server/types/models'
9import { VideoInclude } from '@shared/models'
10
11export async function getVideosForFeeds (options: {
12 sort: string
13 nsfw: boolean
14 isLocal: boolean
15 include: VideoInclude
16
17 accountId?: number
18 videoChannelId?: number
19 displayOnlyForFollower?: DisplayOnlyForFollowerOptions
20 user?: MUserDefault
21}) {
22 const server = await getServerActor()
23
24 const { data } = await VideoModel.listForApi({
25 start: 0,
26 count: CONFIG.FEEDS.VIDEOS.COUNT,
27 displayOnlyForFollower: {
28 actorId: server.id,
29 orLocalVideos: true
30 },
31 hasFiles: true,
32 countVideos: false,
33
34 ...options
35 })
36
37 return data
38}
39
40export function getCommonVideoFeedAttributes (video: VideoModel) {
41 const localLink = WEBSERVER.URL + video.getWatchStaticPath()
42
43 const thumbnailModels: MThumbnail[] = []
44 if (video.hasPreview()) thumbnailModels.push(video.getPreview())
45 thumbnailModels.push(video.getMiniature())
46
47 return {
48 title: video.name,
49 link: localLink,
50 description: mdToOneLinePlainText(video.getTruncatedDescription()),
51 content: toSafeHtml(video.description),
52
53 date: video.publishedAt,
54 nsfw: video.nsfw,
55
56 category: video.category
57 ? [ { name: getCategoryLabel(video.category) } ]
58 : undefined,
59
60 thumbnails: thumbnailModels.map(t => ({
61 url: WEBSERVER.URL + t.getLocalStaticPath(),
62 width: t.width,
63 height: t.height
64 }))
65 }
66}
diff --git a/server/controllers/feeds/video-feeds.ts b/server/controllers/feeds/video-feeds.ts
deleted file mode 100644
index e5941be40..000000000
--- a/server/controllers/feeds/video-feeds.ts
+++ /dev/null
@@ -1,189 +0,0 @@
1import express from 'express'
2import { extname } from 'path'
3import { Feed } from '@peertube/feed'
4import { cacheRouteFactory } from '@server/middlewares'
5import { VideoModel } from '@server/models/video/video'
6import { VideoInclude } from '@shared/models'
7import { buildNSFWFilter } from '../../helpers/express-utils'
8import { MIMETYPES, ROUTE_CACHE_LIFETIME, WEBSERVER } from '../../initializers/constants'
9import {
10 asyncMiddleware,
11 commonVideosFiltersValidator,
12 feedsFormatValidator,
13 setDefaultVideosSort,
14 setFeedFormatContentType,
15 feedsAccountOrChannelFiltersValidator,
16 videosSortValidator,
17 videoSubscriptionFeedsValidator
18} from '../../middlewares'
19import { buildFeedMetadata, getCommonVideoFeedAttributes, getVideosForFeeds, initFeed, sendFeed } from './shared'
20
21const videoFeedsRouter = express.Router()
22
23const { middleware: cacheRouteMiddleware } = cacheRouteFactory({
24 headerBlacklist: [ 'Content-Type' ]
25})
26
27// ---------------------------------------------------------------------------
28
29videoFeedsRouter.get('/videos.:format',
30 videosSortValidator,
31 setDefaultVideosSort,
32 feedsFormatValidator,
33 setFeedFormatContentType,
34 cacheRouteMiddleware(ROUTE_CACHE_LIFETIME.FEEDS),
35 commonVideosFiltersValidator,
36 asyncMiddleware(feedsAccountOrChannelFiltersValidator),
37 asyncMiddleware(generateVideoFeed)
38)
39
40videoFeedsRouter.get('/subscriptions.:format',
41 videosSortValidator,
42 setDefaultVideosSort,
43 feedsFormatValidator,
44 setFeedFormatContentType,
45 cacheRouteMiddleware(ROUTE_CACHE_LIFETIME.FEEDS),
46 commonVideosFiltersValidator,
47 asyncMiddleware(videoSubscriptionFeedsValidator),
48 asyncMiddleware(generateVideoFeedForSubscriptions)
49)
50
51// ---------------------------------------------------------------------------
52
53export {
54 videoFeedsRouter
55}
56
57// ---------------------------------------------------------------------------
58
59async function generateVideoFeed (req: express.Request, res: express.Response) {
60 const account = res.locals.account
61 const videoChannel = res.locals.videoChannel
62
63 const { name, description, imageUrl, accountImageUrl, link, accountLink } = await buildFeedMetadata({ videoChannel, account })
64
65 const feed = initFeed({
66 name,
67 description,
68 link,
69 isPodcast: false,
70 imageUrl,
71 author: { name, link: accountLink, imageUrl: accountImageUrl },
72 resourceType: 'videos',
73 queryString: new URL(WEBSERVER.URL + req.url).search
74 })
75
76 const data = await getVideosForFeeds({
77 sort: req.query.sort,
78 nsfw: buildNSFWFilter(res, req.query.nsfw),
79 isLocal: req.query.isLocal,
80 include: req.query.include | VideoInclude.FILES,
81 accountId: account?.id,
82 videoChannelId: videoChannel?.id
83 })
84
85 addVideosToFeed(feed, data)
86
87 // Now the feed generation is done, let's send it!
88 return sendFeed(feed, req, res)
89}
90
91async function generateVideoFeedForSubscriptions (req: express.Request, res: express.Response) {
92 const account = res.locals.account
93 const { name, description, imageUrl, link } = await buildFeedMetadata({ account })
94
95 const feed = initFeed({
96 name,
97 description,
98 link,
99 isPodcast: false,
100 imageUrl,
101 resourceType: 'videos',
102 queryString: new URL(WEBSERVER.URL + req.url).search
103 })
104
105 const data = await getVideosForFeeds({
106 sort: req.query.sort,
107 nsfw: buildNSFWFilter(res, req.query.nsfw),
108 isLocal: req.query.isLocal,
109 include: req.query.include | VideoInclude.FILES,
110 displayOnlyForFollower: {
111 actorId: res.locals.user.Account.Actor.id,
112 orLocalVideos: false
113 },
114 user: res.locals.user
115 })
116
117 addVideosToFeed(feed, data)
118
119 // Now the feed generation is done, let's send it!
120 return sendFeed(feed, req, res)
121}
122
123// ---------------------------------------------------------------------------
124
125function addVideosToFeed (feed: Feed, videos: VideoModel[]) {
126 /**
127 * Adding video items to the feed object, one at a time
128 */
129 for (const video of videos) {
130 const formattedVideoFiles = video.getFormattedAllVideoFilesJSON(false)
131
132 const torrents = formattedVideoFiles.map(videoFile => ({
133 title: video.name,
134 url: videoFile.torrentUrl,
135 size_in_bytes: videoFile.size
136 }))
137
138 const videoFiles = formattedVideoFiles.map(videoFile => {
139 return {
140 type: MIMETYPES.VIDEO.EXT_MIMETYPE[extname(videoFile.fileUrl)],
141 medium: 'video',
142 height: videoFile.resolution.id,
143 fileSize: videoFile.size,
144 url: videoFile.fileUrl,
145 framerate: videoFile.fps,
146 duration: video.duration,
147 lang: video.language
148 }
149 })
150
151 feed.addItem({
152 ...getCommonVideoFeedAttributes(video),
153
154 id: WEBSERVER.URL + video.getWatchStaticPath(),
155 author: [
156 {
157 name: video.VideoChannel.getDisplayName(),
158 link: video.VideoChannel.getClientUrl()
159 }
160 ],
161 torrents,
162
163 // Enclosure
164 video: videoFiles.length !== 0
165 ? {
166 url: videoFiles[0].url,
167 length: videoFiles[0].fileSize,
168 type: videoFiles[0].type
169 }
170 : undefined,
171
172 // Media RSS
173 videos: videoFiles,
174
175 embed: {
176 url: WEBSERVER.URL + video.getEmbedStaticPath(),
177 allowFullscreen: true
178 },
179 player: {
180 url: WEBSERVER.URL + video.getWatchStaticPath()
181 },
182 community: {
183 statistics: {
184 views: video.views
185 }
186 }
187 })
188 }
189}
diff --git a/server/controllers/feeds/video-podcast-feeds.ts b/server/controllers/feeds/video-podcast-feeds.ts
deleted file mode 100644
index fca82ba68..000000000
--- a/server/controllers/feeds/video-podcast-feeds.ts
+++ /dev/null
@@ -1,313 +0,0 @@
1import express from 'express'
2import { extname } from 'path'
3import { Feed } from '@peertube/feed'
4import { CustomTag, CustomXMLNS, LiveItemStatus } from '@peertube/feed/lib/typings'
5import { getBiggestActorImage } from '@server/lib/actor-image'
6import { InternalEventEmitter } from '@server/lib/internal-event-emitter'
7import { Hooks } from '@server/lib/plugins/hooks'
8import { buildPodcastGroupsCache, cacheRouteFactory, videoFeedsPodcastSetCacheKey } from '@server/middlewares'
9import { MVideo, MVideoCaptionVideo, MVideoFullLight } from '@server/types/models'
10import { sortObjectComparator } from '@shared/core-utils'
11import { ActorImageType, VideoFile, VideoInclude, VideoResolution, VideoState } from '@shared/models'
12import { buildNSFWFilter } from '../../helpers/express-utils'
13import { MIMETYPES, ROUTE_CACHE_LIFETIME, WEBSERVER } from '../../initializers/constants'
14import { asyncMiddleware, setFeedPodcastContentType, videoFeedsPodcastValidator } from '../../middlewares'
15import { VideoModel } from '../../models/video/video'
16import { VideoCaptionModel } from '../../models/video/video-caption'
17import { buildFeedMetadata, getCommonVideoFeedAttributes, getVideosForFeeds, initFeed } from './shared'
18
19const videoPodcastFeedsRouter = express.Router()
20
21// ---------------------------------------------------------------------------
22
23const { middleware: podcastCacheRouteMiddleware, instance: podcastApiCache } = cacheRouteFactory({
24 headerBlacklist: [ 'Content-Type' ]
25})
26
27for (const event of ([ 'video-created', 'video-updated', 'video-deleted' ] as const)) {
28 InternalEventEmitter.Instance.on(event, ({ video }) => {
29 if (video.remote) return
30
31 podcastApiCache.clearGroupSafe(buildPodcastGroupsCache({ channelId: video.channelId }))
32 })
33}
34
35for (const event of ([ 'channel-updated', 'channel-deleted' ] as const)) {
36 InternalEventEmitter.Instance.on(event, ({ channel }) => {
37 podcastApiCache.clearGroupSafe(buildPodcastGroupsCache({ channelId: channel.id }))
38 })
39}
40
41// ---------------------------------------------------------------------------
42
43videoPodcastFeedsRouter.get('/podcast/videos.xml',
44 setFeedPodcastContentType,
45 videoFeedsPodcastSetCacheKey,
46 podcastCacheRouteMiddleware(ROUTE_CACHE_LIFETIME.FEEDS),
47 asyncMiddleware(videoFeedsPodcastValidator),
48 asyncMiddleware(generateVideoPodcastFeed)
49)
50
51// ---------------------------------------------------------------------------
52
53export {
54 videoPodcastFeedsRouter
55}
56
57// ---------------------------------------------------------------------------
58
59async function generateVideoPodcastFeed (req: express.Request, res: express.Response) {
60 const videoChannel = res.locals.videoChannel
61
62 const { name, userName, description, imageUrl, accountImageUrl, email, link, accountLink } = await buildFeedMetadata({ videoChannel })
63
64 const data = await getVideosForFeeds({
65 sort: '-publishedAt',
66 nsfw: buildNSFWFilter(),
67 // Prevent podcast feeds from listing videos in other instances
68 // helps prevent duplicates when they are indexed -- only the author should control them
69 isLocal: true,
70 include: VideoInclude.FILES,
71 videoChannelId: videoChannel?.id
72 })
73
74 const customTags: CustomTag[] = await Hooks.wrapObject(
75 [],
76 'filter:feed.podcast.channel.create-custom-tags.result',
77 { videoChannel }
78 )
79
80 const customXMLNS: CustomXMLNS[] = await Hooks.wrapObject(
81 [],
82 'filter:feed.podcast.rss.create-custom-xmlns.result'
83 )
84
85 const feed = initFeed({
86 name,
87 description,
88 link,
89 isPodcast: true,
90 imageUrl,
91
92 locked: email
93 ? { isLocked: true, email } // Default to true because we have no way of offering a redirect yet
94 : undefined,
95
96 person: [ { name: userName, href: accountLink, img: accountImageUrl } ],
97 resourceType: 'videos',
98 queryString: new URL(WEBSERVER.URL + req.url).search,
99 medium: 'video',
100 customXMLNS,
101 customTags
102 })
103
104 await addVideosToPodcastFeed(feed, data)
105
106 // Now the feed generation is done, let's send it!
107 return res.send(feed.podcast()).end()
108}
109
110type PodcastMedia =
111 {
112 type: string
113 length: number
114 bitrate: number
115 sources: { uri: string, contentType?: string }[]
116 title: string
117 language?: string
118 } |
119 {
120 sources: { uri: string }[]
121 type: string
122 title: string
123 }
124
125async function generatePodcastItem (options: {
126 video: VideoModel
127 liveItem: boolean
128 media: PodcastMedia[]
129}) {
130 const { video, liveItem, media } = options
131
132 const customTags: CustomTag[] = await Hooks.wrapObject(
133 [],
134 'filter:feed.podcast.video.create-custom-tags.result',
135 { video, liveItem }
136 )
137
138 const account = video.VideoChannel.Account
139
140 const author = {
141 name: account.getDisplayName(),
142 href: account.getClientUrl()
143 }
144
145 const commonAttributes = getCommonVideoFeedAttributes(video)
146 const guid = liveItem
147 ? `${video.uuid}_${video.publishedAt.toISOString()}`
148 : commonAttributes.link
149
150 let personImage: string
151
152 if (account.Actor.hasImage(ActorImageType.AVATAR)) {
153 const avatar = getBiggestActorImage(account.Actor.Avatars)
154 personImage = WEBSERVER.URL + avatar.getStaticPath()
155 }
156
157 return {
158 guid,
159 ...commonAttributes,
160
161 trackers: video.getTrackerUrls(),
162
163 author: [ author ],
164 person: [
165 {
166 ...author,
167
168 img: personImage
169 }
170 ],
171
172 media,
173
174 socialInteract: [
175 {
176 uri: video.url,
177 protocol: 'activitypub',
178 accountUrl: account.getClientUrl()
179 }
180 ],
181
182 customTags
183 }
184}
185
186async function addVideosToPodcastFeed (feed: Feed, videos: VideoModel[]) {
187 const captionsGroup = await VideoCaptionModel.listCaptionsOfMultipleVideos(videos.map(v => v.id))
188
189 for (const video of videos) {
190 if (!video.isLive) {
191 await addVODPodcastItem({ feed, video, captionsGroup })
192 } else if (video.isLive && video.state !== VideoState.LIVE_ENDED) {
193 await addLivePodcastItem({ feed, video })
194 }
195 }
196}
197
198async function addVODPodcastItem (options: {
199 feed: Feed
200 video: VideoModel
201 captionsGroup: { [ id: number ]: MVideoCaptionVideo[] }
202}) {
203 const { feed, video, captionsGroup } = options
204
205 const webVideos = video.getFormattedWebVideoFilesJSON(true)
206 .map(f => buildVODWebVideoFile(video, f))
207 .sort(sortObjectComparator('bitrate', 'desc'))
208
209 const streamingPlaylistFiles = buildVODStreamingPlaylists(video)
210
211 // Order matters here, the first media URI will be the "default"
212 // So web videos are default if enabled
213 const media = [ ...webVideos, ...streamingPlaylistFiles ]
214
215 const videoCaptions = buildVODCaptions(video, captionsGroup[video.id])
216 const item = await generatePodcastItem({ video, liveItem: false, media })
217
218 feed.addPodcastItem({ ...item, subTitle: videoCaptions })
219}
220
221async function addLivePodcastItem (options: {
222 feed: Feed
223 video: VideoModel
224}) {
225 const { feed, video } = options
226
227 let status: LiveItemStatus
228
229 switch (video.state) {
230 case VideoState.WAITING_FOR_LIVE:
231 status = LiveItemStatus.pending
232 break
233 case VideoState.PUBLISHED:
234 status = LiveItemStatus.live
235 break
236 }
237
238 const item = await generatePodcastItem({ video, liveItem: true, media: buildLiveStreamingPlaylists(video) })
239
240 feed.addPodcastLiveItem({ ...item, status, start: video.updatedAt.toISOString() })
241}
242
243// ---------------------------------------------------------------------------
244
245function buildVODWebVideoFile (video: MVideo, videoFile: VideoFile) {
246 const isAudio = videoFile.resolution.id === VideoResolution.H_NOVIDEO
247 const type = isAudio
248 ? MIMETYPES.AUDIO.EXT_MIMETYPE[extname(videoFile.fileUrl)]
249 : MIMETYPES.VIDEO.EXT_MIMETYPE[extname(videoFile.fileUrl)]
250
251 const sources = [
252 { uri: videoFile.fileUrl },
253 { uri: videoFile.torrentUrl, contentType: 'application/x-bittorrent' }
254 ]
255
256 if (videoFile.magnetUri) {
257 sources.push({ uri: videoFile.magnetUri })
258 }
259
260 return {
261 type,
262 title: videoFile.resolution.label,
263 length: videoFile.size,
264 bitrate: videoFile.size / video.duration * 8,
265 language: video.language,
266 sources
267 }
268}
269
270function buildVODStreamingPlaylists (video: MVideoFullLight) {
271 const hls = video.getHLSPlaylist()
272 if (!hls) return []
273
274 return [
275 {
276 type: 'application/x-mpegURL',
277 title: 'HLS',
278 sources: [
279 { uri: hls.getMasterPlaylistUrl(video) }
280 ],
281 language: video.language
282 }
283 ]
284}
285
286function buildLiveStreamingPlaylists (video: MVideoFullLight) {
287 const hls = video.getHLSPlaylist()
288
289 return [
290 {
291 type: 'application/x-mpegURL',
292 title: `HLS live stream`,
293 sources: [
294 { uri: hls.getMasterPlaylistUrl(video) }
295 ],
296 language: video.language
297 }
298 ]
299}
300
301function buildVODCaptions (video: MVideo, videoCaptions: MVideoCaptionVideo[]) {
302 return videoCaptions.map(caption => {
303 const type = MIMETYPES.VIDEO_CAPTIONS.EXT_MIMETYPE[extname(caption.filename)]
304 if (!type) return null
305
306 return {
307 url: caption.getFileUrl(video),
308 language: caption.language,
309 type,
310 rel: 'captions'
311 }
312 }).filter(c => c)
313}
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-01 17:51:38 +0000