Plugins can update video constants

Categories, licences and languages

server/lib/plugins/plugin-manager.ts

@@ -5,7 +5,7 @@ import { CONFIG } from '../../initializers/config'
 import { isLibraryCodeValid, isPackageJSONValid } from '../../helpers/custom-validators/plugins'
 import { ClientScript, PluginPackageJson } from '../../../shared/models/plugins/plugin-package-json.model'
 import { createReadStream, createWriteStream } from 'fs'
-import { PLUGIN_GLOBAL_CSS_PATH } from '../../initializers/constants'
+import { PLUGIN_GLOBAL_CSS_PATH, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES } from '../../initializers/constants'
 import { PluginType } from '../../../shared/models/plugins/plugin.type'
 import { installNpmPlugin, installNpmPluginFromDisk, removeNpmPlugin } from './yarn'
 import { outputFile, readJSON } from 'fs-extra'
@@ -18,6 +18,9 @@ import { PluginLibrary } from '../../typings/plugins'
 import { ClientHtml } from '../client-html'
 import { RegisterServerHookOptions } from '../../../shared/models/plugins/register-server-hook.model'
 import { RegisterServerSettingOptions } from '../../../shared/models/plugins/register-server-setting.model'
+import { PluginVideoLanguageManager } from '../../../shared/models/plugins/plugin-video-language-manager.model'
+import { PluginVideoCategoryManager } from '../../../shared/models/plugins/plugin-video-category-manager.model'
+import { PluginVideoLicenceManager } from '../../../shared/models/plugins/plugin-video-licence-manager.model'
 
 export interface RegisteredPlugin {
   npmName: string
@@ -46,6 +49,17 @@ export interface HookInformationValue {
   priority: number
 }
 
+type AlterableVideoConstant = 'language' | 'licence' | 'category'
+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 PluginManager implements ServerHook {
 
   private static instance: PluginManager
@@ -54,6 +68,12 @@ export class PluginManager implements ServerHook {
   private settings: { [ name: string ]: RegisterServerSettingOptions[] } = {}
   private hooks: { [ name: string ]: HookInformationValue[] } = {}
 
+  private updatedVideoConstants: UpdatedVideoConstant = {
+    language: {},
+    licence: {},
+    category: {}
+  }
+
   private constructor () {
   }
 
@@ -161,6 +181,8 @@ export class PluginManager implements ServerHook {
         this.hooks[key] = this.hooks[key].filter(h => h.pluginName !== npmName)
       }
 
+      this.reinitVideoConstants(plugin.npmName)
+
       logger.info('Regenerating registered plugin CSS to global file.')
       await this.regeneratePluginGlobalCSS()
     }
@@ -427,6 +449,24 @@ export class PluginManager implements ServerHook {
       storeData: (key: string, data: any) => PluginModel.storeData(plugin.name, plugin.type, key, data)
     }
 
+    const videoLanguageManager: PluginVideoLanguageManager = {
+      addLanguage: (key: string, label: string) => this.addConstant({ npmName, type: 'language', obj: VIDEO_LANGUAGES, key, label }),
+
+      deleteLanguage: (key: string) => this.deleteConstant({ npmName, type: 'language', obj: VIDEO_LANGUAGES, key })
+    }
+
+    const videoCategoryManager: PluginVideoCategoryManager= {
+      addCategory: (key: number, label: string) => this.addConstant({ npmName, type: 'category', obj: VIDEO_CATEGORIES, key, label }),
+
+      deleteCategory: (key: number) => this.deleteConstant({ npmName, type: 'category', obj: VIDEO_CATEGORIES, key })
+    }
+
+    const videoLicenceManager: PluginVideoLicenceManager = {
+      addLicence: (key: number, label: string) => this.addConstant({ npmName, type: 'licence', obj: VIDEO_LICENCES, key, label }),
+
+      deleteLicence: (key: number) => this.deleteConstant({ npmName, type: 'licence', obj: VIDEO_LICENCES, key })
+    }
+
     const peertubeHelpers = {
       logger
     }
@@ -436,10 +476,90 @@ export class PluginManager implements ServerHook {
       registerSetting,
       settingsManager,
       storageManager,
+      videoLanguageManager,
+      videoCategoryManager,
+      videoLicenceManager,
       peertubeHelpers
     }
   }
 
+  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 %s by plugin %s: key does not exist.', type, npmName, key)
+      return false
+    }
+
+    if (!this.updatedVideoConstants[type][npmName]) {
+      this.updatedVideoConstants[type][npmName] = {
+        added: [],
+        deleted: []
+      }
+    }
+
+    this.updatedVideoConstants[type][npmName].deleted.push({ key, label: obj[key] })
+    delete obj[key]
+
+    return true
+  }
+
+  private reinitVideoConstants (npmName: string) {
+    const hash = {
+      language: VIDEO_LANGUAGES,
+      licence: VIDEO_LICENCES,
+      category: VIDEO_CATEGORIES
+    }
+    const types: AlterableVideoConstant[] = [ 'language', 'licence', 'category' ]
+
+    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]
+    }
+  }
+
   static get Instance () {
     return this.instance || (this.instance = new this())
   }

