-import * as express from 'express'
+import express from 'express'
+import { Server } from 'http'
import { logger } from '@server/helpers/logger'
-import {
- VIDEO_CATEGORIES,
- VIDEO_LANGUAGES,
- VIDEO_LICENCES,
- VIDEO_PLAYLIST_PRIVACIES,
- VIDEO_PRIVACIES
-} from '@server/initializers/constants'
import { onExternalUserAuthenticated } from '@server/lib/auth/external-auth'
+import { VideoConstantManagerFactory } from '@server/lib/plugins/video-constant-manager-factory'
import { PluginModel } from '@server/models/server/plugin'
import {
RegisterServerAuthExternalOptions,
RegisterServerAuthExternalResult,
RegisterServerAuthPassOptions,
RegisterServerExternalAuthenticatedResult,
- RegisterServerOptions
+ RegisterServerOptions,
+ RegisterServerWebSocketRouteOptions
} from '@server/types/plugins'
import {
EncoderOptionsBuilder,
- PluginPlaylistPrivacyManager,
PluginSettingsManager,
PluginStorageManager,
- PluginVideoCategoryManager,
- PluginVideoLanguageManager,
- PluginVideoLicenceManager,
- PluginVideoPrivacyManager,
RegisterServerHookOptions,
RegisterServerSettingOptions,
- serverHookObject
+ serverHookObject,
+ SettingsChangeCallback,
+ VideoPlaylistPrivacy,
+ VideoPrivacy
} from '@shared/models'
-import { VideoTranscodingProfilesManager } from '../transcoding/video-transcoding-profiles'
+import { VideoTranscodingProfilesManager } from '../transcoding/default-transcoding-profiles'
import { buildPluginHelpers } from './plugin-helpers-builder'
-type AlterableVideoConstant = 'language' | 'licence' | 'category' | 'privacy' | 'playlistPrivacy'
-type VideoConstant = { [key in number | string]: string }
-
-type UpdatedVideoConstant = {
- [name in AlterableVideoConstant]: {
- [ npmName: string]: {
- added: { key: number | string, label: string }[]
- deleted: { key: number | string, label: string }[]
- }
- }
-}
-
export class RegisterHelpers {
- private readonly updatedVideoConstants: UpdatedVideoConstant = {
- playlistPrivacy: { },
- privacy: { },
- language: { },
- licence: { },
- category: { }
- }
-
private readonly transcodingProfiles: {
[ npmName: string ]: {
type: 'vod' | 'live'
private idAndPassAuths: RegisterServerAuthPassOptions[] = []
private externalAuths: RegisterServerAuthExternalOptions[] = []
- private readonly onSettingsChangeCallbacks: ((settings: any) => Promise<any>)[] = []
+ private readonly onSettingsChangeCallbacks: SettingsChangeCallback[] = []
+
+ private readonly webSocketRoutes: RegisterServerWebSocketRouteOptions[] = []
private readonly router: express.Router
+ private readonly videoConstantManagerFactory: VideoConstantManagerFactory
constructor (
private readonly npmName: string,
private readonly plugin: PluginModel,
+ private readonly server: Server,
private readonly onHookAdded: (options: RegisterServerHookOptions) => void
) {
this.router = express.Router()
+ this.videoConstantManagerFactory = new VideoConstantManagerFactory(this.npmName)
}
buildRegisterHelpers (): RegisterServerOptions {
const registerSetting = this.buildRegisterSetting()
const getRouter = this.buildGetRouter()
+ const registerWebSocketRoute = this.buildRegisterWebSocketRoute()
const settingsManager = this.buildSettingsManager()
const storageManager = this.buildStorageManager()
- const videoLanguageManager = this.buildVideoLanguageManager()
+ const videoLanguageManager = this.videoConstantManagerFactory.createVideoConstantManager<string>('language')
- const videoLicenceManager = this.buildVideoLicenceManager()
- const videoCategoryManager = this.buildVideoCategoryManager()
+ const videoLicenceManager = this.videoConstantManagerFactory.createVideoConstantManager<number>('licence')
+ const videoCategoryManager = this.videoConstantManagerFactory.createVideoConstantManager<number>('category')
- const videoPrivacyManager = this.buildVideoPrivacyManager()
- const playlistPrivacyManager = this.buildPlaylistPrivacyManager()
+ const videoPrivacyManager = this.videoConstantManagerFactory.createVideoConstantManager<VideoPrivacy>('privacy')
+ const playlistPrivacyManager = this.videoConstantManagerFactory.createVideoConstantManager<VideoPlaylistPrivacy>('playlistPrivacy')
const transcodingManager = this.buildTranscodingManager()
const unregisterIdAndPassAuth = this.buildUnregisterIdAndPassAuth()
const unregisterExternalAuth = this.buildUnregisterExternalAuth()
- const peertubeHelpers = buildPluginHelpers(this.plugin, this.npmName)
+ const peertubeHelpers = buildPluginHelpers(this.server, this.plugin, this.npmName)
return {
registerHook,
registerSetting,
getRouter,
+ registerWebSocketRoute,
settingsManager,
storageManager,
- videoLanguageManager,
- videoCategoryManager,
- videoLicenceManager,
+ videoLanguageManager: {
+ ...videoLanguageManager,
+ /** @deprecated use `addConstant` instead **/
+ addLanguage: videoLanguageManager.addConstant,
+ /** @deprecated use `deleteConstant` instead **/
+ deleteLanguage: videoLanguageManager.deleteConstant
+ },
+ videoCategoryManager: {
+ ...videoCategoryManager,
+ /** @deprecated use `addConstant` instead **/
+ addCategory: videoCategoryManager.addConstant,
+ /** @deprecated use `deleteConstant` instead **/
+ deleteCategory: videoCategoryManager.deleteConstant
+ },
+ videoLicenceManager: {
+ ...videoLicenceManager,
+ /** @deprecated use `addConstant` instead **/
+ addLicence: videoLicenceManager.addConstant,
+ /** @deprecated use `deleteConstant` instead **/
+ deleteLicence: videoLicenceManager.deleteConstant
+ },
- videoPrivacyManager,
- playlistPrivacyManager,
+ videoPrivacyManager: {
+ ...videoPrivacyManager,
+ /** @deprecated use `deleteConstant` instead **/
+ deletePrivacy: videoPrivacyManager.deleteConstant
+ },
+ playlistPrivacyManager: {
+ ...playlistPrivacyManager,
+ /** @deprecated use `deleteConstant` instead **/
+ deletePlaylistPrivacy: playlistPrivacyManager.deleteConstant
+ },
transcodingManager,
}
reinitVideoConstants (npmName: string) {
- const hash = {
- language: VIDEO_LANGUAGES,
- licence: VIDEO_LICENCES,
- category: VIDEO_CATEGORIES,
- privacy: VIDEO_PRIVACIES,
- playlistPrivacy: VIDEO_PLAYLIST_PRIVACIES
- }
- const types: AlterableVideoConstant[] = [ 'language', 'licence', 'category', 'privacy', 'playlistPrivacy' ]
-
- for (const type of types) {
- const updatedConstants = this.updatedVideoConstants[type][npmName]
- if (!updatedConstants) continue
-
- for (const added of updatedConstants.added) {
- delete hash[type][added.key]
- }
-
- for (const deleted of updatedConstants.deleted) {
- hash[type][deleted.key] = deleted.label
- }
-
- delete this.updatedVideoConstants[type][npmName]
- }
+ this.videoConstantManagerFactory.resetVideoConstants(npmName)
}
reinitTranscodingProfilesAndEncoders (npmName: string) {
return this.onSettingsChangeCallbacks
}
+ getWebSocketRoutes () {
+ return this.webSocketRoutes
+ }
+
private buildGetRouter () {
return () => this.router
}
+ private buildRegisterWebSocketRoute () {
+ return (options: RegisterServerWebSocketRouteOptions) => {
+ this.webSocketRoutes.push(options)
+ }
+ }
+
private buildRegisterSetting () {
return (options: RegisterServerSettingOptions) => {
this.settings.push(options)
setSetting: (name: string, value: string) => PluginModel.setSetting(this.plugin.name, this.plugin.type, name, value),
- onSettingsChange: (cb: (settings: any) => Promise<any>) => this.onSettingsChangeCallbacks.push(cb)
+ onSettingsChange: (cb: SettingsChangeCallback) => this.onSettingsChangeCallbacks.push(cb)
}
}
}
}
- private buildVideoLanguageManager (): PluginVideoLanguageManager {
- return {
- addLanguage: (key: string, label: string) => {
- return this.addConstant({ npmName: this.npmName, type: 'language', obj: VIDEO_LANGUAGES, key, label })
- },
-
- deleteLanguage: (key: string) => {
- return this.deleteConstant({ npmName: this.npmName, type: 'language', obj: VIDEO_LANGUAGES, key })
- }
- }
- }
-
- private buildVideoCategoryManager (): PluginVideoCategoryManager {
- return {
- addCategory: (key: number, label: string) => {
- return this.addConstant({ npmName: this.npmName, type: 'category', obj: VIDEO_CATEGORIES, key, label })
- },
-
- deleteCategory: (key: number) => {
- return this.deleteConstant({ npmName: this.npmName, type: 'category', obj: VIDEO_CATEGORIES, key })
- }
- }
- }
-
- private buildVideoPrivacyManager (): PluginVideoPrivacyManager {
- return {
- deletePrivacy: (key: number) => {
- return this.deleteConstant({ npmName: this.npmName, type: 'privacy', obj: VIDEO_PRIVACIES, key })
- }
- }
- }
-
- private buildPlaylistPrivacyManager (): PluginPlaylistPrivacyManager {
- return {
- deletePlaylistPrivacy: (key: number) => {
- return this.deleteConstant({ npmName: this.npmName, type: 'playlistPrivacy', obj: VIDEO_PLAYLIST_PRIVACIES, key })
- }
- }
- }
-
- private buildVideoLicenceManager (): PluginVideoLicenceManager {
- return {
- addLicence: (key: number, label: string) => {
- return this.addConstant({ npmName: this.npmName, type: 'licence', obj: VIDEO_LICENCES, key, label })
- },
-
- deleteLicence: (key: number) => {
- return this.deleteConstant({ npmName: this.npmName, type: 'licence', obj: VIDEO_LICENCES, key })
- }
- }
- }
-
- private addConstant<T extends string | number> (parameters: {
- npmName: string
- type: AlterableVideoConstant
- obj: VideoConstant
- key: T
- label: string
- }) {
- const { npmName, type, obj, key, label } = parameters
-
- if (obj[key]) {
- logger.warn('Cannot add %s %s by plugin %s: key already exists.', type, npmName, key)
- return false
- }
-
- if (!this.updatedVideoConstants[type][npmName]) {
- this.updatedVideoConstants[type][npmName] = {
- added: [],
- deleted: []
- }
- }
-
- this.updatedVideoConstants[type][npmName].added.push({ key, label })
- obj[key] = label
-
- return true
- }
-
- private deleteConstant<T extends string | number> (parameters: {
- npmName: string
- type: AlterableVideoConstant
- obj: VideoConstant
- key: T
- }) {
- const { npmName, type, obj, key } = parameters
-
- if (!obj[key]) {
- logger.warn('Cannot delete %s by plugin %s: key %s does not exist.', type, npmName, key)
- return false
- }
-
- if (!this.updatedVideoConstants[type][npmName]) {
- this.updatedVideoConstants[type][npmName] = {
- added: [],
- deleted: []
- }
- }
-
- const updatedConstants = this.updatedVideoConstants[type][npmName]
-
- const alreadyAdded = updatedConstants.added.find(a => a.key === key)
- if (alreadyAdded) {
- updatedConstants.added.filter(a => a.key !== key)
- } else if (obj[key]) {
- updatedConstants.deleted.push({ key, label: obj[key] })
- }
-
- delete obj[key]
-
- return true
- }
-
private buildTranscodingManager () {
const self = this
projects / github / Chocobozzz / PeerTube.git / blobdiff