backend/app/controllers/api/v1/Export.controller.js

274 lines
9.8 KiB
JavaScript
Raw Normal View History

2020-10-15 04:13:09 +00:00
const { Controller } = require('libflitter')
const ncp = require('ncp').ncp
const fs = require('fs').promises
const path = require('path')
const md = require('markdown').markdown
const rimraf = require('rimraf')
const uuid = require('uuid/v4')
2020-10-15 04:13:09 +00:00
class ExportController extends Controller {
static get services() {
return [...super.services, 'models', 'utility', 'upload']
2020-10-15 04:13:09 +00:00
}
async get_export_list(req, res, next) {
const Export = this.models.get('api:Export')
const exports = await Export.find({
user_id: req.user.id,
})
return res.api(exports)
}
async download_export(req, res, next) {
const Export = this.models.get('api:Export')
const exported = await Export.findOne({ UUID: req.params.ExportId, user_id: req.user.id })
if ( !exported ) {
return res.status(404)
.message('No export with that UUID found.')
.api()
}
const File = this.models.get('upload::File')
const file = await File.findOne({_id: File.ObjectId(exported.file_id)})
if ( !file ) return res.status(404).message('This export file has been deleted.').api({})
return file.send(res)
}
2020-10-15 04:13:09 +00:00
async export_subtree(req, res, next) {
const Export = this.models.get('api:Export')
2020-10-15 04:13:09 +00:00
const format = req.form.format
const page = req.form.page
if ( format === 'html' ) {
const generated_export = await this.export_subtree_as_html(page, req.user)
// Store the generated archive
const uploader = this.upload.provider()
const file = await uploader.store({
temp_path: generated_export,
original_name: `export-${uuid()}.tar.gz`,
mime_type: 'application/gzip',
tag: 'generated_export',
})
const exp = new Export({
user_id: req.user.id,
format,
subtree: true,
file_id: file.id,
PageId: page.UUID,
})
await exp.save()
return res.api(exp)
2020-10-15 04:13:09 +00:00
}
return res.status(400)
.message('Invalid export format!')
.api()
2020-10-15 04:13:09 +00:00
}
async export_subtree_as_html(page, user) {
const flat_tree = []
const add_to_tree = async (page, level = 0) => {
if ( await page.is_accessible_by(user, 'view') ) {
flat_tree.push({
level,
page,
file_name: `${page.Name.replace(/\s/g, '-')}-${page.UUID}.html`,
})
const children = await page.childPages
for ( const child of children ) {
await add_to_tree(child, level + 1)
}
}
}
await add_to_tree(page)
const manifest = {
sidebar: [],
}
for ( const item of flat_tree ) {
manifest.sidebar.push({
title: item.page.Name,
level: item.level,
link: item.file_name,
})
}
// Copy the template over
const work_dir = await this.scratch_dir()
await this.copy_template(this.utility.path('app', 'assets', 'export', 'html'), work_dir)
const html_template = await fs.readFile(path.resolve(work_dir, 'index.html'), 'utf-8')
for ( const item of flat_tree ) {
let item_template = html_template
item_template = item_template.replace(/{{\s?MANIFEST\s?}}/g, JSON.stringify(manifest))
item_template = item_template.replace(/{{\s?GROUP_TITLE\s?}}/g, page.Name)
item_template = item_template.replace(/{{\s?PAGE_TITLE\s?}}/g, item.page.Name)
item_template = item_template.replace(/{{\s?PAGE_CONTENT\s?}}/g, await this.page_as_html(item.page, work_dir))
await fs.writeFile(path.resolve(work_dir, item.file_name), item_template)
}
// Write the main page redirect
const redir_html = `
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="refresh" content="0; url=${flat_tree[0].file_name}">
</head>
</html>
`
await fs.writeFile(path.resolve(work_dir, 'index.html'), redir_html)
// Create the archive
const tar = require('tar')
const archive_path = path.resolve(work_dir, '..', `export-${uuid()}.tar.gz`)
await tar.c({
gzip: true,
file: archive_path,
cwd: path.resolve(work_dir, '..'),
}, [path.basename(work_dir)])
await new Promise(res => {
rimraf(work_dir, res)
})
return archive_path
2020-10-15 04:13:09 +00:00
}
async copy_template(from, to) {
return new Promise((res, rej) => {
ncp(from, to, err => {
if ( err ) rej(err)
else res()
})
})
}
async scratch_dir() {
const tmp = require('tmp')
const gen_id = uuid()
2020-10-15 04:13:09 +00:00
return new Promise((res, rej) => {
tmp.dir((err, tmp_path) => {
2020-10-15 04:13:09 +00:00
if ( err ) rej(err)
else {
fs.mkdir(path.resolve(tmp_path, `export`)).then(() => {
res(path.resolve(tmp_path, `export`))
})
}
2020-10-15 04:13:09 +00:00
})
})
}
/**
* Given a page and a template working directory, render that page as HTML.
* @param {Page} page
* @param {string} work_dir
* @return {Promise<string>}
*/
2020-10-15 04:13:09 +00:00
async page_as_html(page, work_dir) {
const Codium = this.models.get('api:Codium')
const FileGroup = this.models.get('api:FileGroup')
const File = this.models.get('upload::File')
const Database = this.models.get('api:db:Database')
const DBEntry = this.models.get('api:db:DBEntry')
2020-10-15 04:13:09 +00:00
let html = ''
const nodes = await page.nodes
for ( const node of nodes ) {
// ATM, there are 5 node types: norm, markdown, database_ref, files_ref, and code_ref
2020-10-15 04:13:09 +00:00
if ( node.Value.Mode === 'norm' ) {
html += node.Value.Value
} else if ( node.Value.Mode === 'markdown' ) {
html += md.toHTML(node.Value.Value)
2020-10-15 04:13:09 +00:00
} else if ( node.Type === 'code_ref' ) {
const code = await Codium.findOne({ UUID: node.Value.Value })
if ( code ) {
const snip_file = `code-snippet-${code.UUID}.txt`
await fs.writeFile(path.resolve(work_dir, snip_file), code.code)
html += `
<div class="code-ref">
<wc-monaco-editor id="${code.UUID}" language="${code.Language}" src="${snip_file}"></wc-monaco-editor>
</div>
`
}
} else if ( node.Type === 'file_ref' ) {
const file_group = await FileGroup.findOne({ UUID: node.Value.Value })
if ( file_group ) {
const file_htmls = []
for ( const file_id of file_group.FileIds ) {
const file = await File.findById(file_id)
if ( file ) {
const store_path = file.provider().filepath(file.store_id)
const ext = file.original_name.split('.').reverse()[0]
await this.copy_template(store_path, path.resolve(work_dir, `file-${file.upload_name}.${ext}`))
2020-10-15 04:13:09 +00:00
file_htmls.push(`
<div class="file">
<div class="file-name">${file.original_name}</div>
<a href="file-${file.upload_name}.${ext}" class="dl-link" target="_blank"></a>
2020-10-15 04:13:09 +00:00
</div>
`)
}
}
html += `
<div class="file-ref">
${file_htmls.join('\n')}
</div>`
}
} else if ( node.Type === 'database_ref' ) {
const grid_id = `dbase-${node.Value.Value}`
const db = await Database.findOne({ UUID: node.Value.Value })
if ( db ) {
html += `
<div id="${grid_id}-container" class="database-container">
<h4>${db.Name}</h4>
<div id="${grid_id}" class="ag-theme-balham database-ref"></div>
</div>
<script src="${grid_id}.js"></script>
`
// generate the column defs
const cols = await db.get_columns()
const col_defs = cols.map(col => {
return {
field: col.field,
headerName: col.headerName,
}
})
// generate the data rows
const entries = await DBEntry.find({ DatabaseId: db.UUID })
const rows = entries.map(entry => entry.RowData)
let dbTemplateContents = await fs.readFile(path.resolve(work_dir, 'database.js'), 'utf-8')
dbTemplateContents = dbTemplateContents.replace(/{{\s?COLUMN_DEFS\s?}}/g, JSON.stringify(col_defs))
dbTemplateContents = dbTemplateContents.replace(/{{\s?ROW_DATA\s?}}/g, JSON.stringify(rows))
dbTemplateContents = dbTemplateContents.replace(/{{\s?GRID_ID\s?}}/g, grid_id)
await fs.writeFile(path.resolve(work_dir, `${grid_id}.js`), dbTemplateContents)
}
2020-10-15 04:13:09 +00:00
}
}
return html
}
}
module.exports = exports = ExportController