server/controllers/api/config.ts

   1 import * as express from 'express'
   2 import { snakeCase } from 'lodash'
   3 import { ServerConfig, UserRight } from '../../../shared'
   4 import { About } from '../../../shared/models/server/about.model'
   5 import { CustomConfig } from '../../../shared/models/server/custom-config.model'
   6 import { isSignupAllowed, isSignupAllowedForCurrentIP } from '../../helpers/signup'
   7 import { CONSTRAINTS_FIELDS, DEFAULT_THEME_NAME, PEERTUBE_VERSION } from '../../initializers/constants'
   8 import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../middlewares'
   9 import { customConfigUpdateValidator } from '../../middlewares/validators/config'
  10 import { ClientHtml } from '../../lib/client-html'
  11 import { auditLoggerFactory, CustomConfigAuditView, getAuditIdFromRes } from '../../helpers/audit-logger'
  12 import { remove, writeJSON } from 'fs-extra'
  13 import { getServerCommit } from '../../helpers/utils'
  14 import { Emailer } from '../../lib/emailer'
  15 import validator from 'validator'
  16 import { objectConverter } from '../../helpers/core-utils'
  17 import { CONFIG, reloadConfig } from '../../initializers/config'
  18 import { PluginManager } from '../../lib/plugins/plugin-manager'
  19 import { getThemeOrDefault } from '../../lib/plugins/theme-utils'
  20 import { Hooks } from '@server/lib/plugins/hooks'
  21
  22 const configRouter = express.Router()
  23
  24 const auditLogger = auditLoggerFactory('config')
  25
  26 configRouter.get('/about', getAbout)
  27 configRouter.get('/',
  28   asyncMiddleware(getConfig)
  29 )
  30
  31 configRouter.get('/custom',
  32   authenticate,
  33   ensureUserHasRight(UserRight.MANAGE_CONFIGURATION),
  34   getCustomConfig
  35 )
  36 configRouter.put('/custom',
  37   authenticate,
  38   ensureUserHasRight(UserRight.MANAGE_CONFIGURATION),
  39   customConfigUpdateValidator,
  40   asyncMiddleware(updateCustomConfig)
  41 )
  42 configRouter.delete('/custom',
  43   authenticate,
  44   ensureUserHasRight(UserRight.MANAGE_CONFIGURATION),
  45   asyncMiddleware(deleteCustomConfig)
  46 )
  47
  48 let serverCommit: string
  49
  50 async function getConfig (req: express.Request, res: express.Response) {
  51   const { allowed } = await Hooks.wrapPromiseFun(
  52     isSignupAllowed,
  53     {
  54       ip: req.ip
  55     },
  56     'filter:api.user.signup.allowed.result'
  57   )
  58
  59   const allowedForCurrentIP = isSignupAllowedForCurrentIP(req.ip)
  60   const defaultTheme = getThemeOrDefault(CONFIG.THEME.DEFAULT, DEFAULT_THEME_NAME)
  61
  62   if (serverCommit === undefined) serverCommit = await getServerCommit()
  63
  64   const json: ServerConfig = {
  65     instance: {
  66       name: CONFIG.INSTANCE.NAME,
  67       shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
  68       defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
  69       isNSFW: CONFIG.INSTANCE.IS_NSFW,
  70       defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
  71       customizations: {
  72         javascript: CONFIG.INSTANCE.CUSTOMIZATIONS.JAVASCRIPT,
  73         css: CONFIG.INSTANCE.CUSTOMIZATIONS.CSS
  74       }
  75     },
  76     plugin: {
  77       registered: getRegisteredPlugins()
  78     },
  79     theme: {
  80       registered: getRegisteredThemes(),
  81       default: defaultTheme
  82     },
  83     email: {
  84       enabled: Emailer.isEnabled()
  85     },
  86     contactForm: {
  87       enabled: CONFIG.CONTACT_FORM.ENABLED
  88     },
  89     serverVersion: PEERTUBE_VERSION,
  90     serverCommit,
  91     signup: {
  92       allowed,
  93       allowedForCurrentIP,
  94       requiresEmailVerification: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION
  95     },
  96     transcoding: {
  97       hls: {
  98         enabled: CONFIG.TRANSCODING.HLS.ENABLED
  99       },
 100       webtorrent: {
 101         enabled: CONFIG.TRANSCODING.WEBTORRENT.ENABLED
 102       },
 103       enabledResolutions: getEnabledResolutions()
 104     },
 105     import: {
 106       videos: {
 107         http: {
 108           enabled: CONFIG.IMPORT.VIDEOS.HTTP.ENABLED
 109         },
 110         torrent: {
 111           enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
 112         }
 113       }
 114     },
 115     autoBlacklist: {
 116       videos: {
 117         ofUsers: {
 118           enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
 119         }
 120       }
 121     },
 122     avatar: {
 123       file: {
 124         size: {
 125           max: CONSTRAINTS_FIELDS.ACTORS.AVATAR.FILE_SIZE.max
 126         },
 127         extensions: CONSTRAINTS_FIELDS.ACTORS.AVATAR.EXTNAME
 128       }
 129     },
 130     video: {
 131       image: {
 132         extensions: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME,
 133         size: {
 134           max: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.FILE_SIZE.max
 135         }
 136       },
 137       file: {
 138         extensions: CONSTRAINTS_FIELDS.VIDEOS.EXTNAME
 139       }
 140     },
 141     videoCaption: {
 142       file: {
 143         size: {
 144           max: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max
 145         },
 146         extensions: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.EXTNAME
 147       }
 148     },
 149     user: {
 150       videoQuota: CONFIG.USER.VIDEO_QUOTA,
 151       videoQuotaDaily: CONFIG.USER.VIDEO_QUOTA_DAILY
 152     },
 153     trending: {
 154       videos: {
 155         intervalDays: CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
 156       }
 157     },
 158     tracker: {
 159       enabled: CONFIG.TRACKER.ENABLED
 160     },
 161
 162     followings: {
 163       instance: {
 164         autoFollowIndex: {
 165           indexUrl: CONFIG.FOLLOWINGS.INSTANCE.AUTO_FOLLOW_INDEX.INDEX_URL
 166         }
 167       }
 168     }
 169   }
 170
 171   return res.json(json)
 172 }
 173
 174 function getAbout (req: express.Request, res: express.Response) {
 175   const about: About = {
 176     instance: {
 177       name: CONFIG.INSTANCE.NAME,
 178       shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
 179       description: CONFIG.INSTANCE.DESCRIPTION,
 180       terms: CONFIG.INSTANCE.TERMS,
 181       codeOfConduct: CONFIG.INSTANCE.CODE_OF_CONDUCT,
 182
 183       hardwareInformation: CONFIG.INSTANCE.HARDWARE_INFORMATION,
 184
 185       creationReason: CONFIG.INSTANCE.CREATION_REASON,
 186       moderationInformation: CONFIG.INSTANCE.MODERATION_INFORMATION,
 187       administrator: CONFIG.INSTANCE.ADMINISTRATOR,
 188       maintenanceLifetime: CONFIG.INSTANCE.MAINTENANCE_LIFETIME,
 189       businessModel: CONFIG.INSTANCE.BUSINESS_MODEL,
 190
 191       languages: CONFIG.INSTANCE.LANGUAGES,
 192       categories: CONFIG.INSTANCE.CATEGORIES
 193     }
 194   }
 195
 196   return res.json(about).end()
 197 }
 198
 199 function getCustomConfig (req: express.Request, res: express.Response) {
 200   const data = customConfig()
 201
 202   return res.json(data).end()
 203 }
 204
 205 async function deleteCustomConfig (req: express.Request, res: express.Response) {
 206   await remove(CONFIG.CUSTOM_FILE)
 207
 208   auditLogger.delete(getAuditIdFromRes(res), new CustomConfigAuditView(customConfig()))
 209
 210   reloadConfig()
 211   ClientHtml.invalidCache()
 212
 213   const data = customConfig()
 214
 215   return res.json(data).end()
 216 }
 217
 218 async function updateCustomConfig (req: express.Request, res: express.Response) {
 219   const oldCustomConfigAuditKeys = new CustomConfigAuditView(customConfig())
 220
 221   // camelCase to snake_case key + Force number conversion
 222   const toUpdateJSON = convertCustomConfigBody(req.body)
 223
 224   await writeJSON(CONFIG.CUSTOM_FILE, toUpdateJSON, { spaces: 2 })
 225
 226   reloadConfig()
 227   ClientHtml.invalidCache()
 228
 229   const data = customConfig()
 230
 231   auditLogger.update(
 232     getAuditIdFromRes(res),
 233     new CustomConfigAuditView(data),
 234     oldCustomConfigAuditKeys
 235   )
 236
 237   return res.json(data).end()
 238 }
 239
 240 function getRegisteredThemes () {
 241   return PluginManager.Instance.getRegisteredThemes()
 242                       .map(t => ({
 243                         name: t.name,
 244                         version: t.version,
 245                         description: t.description,
 246                         css: t.css,
 247                         clientScripts: t.clientScripts
 248                       }))
 249 }
 250
 251 function getEnabledResolutions () {
 252   return Object.keys(CONFIG.TRANSCODING.RESOLUTIONS)
 253                .filter(key => CONFIG.TRANSCODING.ENABLED && CONFIG.TRANSCODING.RESOLUTIONS[key] === true)
 254                .map(r => parseInt(r, 10))
 255 }
 256
 257 function getRegisteredPlugins () {
 258   return PluginManager.Instance.getRegisteredPlugins()
 259                       .map(p => ({
 260                         name: p.name,
 261                         version: p.version,
 262                         description: p.description,
 263                         clientScripts: p.clientScripts
 264                       }))
 265 }
 266
 267 // ---------------------------------------------------------------------------
 268
 269 export {
 270   configRouter,
 271   getEnabledResolutions,
 272   getRegisteredPlugins,
 273   getRegisteredThemes
 274 }
 275
 276 // ---------------------------------------------------------------------------
 277
 278 function customConfig (): CustomConfig {
 279   return {
 280     instance: {
 281       name: CONFIG.INSTANCE.NAME,
 282       shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
 283       description: CONFIG.INSTANCE.DESCRIPTION,
 284       terms: CONFIG.INSTANCE.TERMS,
 285       codeOfConduct: CONFIG.INSTANCE.CODE_OF_CONDUCT,
 286
 287       creationReason: CONFIG.INSTANCE.CREATION_REASON,
 288       moderationInformation: CONFIG.INSTANCE.MODERATION_INFORMATION,
 289       administrator: CONFIG.INSTANCE.ADMINISTRATOR,
 290       maintenanceLifetime: CONFIG.INSTANCE.MAINTENANCE_LIFETIME,
 291       businessModel: CONFIG.INSTANCE.BUSINESS_MODEL,
 292       hardwareInformation: CONFIG.INSTANCE.HARDWARE_INFORMATION,
 293
 294       languages: CONFIG.INSTANCE.LANGUAGES,
 295       categories: CONFIG.INSTANCE.CATEGORIES,
 296
 297       isNSFW: CONFIG.INSTANCE.IS_NSFW,
 298       defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
 299       defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
 300       customizations: {
 301         css: CONFIG.INSTANCE.CUSTOMIZATIONS.CSS,
 302         javascript: CONFIG.INSTANCE.CUSTOMIZATIONS.JAVASCRIPT
 303       }
 304     },
 305     theme: {
 306       default: CONFIG.THEME.DEFAULT
 307     },
 308     services: {
 309       twitter: {
 310         username: CONFIG.SERVICES.TWITTER.USERNAME,
 311         whitelisted: CONFIG.SERVICES.TWITTER.WHITELISTED
 312       }
 313     },
 314     cache: {
 315       previews: {
 316         size: CONFIG.CACHE.PREVIEWS.SIZE
 317       },
 318       captions: {
 319         size: CONFIG.CACHE.VIDEO_CAPTIONS.SIZE
 320       }
 321     },
 322     signup: {
 323       enabled: CONFIG.SIGNUP.ENABLED,
 324       limit: CONFIG.SIGNUP.LIMIT,
 325       requiresEmailVerification: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION
 326     },
 327     admin: {
 328       email: CONFIG.ADMIN.EMAIL
 329     },
 330     contactForm: {
 331       enabled: CONFIG.CONTACT_FORM.ENABLED
 332     },
 333     user: {
 334       videoQuota: CONFIG.USER.VIDEO_QUOTA,
 335       videoQuotaDaily: CONFIG.USER.VIDEO_QUOTA_DAILY
 336     },
 337     transcoding: {
 338       enabled: CONFIG.TRANSCODING.ENABLED,
 339       allowAdditionalExtensions: CONFIG.TRANSCODING.ALLOW_ADDITIONAL_EXTENSIONS,
 340       allowAudioFiles: CONFIG.TRANSCODING.ALLOW_AUDIO_FILES,
 341       threads: CONFIG.TRANSCODING.THREADS,
 342       resolutions: {
 343         '0p': CONFIG.TRANSCODING.RESOLUTIONS['0p'],
 344         '240p': CONFIG.TRANSCODING.RESOLUTIONS['240p'],
 345         '360p': CONFIG.TRANSCODING.RESOLUTIONS['360p'],
 346         '480p': CONFIG.TRANSCODING.RESOLUTIONS['480p'],
 347         '720p': CONFIG.TRANSCODING.RESOLUTIONS['720p'],
 348         '1080p': CONFIG.TRANSCODING.RESOLUTIONS['1080p'],
 349         '2160p': CONFIG.TRANSCODING.RESOLUTIONS['2160p']
 350       },
 351       webtorrent: {
 352         enabled: CONFIG.TRANSCODING.WEBTORRENT.ENABLED
 353       },
 354       hls: {
 355         enabled: CONFIG.TRANSCODING.HLS.ENABLED
 356       }
 357     },
 358     import: {
 359       videos: {
 360         http: {
 361           enabled: CONFIG.IMPORT.VIDEOS.HTTP.ENABLED
 362         },
 363         torrent: {
 364           enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
 365         }
 366       }
 367     },
 368     autoBlacklist: {
 369       videos: {
 370         ofUsers: {
 371           enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
 372         }
 373       }
 374     },
 375     followers: {
 376       instance: {
 377         enabled: CONFIG.FOLLOWERS.INSTANCE.ENABLED,
 378         manualApproval: CONFIG.FOLLOWERS.INSTANCE.MANUAL_APPROVAL
 379       }
 380     },
 381     followings: {
 382       instance: {
 383         autoFollowBack: {
 384           enabled: CONFIG.FOLLOWINGS.INSTANCE.AUTO_FOLLOW_BACK.ENABLED
 385         },
 386
 387         autoFollowIndex: {
 388           enabled: CONFIG.FOLLOWINGS.INSTANCE.AUTO_FOLLOW_INDEX.ENABLED,
 389           indexUrl: CONFIG.FOLLOWINGS.INSTANCE.AUTO_FOLLOW_INDEX.INDEX_URL
 390         }
 391       }
 392     }
 393   }
 394 }
 395
 396 function convertCustomConfigBody (body: CustomConfig) {
 397   function keyConverter (k: string) {
 398     // Transcoding resolutions exception
 399     if (/^\d{3,4}p$/.exec(k)) return k
 400     if (k === '0p') return k
 401
 402     return snakeCase(k)
 403   }
 404
 405   function valueConverter (v: any) {
 406     if (validator.isNumeric(v + '')) return parseInt('' + v, 10)
 407
 408     return v
 409   }
 410
 411   return objectConverter(body, keyConverter, valueConverter)
 412 }