wikijs-fork/server/libs/entries.js

458 lines
13 KiB
JavaScript
Raw Normal View History

2017-02-09 01:52:37 +00:00
'use strict'
/* global db, git, lang, mark, rights, search, winston */
2017-02-09 01:52:37 +00:00
const Promise = require('bluebird')
const path = require('path')
const fs = Promise.promisifyAll(require('fs-extra'))
const _ = require('lodash')
2017-04-28 22:22:03 +00:00
const entryHelper = require('../helpers/entry')
/**
* Entries Model
*/
module.exports = {
2017-02-09 01:52:37 +00:00
_repoPath: 'repo',
_cachePath: 'data/cache',
/**
* Initialize Entries model
*
* @return {Object} Entries model instance
*/
init() {
2017-02-09 01:52:37 +00:00
let self = this
self._repoPath = path.resolve(ROOTPATH, appconfig.paths.repo)
self._cachePath = path.resolve(ROOTPATH, appconfig.paths.data, 'cache')
2017-04-28 22:22:03 +00:00
appdata.repoPath = self._repoPath
appdata.cachePath = self._cachePath
2017-02-09 01:52:37 +00:00
return self
},
/**
* Check if a document already exists
*
* @param {String} entryPath The entry path
* @return {Promise<Boolean>} True if exists, false otherwise
*/
exists(entryPath) {
2017-02-09 01:52:37 +00:00
let self = this
return self.fetchOriginal(entryPath, {
parseMarkdown: false,
parseMeta: false,
parseTree: false,
includeMarkdown: false,
includeParentInfo: false,
cache: false
}).then(() => {
return true
}).catch((err) => { // eslint-disable-line handle-callback-err
return false
})
},
/**
* Fetch a document from cache, otherwise the original
*
* @param {String} entryPath The entry path
* @return {Promise<Object>} Page Data
*/
fetch(entryPath) {
2017-02-09 01:52:37 +00:00
let self = this
2017-04-28 22:22:03 +00:00
let cpath = entryHelper.getCachePath(entryPath)
2017-02-09 01:52:37 +00:00
return fs.statAsync(cpath).then((st) => {
return st.isFile()
}).catch((err) => { // eslint-disable-line handle-callback-err
return false
}).then((isCache) => {
if (isCache) {
// Load from cache
return fs.readFileAsync(cpath).then((contents) => {
return JSON.parse(contents)
}).catch((err) => { // eslint-disable-line handle-callback-err
winston.error('Corrupted cache file. Deleting it...')
fs.unlinkSync(cpath)
return false
})
} else {
// Load original
return self.fetchOriginal(entryPath)
}
})
},
/**
* Fetches the original document entry
*
* @param {String} entryPath The entry path
* @param {Object} options The options
* @return {Promise<Object>} Page data
*/
fetchOriginal(entryPath, options) {
2017-02-09 01:52:37 +00:00
let self = this
2017-04-28 22:22:03 +00:00
let fpath = entryHelper.getFullPath(entryPath)
let cpath = entryHelper.getCachePath(entryPath)
2017-02-09 01:52:37 +00:00
options = _.defaults(options, {
parseMarkdown: true,
parseMeta: true,
parseTree: true,
includeMarkdown: false,
includeParentInfo: true,
cache: true
})
return fs.statAsync(fpath).then((st) => {
if (st.isFile()) {
return fs.readFileAsync(fpath, 'utf8').then((contents) => {
let htmlProcessor = (options.parseMarkdown) ? mark.parseContent(contents) : Promise.resolve('')
2017-02-09 01:52:37 +00:00
// Parse contents
return htmlProcessor.then(html => {
let pageData = {
markdown: (options.includeMarkdown) ? contents : '',
html,
meta: (options.parseMeta) ? mark.parseMeta(contents) : {},
tree: (options.parseTree) ? mark.parseTree(contents) : []
}
2017-02-09 01:52:37 +00:00
if (!pageData.meta.title) {
pageData.meta.title = _.startCase(entryPath)
}
2017-02-09 01:52:37 +00:00
pageData.meta.path = entryPath
2017-02-09 01:52:37 +00:00
// Get parent
2017-02-09 01:52:37 +00:00
let parentPromise = (options.includeParentInfo) ? self.getParentInfo(entryPath).then((parentData) => {
return (pageData.parent = parentData)
}).catch((err) => { // eslint-disable-line handle-callback-err
return (pageData.parent = false)
}) : Promise.resolve(true)
2017-02-09 01:52:37 +00:00
return parentPromise.then(() => {
// Cache to disk
2017-02-09 01:52:37 +00:00
if (options.cache) {
let cacheData = JSON.stringify(_.pick(pageData, ['html', 'meta', 'tree', 'parent']), false, false, false)
return fs.writeFileAsync(cpath, cacheData).catch((err) => {
winston.error('Unable to write to cache! Performance may be affected.')
winston.error(err)
return true
})
} else {
2017-02-09 01:52:37 +00:00
return true
}
}).return(pageData)
})
2017-02-09 01:52:37 +00:00
})
} else {
return false
}
}).catch((err) => { // eslint-disable-line handle-callback-err
2017-05-03 01:41:22 +00:00
throw new Promise.OperationalError(lang.t('errors:notexist', { path: entryPath }))
2017-02-09 01:52:37 +00:00
})
},
/**
* Gets the parent information.
*
* @param {String} entryPath The entry path
* @return {Promise<Object|False>} The parent information.
*/
getParentInfo(entryPath) {
2017-02-09 01:52:37 +00:00
if (_.includes(entryPath, '/')) {
let parentParts = _.initial(_.split(entryPath, '/'))
let parentPath = _.join(parentParts, '/')
let parentFile = _.last(parentParts)
2017-04-28 22:22:03 +00:00
let fpath = entryHelper.getFullPath(parentPath)
2017-02-09 01:52:37 +00:00
return fs.statAsync(fpath).then((st) => {
if (st.isFile()) {
return fs.readFileAsync(fpath, 'utf8').then((contents) => {
let pageMeta = mark.parseMeta(contents)
return {
path: parentPath,
title: (pageMeta.title) ? pageMeta.title : _.startCase(parentFile),
subtitle: (pageMeta.subtitle) ? pageMeta.subtitle : false
}
})
} else {
2017-05-03 01:41:22 +00:00
return Promise.reject(new Error(lang.t('errors:parentinvalid')))
2017-02-09 01:52:37 +00:00
}
})
} else {
2017-05-03 01:41:22 +00:00
return Promise.reject(new Error(lang.t('errors:parentisroot')))
2017-02-09 01:52:37 +00:00
}
},
/**
* Update an existing document
*
* @param {String} entryPath The entry path
* @param {String} contents The markdown-formatted contents
* @param {Object} author The author user object
2017-02-09 01:52:37 +00:00
* @return {Promise<Boolean>} True on success, false on failure
*/
update(entryPath, contents, author) {
2017-02-09 01:52:37 +00:00
let self = this
2017-04-28 22:22:03 +00:00
let fpath = entryHelper.getFullPath(entryPath)
2017-02-09 01:52:37 +00:00
return fs.statAsync(fpath).then((st) => {
if (st.isFile()) {
return self.makePersistent(entryPath, contents, author).then(() => {
return self.updateCache(entryPath).then(entry => {
return search.add(entry)
})
2017-02-09 01:52:37 +00:00
})
} else {
2017-05-03 01:42:25 +00:00
return Promise.reject(new Error(lang.t('errors:notexist', { path: entryPath })))
2017-02-09 01:52:37 +00:00
}
}).catch((err) => {
winston.error(err)
2017-05-03 01:41:22 +00:00
return Promise.reject(new Error(lang.t('errors:savefailed')))
2017-02-09 01:52:37 +00:00
})
},
/**
2017-04-18 02:44:04 +00:00
* Update local cache
2017-02-09 01:52:37 +00:00
*
* @param {String} entryPath The entry path
* @return {Promise} Promise of the operation
*/
updateCache(entryPath) {
2017-02-09 01:52:37 +00:00
let self = this
return self.fetchOriginal(entryPath, {
parseMarkdown: true,
parseMeta: true,
parseTree: true,
includeMarkdown: true,
includeParentInfo: true,
cache: true
}).catch(err => {
winston.error(err)
return err
2017-02-09 01:52:37 +00:00
}).then((pageData) => {
return {
entryPath,
meta: pageData.meta,
parent: pageData.parent || {},
text: mark.removeMarkdown(pageData.markdown)
}
}).catch(err => {
winston.error(err)
return err
2017-02-09 01:52:37 +00:00
}).then((content) => {
2017-04-23 19:54:35 +00:00
let parentPath = _.chain(content.entryPath).split('/').initial().join('/').value()
2017-02-09 01:52:37 +00:00
return db.Entry.findOneAndUpdate({
_id: content.entryPath
}, {
2017-06-24 20:31:32 +00:00
_id: content.entryPath,
title: content.meta.title || content.entryPath,
subtitle: content.meta.subtitle || '',
parentTitle: content.parent.title || '',
parentPath: parentPath,
isDirectory: false,
isEntry: true
}, {
new: true,
upsert: true
}).then(result => {
let plainResult = result.toObject()
plainResult.text = content.text
return plainResult
})
2017-04-23 19:54:35 +00:00
}).then(result => {
return self.updateTreeInfo().then(() => {
return result
2017-04-23 19:54:35 +00:00
})
}).catch(err => {
winston.error(err)
return err
2017-02-09 01:52:37 +00:00
})
},
/**
* Update tree info for all directory and parent entries
*
* @returns {Promise<Boolean>} Promise of the operation
*/
updateTreeInfo() {
return db.Entry.distinct('parentPath', { parentPath: { $ne: '' } }).then(allPaths => {
if (allPaths.length > 0) {
return Promise.map(allPaths, pathItem => {
let parentPath = _.chain(pathItem).split('/').initial().join('/').value()
let guessedTitle = _.chain(pathItem).split('/').last().startCase().value()
return db.Entry.update({ _id: pathItem }, {
$set: { isDirectory: true },
$setOnInsert: { isEntry: false, title: guessedTitle, parentPath }
}, { upsert: true })
})
} else {
return true
}
})
},
2017-02-09 01:52:37 +00:00
/**
* Create a new document
*
* @param {String} entryPath The entry path
* @param {String} contents The markdown-formatted contents
* @param {Object} author The author user object
* @return {Promise<Boolean>} True on success, false on failure
2017-02-09 01:52:37 +00:00
*/
create(entryPath, contents, author) {
2017-02-09 01:52:37 +00:00
let self = this
return self.exists(entryPath).then((docExists) => {
if (!docExists) {
return self.makePersistent(entryPath, contents, author).then(() => {
return self.updateCache(entryPath).then(entry => {
return search.add(entry)
})
2017-02-09 01:52:37 +00:00
})
} else {
2017-05-03 01:41:22 +00:00
return Promise.reject(new Error(lang.t('errors:alreadyexists')))
2017-02-09 01:52:37 +00:00
}
}).catch((err) => {
winston.error(err)
2017-05-03 01:41:22 +00:00
return Promise.reject(new Error(lang.t('errors:generic')))
2017-02-09 01:52:37 +00:00
})
},
/**
* Makes a document persistent to disk and git repository
*
* @param {String} entryPath The entry path
* @param {String} contents The markdown-formatted contents
* @param {Object} author The author user object
* @return {Promise<Boolean>} True on success, false on failure
2017-02-09 01:52:37 +00:00
*/
makePersistent(entryPath, contents, author) {
2017-04-28 22:22:03 +00:00
let fpath = entryHelper.getFullPath(entryPath)
2017-02-09 01:52:37 +00:00
return fs.outputFileAsync(fpath, contents).then(() => {
return git.commitDocument(entryPath, author)
2017-02-09 01:52:37 +00:00
})
},
/**
* Move a document
*
* @param {String} entryPath The current entry path
* @param {String} newEntryPath The new entry path
* @param {Object} author The author user object
* @return {Promise} Promise of the operation
2017-02-09 01:52:37 +00:00
*/
move(entryPath, newEntryPath, author) {
2017-02-09 01:52:37 +00:00
let self = this
if (_.isEmpty(entryPath) || entryPath === 'home') {
2017-05-03 01:41:22 +00:00
return Promise.reject(new Error(lang.t('errors:invalidpath')))
2017-02-09 01:52:37 +00:00
}
return git.moveDocument(entryPath, newEntryPath).then(() => {
return git.commitDocument(newEntryPath, author).then(() => {
2017-02-09 01:52:37 +00:00
// Delete old cache version
2017-04-28 22:22:03 +00:00
let oldEntryCachePath = entryHelper.getCachePath(entryPath)
2017-02-09 01:52:37 +00:00
fs.unlinkAsync(oldEntryCachePath).catch((err) => { return true }) // eslint-disable-line handle-callback-err
// Delete old index entry
2017-02-13 04:17:14 +00:00
search.delete(entryPath)
2017-02-09 01:52:37 +00:00
// Create cache for new entry
2017-08-11 01:00:18 +00:00
return Promise.join(
db.Entry.deleteOne({ _id: entryPath }),
self.updateCache(newEntryPath).then(entry => {
return search.add(entry)
})
)
2017-02-09 01:52:37 +00:00
})
})
},
2017-10-10 01:43:43 +00:00
/**
* Delete a document
*
* @param {String} entryPath The current entry path
* @param {Object} author The author user object
* @return {Promise} Promise of the operation
*/
remove(entryPath, author) {
if (_.isEmpty(entryPath) || entryPath === 'home') {
return Promise.reject(new Error(lang.t('errors:invalidpath')))
}
return git.deleteDocument(entryPath, author).then(() => {
// Delete old cache version
let oldEntryCachePath = entryHelper.getCachePath(entryPath)
fs.unlinkAsync(oldEntryCachePath).catch((err) => { return true }) // eslint-disable-line handle-callback-err
// Delete old index entry
search.delete(entryPath)
// Delete entry
return db.Entry.deleteOne({ _id: entryPath })
})
},
2017-02-09 01:52:37 +00:00
/**
* Generate a starter page content based on the entry path
*
* @param {String} entryPath The entry path
* @return {Promise<String>} Starter content
*/
getStarter(entryPath) {
2017-02-09 01:52:37 +00:00
let formattedTitle = _.startCase(_.last(_.split(entryPath, '/')))
2017-04-28 22:22:03 +00:00
return fs.readFileAsync(path.join(SERVERPATH, 'app/content/create.md'), 'utf8').then((contents) => {
2017-02-09 01:52:37 +00:00
return _.replace(contents, new RegExp('{TITLE}', 'g'), formattedTitle)
})
2017-04-09 15:48:37 +00:00
},
/**
* Get all entries from base path
*
* @param {String} basePath Path to list from
* @param {Object} usr Current user
2017-04-09 15:48:37 +00:00
* @return {Promise<Array>} List of entries
*/
getFromTree(basePath, usr) {
return db.Entry.find({ parentPath: basePath }, 'title parentPath isDirectory isEntry').sort({ title: 'asc' }).then(results => {
return _.filter(results, r => {
return rights.checkRole('/' + r._id, usr.rights, 'read')
})
})
},
getHistory(entryPath) {
return db.Entry.findOne({ _id: entryPath, isEntry: true }).then(entry => {
if (!entry) { return false }
return git.getHistory(entryPath).then(history => {
return {
meta: entry,
history
}
})
})
2017-02-09 01:52:37 +00:00
}
}