server/tests/fixtures/peertube-plugin-test-three/main.js

@@ -0,0 +1,39 @@
+async function register ({
+  registerHook,
+  registerSetting,
+  settingsManager,
+  storageManager,
+  videoCategoryManager,
+  videoLicenceManager,
+  videoLanguageManager
+}) {
+  videoLanguageManager.addLanguage('al_bhed', 'Al Bhed')
+  videoLanguageManager.addLanguage('al_bhed2', 'Al Bhed 2')
+  videoLanguageManager.deleteLanguage('en')
+  videoLanguageManager.deleteLanguage('fr')
+
+  videoCategoryManager.addCategory(42, 'Best category')
+  videoCategoryManager.addCategory(43, 'High best category')
+  videoCategoryManager.deleteCategory(1) // Music
+  videoCategoryManager.deleteCategory(2) // Films
+
+  videoLicenceManager.addLicence(42, 'Best licence')
+  videoLicenceManager.addLicence(43, 'High best licence')
+  videoLicenceManager.deleteLicence(1) // Attribution
+  videoLicenceManager.deleteLicence(7) // Public domain
+}
+
+async function unregister () {
+  return
+}
+
+module.exports = {
+  register,
+  unregister
+}
+
+// ############################################################################
+
+function addToCount (obj) {
+  return Object.assign({}, obj, { count: obj.count + 1 })
+}

server/tests/fixtures/peertube-plugin-test-three/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "peertube-plugin-test-three",
+  "version": "0.0.1",
+  "description": "Plugin test 3",
+  "engine": {
+    "peertube": ">=1.3.0"
+  },
+  "keywords": [
+    "peertube",
+    "plugin"
+  ],
+  "homepage": "https://github.com/Chocobozzz/PeerTube",
+  "author": "Chocobozzz",
+  "bugs": "https://github.com/Chocobozzz/PeerTube/issues",
+  "library": "./main.js",
+  "staticDirs": {},
+  "css": [],
+  "clientScripts": []
+}

server/tests/plugins/index.ts

@@ -1,2 +1,3 @@
 import './action-hooks'
 import './filter-hooks'
+import './video-constants'

server/tests/plugins/video-constants.ts

