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