1 import express from 'express'
2 import { readFile } from 'fs-extra'
3 import { join } from 'path'
4 import validator from 'validator'
5 import { escapeHTML } from '@shared/core-utils/renderer'
6 import { HTMLServerConfig } from '@shared/models'
7 import { buildFileLocale, getDefaultLocale, is18nLocale, POSSIBLE_LOCALES } from '../../shared/core-utils/i18n/i18n'
8 import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
9 import { VideoPlaylistPrivacy, VideoPrivacy } from '../../shared/models/videos'
10 import { isTestInstance, sha256 } from '../helpers/core-utils'
11 import { logger } from '../helpers/logger'
12 import { mdToPlainText } from '../helpers/markdown'
13 import { CONFIG } from '../initializers/config'
17 CUSTOM_HTML_TAG_COMMENTS,
20 PLUGIN_GLOBAL_CSS_PATH,
22 } from '../initializers/constants'
23 import { AccountModel } from '../models/account/account'
24 import { getActivityStreamDuration } from '../models/video/formatter/video-format-utils'
25 import { VideoModel } from '../models/video/video'
26 import { VideoChannelModel } from '../models/video/video-channel'
27 import { VideoPlaylistModel } from '../models/video/video-playlist'
28 import { MAccountActor, MChannelActor } from '../types/models'
29 import { ServerConfigManager } from './server-config-manager'
30 import { toCompleteUUID } from '@server/helpers/custom-validators/misc'
34 twitterCard: 'player' | 'summary' | 'summary_large_image'
47 disallowIndexation?: boolean
65 private static htmlCache: { [path: string]: string } = {}
67 static invalidCache () {
68 logger.info('Cleaning HTML cache.')
70 ClientHtml.htmlCache = {}
73 static async getDefaultHTMLPage (req: express.Request, res: express.Response, paramLang?: string) {
74 const html = paramLang
75 ? await ClientHtml.getIndexHTML(req, res, paramLang)
76 : await ClientHtml.getIndexHTML(req, res)
78 let customHtml = ClientHtml.addTitleTag(html)
79 customHtml = ClientHtml.addDescriptionTag(customHtml)
84 static async getWatchHTMLPage (videoIdArg: string, req: express.Request, res: express.Response) {
85 const videoId = toCompleteUUID(videoIdArg)
87 // Let Angular application handle errors
88 if (!validator.isInt(videoId) && !validator.isUUID(videoId, 4)) {
89 res.status(HttpStatusCode.NOT_FOUND_404)
90 return ClientHtml.getIndexHTML(req, res)
93 const [ html, video ] = await Promise.all([
94 ClientHtml.getIndexHTML(req, res),
95 VideoModel.loadWithBlacklist(videoId)
98 // Let Angular application handle errors
99 if (!video || video.privacy === VideoPrivacy.PRIVATE || video.privacy === VideoPrivacy.INTERNAL || video.VideoBlacklist) {
100 res.status(HttpStatusCode.NOT_FOUND_404)
104 let customHtml = ClientHtml.addTitleTag(html, escapeHTML(video.name))
105 customHtml = ClientHtml.addDescriptionTag(customHtml, mdToPlainText(video.description))
107 const url = WEBSERVER.URL + video.getWatchStaticPath()
108 const originUrl = video.url
109 const title = escapeHTML(video.name)
110 const siteName = escapeHTML(CONFIG.INSTANCE.NAME)
111 const description = mdToPlainText(video.description)
114 url: WEBSERVER.URL + video.getPreviewStaticPath()
118 url: WEBSERVER.URL + video.getEmbedStaticPath(),
119 createdAt: video.createdAt.toISOString(),
120 duration: getActivityStreamDuration(video.duration),
124 const ogType = 'video'
125 const twitterCard = CONFIG.SERVICES.TWITTER.WHITELISTED ? 'player' : 'summary_large_image'
126 const schemaType = 'VideoObject'
128 customHtml = ClientHtml.addTags(customHtml, {
144 static async getWatchPlaylistHTMLPage (videoPlaylistIdArg: string, req: express.Request, res: express.Response) {
145 const videoPlaylistId = toCompleteUUID(videoPlaylistIdArg)
147 // Let Angular application handle errors
148 if (!validator.isInt(videoPlaylistId) && !validator.isUUID(videoPlaylistId, 4)) {
149 res.status(HttpStatusCode.NOT_FOUND_404)
150 return ClientHtml.getIndexHTML(req, res)
153 const [ html, videoPlaylist ] = await Promise.all([
154 ClientHtml.getIndexHTML(req, res),
155 VideoPlaylistModel.loadWithAccountAndChannel(videoPlaylistId, null)
158 // Let Angular application handle errors
159 if (!videoPlaylist || videoPlaylist.privacy === VideoPlaylistPrivacy.PRIVATE) {
160 res.status(HttpStatusCode.NOT_FOUND_404)
164 let customHtml = ClientHtml.addTitleTag(html, escapeHTML(videoPlaylist.name))
165 customHtml = ClientHtml.addDescriptionTag(customHtml, mdToPlainText(videoPlaylist.description))
167 const url = WEBSERVER.URL + videoPlaylist.getWatchStaticPath()
168 const originUrl = videoPlaylist.url
169 const title = escapeHTML(videoPlaylist.name)
170 const siteName = escapeHTML(CONFIG.INSTANCE.NAME)
171 const description = mdToPlainText(videoPlaylist.description)
174 url: videoPlaylist.getThumbnailUrl()
178 url: WEBSERVER.URL + videoPlaylist.getEmbedStaticPath(),
179 createdAt: videoPlaylist.createdAt.toISOString()
183 numberOfItems: videoPlaylist.get('videosLength') as number
186 const ogType = 'video'
187 const twitterCard = CONFIG.SERVICES.TWITTER.WHITELISTED ? 'player' : 'summary'
188 const schemaType = 'ItemList'
190 customHtml = ClientHtml.addTags(customHtml, {
207 static async getAccountHTMLPage (nameWithHost: string, req: express.Request, res: express.Response) {
208 const accountModelPromise = AccountModel.loadByNameWithHost(nameWithHost)
209 return this.getAccountOrChannelHTMLPage(() => accountModelPromise, req, res)
212 static async getVideoChannelHTMLPage (nameWithHost: string, req: express.Request, res: express.Response) {
213 const videoChannelModelPromise = VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithHost)
214 return this.getAccountOrChannelHTMLPage(() => videoChannelModelPromise, req, res)
217 static async getActorHTMLPage (nameWithHost: string, req: express.Request, res: express.Response) {
218 const [ account, channel ] = await Promise.all([
219 AccountModel.loadByNameWithHost(nameWithHost),
220 VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithHost)
223 return this.getAccountOrChannelHTMLPage(() => Promise.resolve(account || channel), req, res)
226 static async getEmbedHTML () {
227 const path = ClientHtml.getEmbedPath()
229 if (!isTestInstance() && ClientHtml.htmlCache[path]) return ClientHtml.htmlCache[path]
231 const buffer = await readFile(path)
232 const serverConfig = await ServerConfigManager.Instance.getHTMLServerConfig()
234 let html = buffer.toString()
235 html = await ClientHtml.addAsyncPluginCSS(html)
236 html = ClientHtml.addCustomCSS(html)
237 html = ClientHtml.addTitleTag(html)
238 html = ClientHtml.addDescriptionTag(html)
239 html = ClientHtml.addServerConfig(html, serverConfig)
241 ClientHtml.htmlCache[path] = html
246 private static async getAccountOrChannelHTMLPage (
247 loader: () => Promise<MAccountActor | MChannelActor>,
248 req: express.Request,
249 res: express.Response
251 const [ html, entity ] = await Promise.all([
252 ClientHtml.getIndexHTML(req, res),
256 // Let Angular application handle errors
258 res.status(HttpStatusCode.NOT_FOUND_404)
259 return ClientHtml.getIndexHTML(req, res)
262 let customHtml = ClientHtml.addTitleTag(html, escapeHTML(entity.getDisplayName()))
263 customHtml = ClientHtml.addDescriptionTag(customHtml, mdToPlainText(entity.description))
265 const url = entity.getLocalUrl()
266 const originUrl = entity.Actor.url
267 const siteName = escapeHTML(CONFIG.INSTANCE.NAME)
268 const title = escapeHTML(entity.getDisplayName())
269 const description = mdToPlainText(entity.description)
272 url: entity.Actor.getAvatarUrl(),
273 width: ACTOR_IMAGES_SIZE.AVATARS.width,
274 height: ACTOR_IMAGES_SIZE.AVATARS.height
277 const ogType = 'website'
278 const twitterCard = 'summary'
279 const schemaType = 'ProfilePage'
281 customHtml = ClientHtml.addTags(customHtml, {
291 disallowIndexation: !entity.Actor.isOwned()
297 private static async getIndexHTML (req: express.Request, res: express.Response, paramLang?: string) {
298 const path = ClientHtml.getIndexPath(req, res, paramLang)
299 if (!isTestInstance() && ClientHtml.htmlCache[path]) return ClientHtml.htmlCache[path]
301 const buffer = await readFile(path)
302 const serverConfig = await ServerConfigManager.Instance.getHTMLServerConfig()
304 let html = buffer.toString()
306 html = ClientHtml.addManifestContentHash(html)
307 html = ClientHtml.addFaviconContentHash(html)
308 html = ClientHtml.addLogoContentHash(html)
309 html = ClientHtml.addCustomCSS(html)
310 html = ClientHtml.addServerConfig(html, serverConfig)
311 html = await ClientHtml.addAsyncPluginCSS(html)
313 ClientHtml.htmlCache[path] = html
318 private static getIndexPath (req: express.Request, res: express.Response, paramLang: string) {
321 // Check param lang validity
322 if (paramLang && is18nLocale(paramLang)) {
325 // Save locale in cookies
326 res.cookie('clientLanguage', lang, {
327 secure: WEBSERVER.SCHEME === 'https',
329 maxAge: 1000 * 3600 * 24 * 90 // 3 months
332 } else if (req.cookies.clientLanguage && is18nLocale(req.cookies.clientLanguage)) {
333 lang = req.cookies.clientLanguage
335 lang = req.acceptsLanguages(POSSIBLE_LOCALES) || getDefaultLocale()
338 return join(__dirname, '../../../client/dist/' + buildFileLocale(lang) + '/index.html')
341 private static getEmbedPath () {
342 return join(__dirname, '../../../client/dist/standalone/videos/embed.html')
345 private static addHtmlLang (htmlStringPage: string, paramLang: string) {
346 return htmlStringPage.replace('<html>', `<html lang="${paramLang}">`)
349 private static addManifestContentHash (htmlStringPage: string) {
350 return htmlStringPage.replace('[manifestContentHash]', FILES_CONTENT_HASH.MANIFEST)
353 private static addFaviconContentHash (htmlStringPage: string) {
354 return htmlStringPage.replace('[faviconContentHash]', FILES_CONTENT_HASH.FAVICON)
357 private static addLogoContentHash (htmlStringPage: string) {
358 return htmlStringPage.replace('[logoContentHash]', FILES_CONTENT_HASH.LOGO)
361 private static addTitleTag (htmlStringPage: string, title?: string) {
362 let text = title || CONFIG.INSTANCE.NAME
363 if (title) text += ` - ${CONFIG.INSTANCE.NAME}`
365 const titleTag = `<title>${text}</title>`
367 return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.TITLE, titleTag)
370 private static addDescriptionTag (htmlStringPage: string, description?: string) {
371 const content = description || CONFIG.INSTANCE.SHORT_DESCRIPTION
372 const descriptionTag = `<meta name="description" content="${content}" />`
374 return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.DESCRIPTION, descriptionTag)
377 private static addCustomCSS (htmlStringPage: string) {
378 const styleTag = `<style class="custom-css-style">${CONFIG.INSTANCE.CUSTOMIZATIONS.CSS}</style>`
380 return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.CUSTOM_CSS, styleTag)
383 private static addServerConfig (htmlStringPage: string, serverConfig: HTMLServerConfig) {
384 // Stringify the JSON object, and then stringify the string object so we can inject it into the HTML
385 const serverConfigString = JSON.stringify(JSON.stringify(serverConfig))
386 const configScriptTag = `<script type="application/javascript">window.PeerTubeServerConfig = ${serverConfigString}</script>`
388 return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.SERVER_CONFIG, configScriptTag)
391 private static async addAsyncPluginCSS (htmlStringPage: string) {
392 const globalCSSContent = await readFile(PLUGIN_GLOBAL_CSS_PATH)
393 if (globalCSSContent.byteLength === 0) return htmlStringPage
395 const fileHash = sha256(globalCSSContent)
396 const linkTag = `<link rel="stylesheet" href="/plugins/global.css?hash=${fileHash}" />`
398 return htmlStringPage.replace('</head>', linkTag + '</head>')
401 private static generateOpenGraphMetaTags (tags: Tags) {
403 'og:type': tags.ogType,
404 'og:site_name': tags.siteName,
405 'og:title': tags.title,
406 'og:image': tags.image.url
409 if (tags.image.width && tags.image.height) {
410 metaTags['og:image:width'] = tags.image.width
411 metaTags['og:image:height'] = tags.image.height
414 metaTags['og:url'] = tags.url
415 metaTags['og:description'] = mdToPlainText(tags.description)
418 metaTags['og:video:url'] = tags.embed.url
419 metaTags['og:video:secure_url'] = tags.embed.url
420 metaTags['og:video:type'] = 'text/html'
421 metaTags['og:video:width'] = EMBED_SIZE.width
422 metaTags['og:video:height'] = EMBED_SIZE.height
428 private static generateStandardMetaTags (tags: Tags) {
431 description: mdToPlainText(tags.description),
432 image: tags.image.url
436 private static generateTwitterCardMetaTags (tags: Tags) {
438 'twitter:card': tags.twitterCard,
439 'twitter:site': CONFIG.SERVICES.TWITTER.USERNAME,
440 'twitter:title': tags.title,
441 'twitter:description': tags.description,
442 'twitter:image': tags.image.url
445 if (tags.image.width && tags.image.height) {
446 metaTags['twitter:image:width'] = tags.image.width
447 metaTags['twitter:image:height'] = tags.image.height
450 if (tags.twitterCard === 'player') {
451 metaTags['twitter:player'] = tags.embed.url
452 metaTags['twitter:player:width'] = EMBED_SIZE.width
453 metaTags['twitter:player:height'] = EMBED_SIZE.height
459 private static generateSchemaTags (tags: Tags) {
461 '@context': 'http://schema.org',
462 '@type': tags.schemaType,
464 'description': tags.description,
465 'image': tags.image.url,
470 schema['numberOfItems'] = tags.list.numberOfItems
471 schema['thumbnailUrl'] = tags.image.url
475 schema['embedUrl'] = tags.embed.url
476 schema['uploadDate'] = tags.embed.createdAt
478 if (tags.embed.duration) schema['duration'] = tags.embed.duration
479 if (tags.embed.views) schema['iterationCount'] = tags.embed.views
481 schema['thumbnailUrl'] = tags.image.url
482 schema['contentUrl'] = tags.url
488 private static addTags (htmlStringPage: string, tagsValues: Tags) {
489 const openGraphMetaTags = this.generateOpenGraphMetaTags(tagsValues)
490 const standardMetaTags = this.generateStandardMetaTags(tagsValues)
491 const twitterCardMetaTags = this.generateTwitterCardMetaTags(tagsValues)
492 const schemaTags = this.generateSchemaTags(tagsValues)
494 const { url, title, embed, originUrl, disallowIndexation } = tagsValues
496 const oembedLinkTags: { type: string, href: string, title: string }[] = []
499 oembedLinkTags.push({
500 type: 'application/json+oembed',
501 href: WEBSERVER.URL + '/services/oembed?url=' + encodeURIComponent(url),
509 Object.keys(openGraphMetaTags).forEach(tagName => {
510 const tagValue = openGraphMetaTags[tagName]
512 tagsString += `<meta property="${tagName}" content="${tagValue}" />`
516 Object.keys(standardMetaTags).forEach(tagName => {
517 const tagValue = standardMetaTags[tagName]
519 tagsString += `<meta property="${tagName}" content="${tagValue}" />`
523 Object.keys(twitterCardMetaTags).forEach(tagName => {
524 const tagValue = twitterCardMetaTags[tagName]
526 tagsString += `<meta property="${tagName}" content="${tagValue}" />`
530 for (const oembedLinkTag of oembedLinkTags) {
531 tagsString += `<link rel="alternate" type="${oembedLinkTag.type}" href="${oembedLinkTag.href}" title="${oembedLinkTag.title}" />`
536 tagsString += `<script type="application/ld+json">${JSON.stringify(schemaTags)}</script>`
539 // SEO, use origin URL
540 tagsString += `<link rel="canonical" href="${originUrl}" />`
542 if (disallowIndexation) {
543 tagsString += `<meta name="robots" content="noindex" />`
546 return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.META_TAGS, tagsString)
550 function sendHTML (html: string, res: express.Response) {
551 res.set('Content-Type', 'text/html; charset=UTF-8')
553 return res.send(html)
556 async function serveIndexHTML (req: express.Request, res: express.Response) {
557 if (req.accepts(ACCEPT_HEADERS) === 'html' || !req.headers.accept) {
559 await generateHTMLPage(req, res, req.params.language)
562 logger.error('Cannot generate HTML page.', err)
563 return res.status(HttpStatusCode.INTERNAL_SERVER_ERROR_500).end()
567 return res.status(HttpStatusCode.NOT_ACCEPTABLE_406).end()
570 // ---------------------------------------------------------------------------
578 async function generateHTMLPage (req: express.Request, res: express.Response, paramLang?: string) {
579 const html = await ClientHtml.getDefaultHTMLPage(req, res, paramLang)
581 return sendHTML(html, res)