wikijs-fork/server/graph/resolvers/system.js

431 lines
14 KiB
JavaScript
Raw Normal View History

2018-03-18 04:34:32 +00:00
const _ = require('lodash')
const Promise = require('bluebird')
const getos = Promise.promisify(require('getos'))
2018-03-18 04:34:32 +00:00
const os = require('os')
const filesize = require('filesize')
const path = require('path')
const fs = require('fs-extra')
2019-01-13 20:37:45 +00:00
const moment = require('moment')
2019-02-23 23:22:25 +00:00
const graphHelper = require('../../helpers/graph')
const request = require('request-promise')
const crypto = require('crypto')
const nanoid = require('nanoid/non-secure').customAlphabet('1234567890abcdef', 10)
2018-03-18 04:34:32 +00:00
/* global WIKI */
const dbTypes = {
2018-09-08 19:49:36 +00:00
mysql: 'MySQL',
mariadb: 'MariaDB',
postgres: 'PostgreSQL',
sqlite: 'SQLite',
mssql: 'MS SQL Server'
}
2018-03-18 04:34:32 +00:00
module.exports = {
Query: {
2019-09-22 20:32:39 +00:00
async system () { return {} }
2018-03-18 04:34:32 +00:00
},
2019-02-23 23:22:25 +00:00
Mutation: {
2019-09-22 20:32:39 +00:00
async system () { return {} }
2019-02-23 23:22:25 +00:00
},
2018-03-18 04:34:32 +00:00
SystemQuery: {
2019-09-22 20:32:39 +00:00
flags () {
2019-02-23 23:22:25 +00:00
return _.transform(WIKI.config.flags, (result, value, key) => {
result.push({ key, value })
}, [])
},
2020-05-18 04:45:51 +00:00
async info () { return {} },
async extensions () {
const exts = Object.values(WIKI.extensions.ext).map(ext => _.pick(ext, ['key', 'title', 'description', 'isInstalled']))
for (let ext of exts) {
ext.isCompatible = await WIKI.extensions.ext[ext.key].isCompatible()
}
return exts
},
async exportStatus () {
return {
status: WIKI.system.exportStatus.status,
progress: Math.ceil(WIKI.system.exportStatus.progress),
message: WIKI.system.exportStatus.message,
startedAt: WIKI.system.exportStatus.startedAt
}
2020-05-18 04:45:51 +00:00
}
},
2019-02-23 23:22:25 +00:00
SystemMutation: {
2019-09-22 20:32:39 +00:00
async updateFlags (obj, args, context) {
2019-02-23 23:22:25 +00:00
WIKI.config.flags = _.transform(args.flags, (result, row) => {
_.set(result, row.key, row.value)
}, {})
await WIKI.configSvc.applyFlags()
await WIKI.configSvc.saveToDb(['flags'])
return {
responseResult: graphHelper.generateSuccess('System Flags applied successfully')
}
2019-07-06 21:43:50 +00:00
},
2019-09-22 20:32:39 +00:00
async resetTelemetryClientId (obj, args, context) {
2019-07-06 21:43:50 +00:00
try {
WIKI.telemetry.generateClientId()
await WIKI.configSvc.saveToDb(['telemetry'])
return {
responseResult: graphHelper.generateSuccess('Telemetry state updated successfully')
}
} catch (err) {
2019-07-06 21:43:50 +00:00
return graphHelper.generateError(err)
}
},
2019-09-22 20:32:39 +00:00
async setTelemetry (obj, args, context) {
2019-07-06 21:43:50 +00:00
try {
_.set(WIKI.config, 'telemetry.isEnabled', args.enabled)
WIKI.telemetry.enabled = args.enabled
await WIKI.configSvc.saveToDb(['telemetry'])
return {
responseResult: graphHelper.generateSuccess('Telemetry Client ID has been reset successfully')
}
} catch (err) {
2019-07-06 21:43:50 +00:00
return graphHelper.generateError(err)
}
2019-09-22 20:32:39 +00:00
},
async performUpgrade (obj, args, context) {
try {
if (process.env.UPGRADE_COMPANION) {
await request({
method: 'POST',
uri: 'http://wiki-update-companion/upgrade'
})
return {
responseResult: graphHelper.generateSuccess('Upgrade has started.')
2019-09-22 20:32:39 +00:00
}
} else {
throw new Error('You must run the wiki-update-companion container and pass the UPGRADE_COMPANION env var in order to use this feature.')
2019-09-22 20:32:39 +00:00
}
} catch (err) {
return graphHelper.generateError(err)
}
},
/**
* Import Users from a v1 installation
*/
async importUsersFromV1(obj, args, context) {
try {
const MongoClient = require('mongodb').MongoClient
if (args.mongoDbConnString && args.mongoDbConnString.length > 10) {
// -> Connect to DB
const client = await MongoClient.connect(args.mongoDbConnString, {
appname: `Wiki.js ${WIKI.version} Migration Tool`
})
const dbUsers = client.db().collection('users')
const userCursor = dbUsers.find({ email: { '$ne': 'guest' } })
const curDateISO = new Date().toISOString()
let failed = []
let usersCount = 0
let groupsCount = 0
let assignableGroups = []
let reuseGroups = []
// -> Create SINGLE group
if (args.groupMode === `SINGLE`) {
const singleGroup = await WIKI.models.groups.query().insert({
name: `Import_${curDateISO}`,
permissions: JSON.stringify(WIKI.data.groups.defaultPermissions),
pageRules: JSON.stringify(WIKI.data.groups.defaultPageRules)
})
groupsCount++
assignableGroups.push(singleGroup.id)
}
// -> Iterate all users
while (await userCursor.hasNext()) {
const usr = await userCursor.next()
let usrGroup = []
if (args.groupMode === `MULTI`) {
// -> Check if global admin
if (_.some(usr.rights, ['role', 'admin'])) {
usrGroup.push(1)
} else {
// -> Check if identical group already exists
const currentRights = _.sortBy(_.map(usr.rights, r => _.pick(r, ['role', 'path', 'exact', 'deny'])), ['role', 'path', 'exact', 'deny'])
const ruleSetId = crypto.createHash('sha1').update(JSON.stringify(currentRights)).digest('base64')
const existingGroup = _.find(reuseGroups, ['hash', ruleSetId])
if (existingGroup) {
usrGroup.push(existingGroup.groupId)
} else {
// -> Build new group
const pageRules = _.map(usr.rights, r => {
let roles = ['read:pages', 'read:assets', 'read:comments', 'write:comments']
if (r.role === `write`) {
roles = _.concat(roles, ['write:pages', 'manage:pages', 'read:source', 'read:history', 'write:assets', 'manage:assets'])
}
return {
id: nanoid(),
roles: roles,
match: r.exact ? 'EXACT' : 'START',
deny: r.deny,
path: (r.path.indexOf('/') === 0) ? r.path.substring(1) : r.path,
locales: []
}
})
const perms = _.chain(pageRules).reject('deny').map('roles').union().flatten().value()
// -> Create new group
const newGroup = await WIKI.models.groups.query().insert({
name: `Import_${curDateISO}_${groupsCount + 1}`,
permissions: JSON.stringify(perms),
pageRules: JSON.stringify(pageRules)
})
reuseGroups.push({
groupId: newGroup.id,
hash: ruleSetId
})
groupsCount++
usrGroup.push(newGroup.id)
}
}
}
// -> Create User
try {
await WIKI.models.users.createNewUser({
providerKey: usr.provider,
email: usr.email,
name: usr.name,
passwordRaw: usr.password,
groups: (usrGroup.length > 0) ? usrGroup : assignableGroups,
mustChangePassword: false,
sendWelcomeEmail: false
})
usersCount++
} catch (err) {
failed.push({
provider: usr.provider,
email: usr.email,
error: err.message
})
WIKI.logger.warn(`${usr.email}: ${err}`)
}
}
// -> Reload group permissions
if (args.groupMode !== `NONE`) {
await WIKI.auth.reloadGroups()
2020-04-20 00:26:26 +00:00
WIKI.events.outbound.emit('reloadGroups')
}
client.close()
return {
responseResult: graphHelper.generateSuccess('Import completed.'),
usersCount: usersCount,
groupsCount: groupsCount,
failed: failed
}
} else {
throw new Error('MongoDB Connection String is missing or invalid.')
}
} catch (err) {
return graphHelper.generateError(err)
}
},
/**
* Set HTTPS Redirection State
*/
async setHTTPSRedirection (obj, args, context) {
_.set(WIKI.config, 'server.sslRedir', args.enabled)
await WIKI.configSvc.saveToDb(['server'])
return {
responseResult: graphHelper.generateSuccess('HTTP Redirection state set successfully.')
}
},
/**
* Renew SSL Certificate
*/
async renewHTTPSCertificate (obj, args, context) {
try {
if (!WIKI.config.ssl.enabled) {
throw new WIKI.Error.SystemSSLDisabled()
} else if (WIKI.config.ssl.provider !== `letsencrypt`) {
throw new WIKI.Error.SystemSSLRenewInvalidProvider()
} else if (!WIKI.servers.le) {
throw new WIKI.Error.SystemSSLLEUnavailable()
} else {
await WIKI.servers.le.requestCertificate()
await WIKI.servers.restartServer('https')
return {
responseResult: graphHelper.generateSuccess('SSL Certificate renewed successfully.')
}
}
} catch (err) {
return graphHelper.generateError(err)
}
},
/**
* Export Wiki to Disk
*/
async export (obj, args, context) {
try {
const desiredPath = path.resolve(WIKI.ROOTPATH, args.path)
// -> Check if export process is already running
if (WIKI.system.exportStatus.status === 'running') {
throw new Error('Another export is already running.')
}
// -> Validate entities
if (args.entities.length < 1) {
throw new Error('Must specify at least 1 entity to export.')
}
// -> Check target path
await fs.ensureDir(desiredPath)
const existingFiles = await fs.readdir(desiredPath)
if (existingFiles.length) {
throw new Error('Target directory must be empty!')
}
// -> Start export
WIKI.system.export({
entities: args.entities,
path: desiredPath
})
return {
responseResult: graphHelper.generateSuccess('Export started successfully.')
}
} catch (err) {
return graphHelper.generateError(err)
}
2019-02-23 23:22:25 +00:00
}
},
SystemInfo: {
2019-09-22 20:32:39 +00:00
configFile () {
return path.join(process.cwd(), 'config.yml')
},
2019-09-22 20:32:39 +00:00
cpuCores () {
2019-07-06 21:43:50 +00:00
return os.cpus().length
},
2019-09-22 20:32:39 +00:00
currentVersion () {
return WIKI.version
},
2019-09-22 20:32:39 +00:00
dbType () {
return _.get(dbTypes, WIKI.config.db.type, 'Unknown DB')
},
2019-09-22 20:32:39 +00:00
async dbVersion () {
2018-09-08 19:49:36 +00:00
let version = 'Unknown Version'
switch (WIKI.config.db.type) {
case 'mariadb':
case 'mysql':
const resultMYSQL = await WIKI.models.knex.raw('SELECT VERSION() as version;')
version = _.get(resultMYSQL, '[0][0].version', 'Unknown Version')
break
case 'mssql':
const resultMSSQL = await WIKI.models.knex.raw('SELECT @@VERSION as version;')
version = _.get(resultMSSQL, '[0].version', 'Unknown Version')
break
case 'postgres':
version = _.get(WIKI.models, 'knex.client.version', 'Unknown Version')
break
case 'sqlite':
version = _.get(WIKI.models, 'knex.client.driver.VERSION', 'Unknown Version')
break
}
return version
},
2019-09-22 20:32:39 +00:00
dbHost () {
2018-09-08 19:49:36 +00:00
if (WIKI.config.db.type === 'sqlite') {
return WIKI.config.db.storage
} else {
return WIKI.config.db.host
}
},
2019-09-22 20:32:39 +00:00
hostname () {
2019-07-06 21:43:50 +00:00
return os.hostname()
},
httpPort () {
return WIKI.servers.servers.http ? _.get(WIKI.servers.servers.http.address(), 'port', 0) : 0
},
httpRedirection () {
return _.get(WIKI.config, 'server.sslRedir', false)
},
httpsPort () {
return WIKI.servers.servers.https ? _.get(WIKI.servers.servers.https.address(), 'port', 0) : 0
},
2019-09-22 20:32:39 +00:00
latestVersion () {
2019-01-13 20:37:45 +00:00
return WIKI.system.updates.version
},
2019-09-22 20:32:39 +00:00
latestVersionReleaseDate () {
2019-01-13 20:37:45 +00:00
return moment.utc(WIKI.system.updates.releaseDate)
},
2019-09-22 20:32:39 +00:00
nodeVersion () {
2019-07-06 21:43:50 +00:00
return process.version.substr(1)
},
2019-09-22 20:32:39 +00:00
async operatingSystem () {
let osLabel = `${os.type()} (${os.platform()}) ${os.release()} ${os.arch()}`
if (os.platform() === 'linux') {
const osInfo = await getos()
osLabel = `${os.type()} - ${osInfo.dist} (${osInfo.codename || os.platform()}) ${osInfo.release || os.release()} ${os.arch()}`
}
return osLabel
},
async platform () {
const isDockerized = await fs.pathExists('/.dockerenv')
if (isDockerized) {
return 'docker'
}
return os.platform()
},
2019-09-22 20:32:39 +00:00
ramTotal () {
return filesize(os.totalmem())
},
sslDomain () {
return WIKI.config.ssl.enabled && WIKI.config.ssl.provider === `letsencrypt` ? WIKI.config.ssl.domain : null
},
sslExpirationDate () {
return WIKI.config.ssl.enabled && WIKI.config.ssl.provider === `letsencrypt` ? _.get(WIKI.config.letsencrypt, 'payload.expires', null) : null
},
sslProvider () {
return WIKI.config.ssl.enabled ? WIKI.config.ssl.provider : null
},
sslStatus () {
return 'OK'
},
sslSubscriberEmail () {
return WIKI.config.ssl.enabled && WIKI.config.ssl.provider === `letsencrypt` ? WIKI.config.ssl.subscriberEmail : null
},
2019-09-22 20:32:39 +00:00
telemetry () {
2019-07-06 21:43:50 +00:00
return WIKI.telemetry.enabled
},
2019-09-22 20:32:39 +00:00
telemetryClientId () {
2019-07-06 21:43:50 +00:00
return WIKI.config.telemetry.clientId
},
2019-09-22 20:32:39 +00:00
async upgradeCapable () {
return !_.isNil(process.env.UPGRADE_COMPANION)
2019-09-22 20:32:39 +00:00
},
workingDirectory () {
return process.cwd()
},
2019-09-22 20:32:39 +00:00
async groupsTotal () {
2020-01-26 18:11:33 +00:00
const total = await WIKI.models.groups.query().count('* as total').first()
return _.toSafeInteger(total.total)
},
2019-09-22 20:32:39 +00:00
async pagesTotal () {
2020-01-26 18:11:33 +00:00
const total = await WIKI.models.pages.query().count('* as total').first()
return _.toSafeInteger(total.total)
},
2019-09-22 20:32:39 +00:00
async usersTotal () {
2020-01-26 18:11:33 +00:00
const total = await WIKI.models.users.query().count('* as total').first()
return _.toSafeInteger(total.total)
2020-02-09 05:49:32 +00:00
},
async tagsTotal () {
const total = await WIKI.models.tags.query().count('* as total').first()
return _.toSafeInteger(total.total)
2018-03-18 04:34:32 +00:00
}
}
2018-03-18 04:34:32 +00:00
}