@@ -0,0 +1,140 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  cleanupTests,
+  flushAndRunMultipleServers,
+  flushAndRunServer, killallServers, reRunServer,
+  ServerInfo,
+  waitUntilLog
+} from '../../../shared/extra-utils/server/servers'
+import {
+  addVideoCommentReply,
+  addVideoCommentThread,
+  deleteVideoComment,
+  getPluginTestPath,
+  getVideosList,
+  installPlugin,
+  removeVideo,
+  setAccessTokensToServers,
+  updateVideo,
+  uploadVideo,
+  viewVideo,
+  getVideosListPagination,
+  getVideo,
+  getVideoCommentThreads,
+  getVideoThreadComments,
+  getVideoWithToken,
+  setDefaultVideoChannel,
+  waitJobs,
+  doubleFollow, getVideoLanguages, getVideoLicences, getVideoCategories, uninstallPlugin
+} from '../../../shared/extra-utils'
+import { VideoCommentThreadTree } from '../../../shared/models/videos/video-comment.model'
+import { VideoDetails } from '../../../shared/models/videos'
+import { getYoutubeVideoUrl, importVideo } from '../../../shared/extra-utils/videos/video-imports'
+
+const expect = chai.expect
+
+describe('Test plugin altering video constants', function () {
+  let server: ServerInfo
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await flushAndRunServer(1)
+    await setAccessTokensToServers([ server ])
+
+    await installPlugin({
+      url: server.url,
+      accessToken: server.accessToken,
+      path: getPluginTestPath('-three')
+    })
+  })
+
+  it('Should have updated languages', async function () {
+    const res = await getVideoLanguages(server.url)
+    const languages = res.body
+
+    expect(languages['en']).to.not.exist
+    expect(languages['fr']).to.not.exist
+
+    expect(languages['al_bhed']).to.equal('Al Bhed')
+    expect(languages['al_bhed2']).to.equal('Al Bhed 2')
+  })
+
+  it('Should have updated categories', async function () {
+    const res = await getVideoCategories(server.url)
+    const categories = res.body
+
+    expect(categories[1]).to.not.exist
+    expect(categories[2]).to.not.exist
+
+    expect(categories[42]).to.equal('Best category')
+    expect(categories[43]).to.equal('High best category')
+  })
+
+  it('Should have updated licences', async function () {
+    const res = await getVideoLicences(server.url)
+    const licences = res.body
+
+    expect(licences[1]).to.not.exist
+    expect(licences[7]).to.not.exist
+
+    expect(licences[42]).to.equal('Best licence')
+    expect(licences[43]).to.equal('High best licence')
+  })
+
+  it('Should be able to upload a video with these values', async function () {
+    const attrs = { name: 'video', category: 42, licence: 42, language: 'al_bhed2' }
+    const resUpload = await uploadVideo(server.url, server.accessToken, attrs)
+
+    const res = await getVideo(server.url, resUpload.body.video.uuid)
+
+    const video: VideoDetails = res.body
+    expect(video.language.label).to.equal('Al Bhed 2')
+    expect(video.licence.label).to.equal('Best licence')
+    expect(video.category.label).to.equal('Best category')
+  })
+
+  it('Should uninstall the plugin and reset languages, categories and licences', async function () {
+    await uninstallPlugin({ url: server.url, accessToken: server.accessToken, npmName: 'peertube-plugin-test-three' })
+
+    {
+      const res = await getVideoLanguages(server.url)
+      const languages = res.body
+
+      expect(languages[ 'en' ]).to.equal('English')
+      expect(languages[ 'fr' ]).to.equal('French')
+
+      expect(languages[ 'al_bhed' ]).to.not.exist
+      expect(languages[ 'al_bhed2' ]).to.not.exist
+    }
+
+    {
+      const res = await getVideoCategories(server.url)
+      const categories = res.body
+
+      expect(categories[ 1 ]).to.equal('Music')
+      expect(categories[ 2 ]).to.equal('Films')
+
+      expect(categories[ 42 ]).to.not.exist
+      expect(categories[ 43 ]).to.not.exist
+    }
+
+    {
+      const res = await getVideoLicences(server.url)
+      const licences = res.body
+
+      expect(licences[ 1 ]).to.equal('Attribution')
+      expect(licences[ 7 ]).to.equal('Public Domain Dedication')
+
+      expect(licences[ 42 ]).to.not.exist
+      expect(licences[ 43 ]).to.not.exist
+    }
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})

server/typings/plugins/register-server-option.model.ts

@@ -3,6 +3,9 @@ import { PluginSettingsManager } from '../../../shared/models/plugins/plugin-set
 import { PluginStorageManager } from '../../../shared/models/plugins/plugin-storage-manager.model'
 import { RegisterServerHookOptions } from '../../../shared/models/plugins/register-server-hook.model'
 import { RegisterServerSettingOptions } from '../../../shared/models/plugins/register-server-setting.model'
+import { PluginVideoCategoryManager } from '../../../shared/models/plugins/plugin-video-category-manager.model'
+import { PluginVideoLanguageManager } from '../../../shared/models/plugins/plugin-video-language-manager.model'
+import { PluginVideoLicenceManager } from '../../../shared/models/plugins/plugin-video-licence-manager.model'
 
 export type RegisterServerOptions = {
   registerHook: (options: RegisterServerHookOptions) => void
@@ -13,6 +16,10 @@ export type RegisterServerOptions = {
 
   storageManager: PluginStorageManager
 
+  videoCategoryManager: PluginVideoCategoryManager
+  videoLanguageManager: PluginVideoLanguageManager
+  videoLicenceManager: PluginVideoLicenceManager
+
   peertubeHelpers: {
     logger: typeof logger
   }

shared/models/plugins/plugin-video-category-manager.model.ts

@@ -0,0 +1,5 @@
+export interface PluginVideoCategoryManager {
+  addCategory: (categoryKey: number, categoryLabel: string) => boolean
+
+  deleteCategory: (categoryKey: number) => boolean
+}

shared/models/plugins/plugin-video-language-manager.model.ts

@@ -0,0 +1,5 @@
+export interface PluginVideoLanguageManager {
+  addLanguage: (languageKey: string, languageLabel: string) => boolean
+
+  deleteLanguage: (languageKey: string) => boolean
+}

shared/models/plugins/plugin-video-licence-manager.model.ts

@@ -0,0 +1,5 @@
+export interface PluginVideoLicenceManager {
+  addLicence: (licenceKey: number, licenceLabel: string) => boolean
+
+  deleteLicence: (licenceKey: number) => boolean
+}