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