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

287 lines
10 KiB
JavaScript
Raw Normal View History

2020-02-09 05:09:18 +00:00
const Controller = require('libflitter/controller/Controller')
const Page = require('../../../models/api/Page.model')
const Node = require('../../../models/api/Node.model')
const Database = require('../../../models/api/db/Database.model')
const ColumnDef = require('../../../models/api/db/ColumnDef.model')
const DBEntry = require('../../../models/api/db/DBEntry.model')
/*
* Database Controller
* -------------------------------------------------------------
* Put some description here!
*/
class FormDatabase extends Controller {
async create_new(req, res) {
const PageId = req.params.PageId
let page = await Page.findOne({UUID: PageId})
if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
if ( !(await page.is_accessible_by(req.user, 'update')) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
const NodeId = req.params.NodeId
let node = await Node.findOne({UUID: NodeId})
if ( !node ) return res.status(404).message('Node not found with that ID.').api({})
const db = new Database({
Name: req.body.name ? req.body.name : 'New Database',
NodeId: node.UUID,
PageId: page.UUID,
})
await db.save()
req.user.allow(`database:${db.UUID}`);
await req.user.save()
return res.api(db)
}
async get_config(req, res) {
const PageId = req.params.PageId
let page = await Page.findOne({UUID: PageId})
if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
if ( !(await page.is_accessible_by(req.user)) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
const NodeId = req.params.NodeId
let node = await Node.findOne({UUID: NodeId})
if ( !node ) return res.status(404).message('Node not found with that ID.').api({})
const DatabaseId = req.params.DatabaseId
const db = await Database.findOne({UUID: DatabaseId})
if ( !db ) return res.status(404).message('Database not found with that ID.').api({})
// if ( !db.accessible_by(req.user) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
return res.api(db)
}
async get_columns(req, res) {
const PageId = req.params.PageId
let page = await Page.findOne({UUID: PageId})
if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
if ( !(await page.is_accessible_by(req.user)) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
const NodeId = req.params.NodeId
let node = await Node.findOne({UUID: NodeId})
if ( !node ) return res.status(404).message('Node not found with that ID.').api({})
const DatabaseId = req.params.DatabaseId
const db = await Database.findOne({UUID: DatabaseId})
if ( !db ) return res.status(404).message('Database not found with that ID.').api({})
2020-02-19 07:11:28 +00:00
const columns = []
for ( const col_id of db.ColumnIds ) {
const rec = await ColumnDef.findOne({UUID: col_id})
if ( rec ) {
rec.additionalData = rec.data()
columns.push(rec)
}
}
// Fallback for backwards compat
if ( columns.length < 1 ) {
2020-02-19 07:18:45 +00:00
return res.api((await ColumnDef.find({DatabaseId: db.UUID})).map(x => {
2020-02-19 07:11:28 +00:00
x.additionalData = x.data()
return x
2020-02-19 07:18:45 +00:00
}))
2020-02-19 07:11:28 +00:00
}
2020-02-09 05:09:18 +00:00
return res.api(columns)
}
async set_name(req, res) {
if ( !req.body.Name ) {
return res.status(400)
.message('Missing required field: Name')
.api()
}
const PageId = req.params.PageId
let page = await Page.findOne({UUID: PageId})
if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
if ( !(await page.is_accessible_by(req.user, 'update')) ) return req.security.deny()
const NodeId = req.params.NodeId
let node = await Node.findOne({UUID: NodeId})
if ( !node ) return res.status(404).message('Node not found with that ID.').api({})
const DatabaseId = req.params.DatabaseId
const db = await Database.findOne({UUID: DatabaseId})
if ( !db ) return res.status(404).message('Database not found with that ID.').api({})
// if ( !db.accessible_by(req.user, 'update') ) return req.security.deny()
db.Name = req.body.Name
await db.save()
return res.api(db)
}
2020-02-09 05:09:18 +00:00
async set_columns(req, res) {
const PageId = req.params.PageId
let page = await Page.findOne({UUID: PageId})
if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
if ( !(await page.is_accessible_by(req.user, 'update')) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
const NodeId = req.params.NodeId
let node = await Node.findOne({UUID: NodeId})
if ( !node ) return res.status(404).message('Node not found with that ID.').api({})
const DatabaseId = req.params.DatabaseId
const db = await Database.findOne({UUID: DatabaseId})
if ( !db ) return res.status(404).message('Database not found with that ID.').api({})
// if ( !db.accessible_by(req.user, 'update') ) return req.security.deny()
2020-02-09 05:09:18 +00:00
const existing_columns = await ColumnDef.find({ DatabaseId: db.UUID })
const assoc_columns = []
existing_columns.forEach(col => assoc_columns[col.UUID] = col)
const update_columns = []
for ( const col of req.body.columns ) {
if ( col.UUID && assoc_columns[col.UUID] ) {
assoc_columns[col.UUID].headerName = col.headerName
assoc_columns[col.UUID].field = col.field
assoc_columns[col.UUID].DatabaseId = db.UUID
assoc_columns[col.UUID].Type = col.Type
2020-02-18 17:17:49 +00:00
assoc_columns[col.UUID].additionalData = JSON.stringify(col.additionalData)
2020-02-09 05:09:18 +00:00
await assoc_columns[col.UUID].save()
update_columns.push(assoc_columns[col.UUID])
} else {
const new_col = new ColumnDef({
headerName: col.headerName,
field: col.field,
DatabaseId: db.UUID,
Type: col.Type,
2020-02-18 17:17:49 +00:00
additionalData: JSON.stringify(col.additionalData),
2020-02-09 05:09:18 +00:00
})
await new_col.save()
update_columns.push(new_col)
}
}
for ( const col of existing_columns ) {
if ( !update_columns.includes(col) ) {
await col.delete()
}
}
2020-02-19 07:11:28 +00:00
db.ColumnIds = update_columns.map(x => x.UUID)
await db.save()
2020-02-09 05:09:18 +00:00
return res.api(update_columns)
}
async get_data(req, res) {
const PageId = req.params.PageId
let page = await Page.findOne({UUID: PageId})
if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
if ( !(await page.is_accessible_by(req.user)) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
const NodeId = req.params.NodeId
let node = await Node.findOne({UUID: NodeId})
if ( !node ) return res.status(404).message('Node not found with that ID.').api({})
const DatabaseId = req.params.DatabaseId
const db = await Database.findOne({UUID: DatabaseId})
if ( !db ) return res.status(404).message('Database not found with that ID.').api({})
// if ( !db.accessible_by(req.user) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
const entries = await DBEntry.find({DatabaseId: db.UUID})
entries.forEach(entry => entry.RowData.UUID = entry.UUID)
return res.api(entries)
}
async set_data(req, res) {
const PageId = req.params.PageId
let page = await Page.findOne({UUID: PageId})
if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
if ( !(await page.is_accessible_by(req.user, 'update')) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
const NodeId = req.params.NodeId
let node = await Node.findOne({UUID: NodeId})
if ( !node ) return res.status(404).message('Node not found with that ID.').api({})
const DatabaseId = req.params.DatabaseId
const db = await Database.findOne({UUID: DatabaseId})
if ( !db ) return res.status(404).message('Database not found with that ID.').api({})
// if ( !db.accessible_by(req.user) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
await DBEntry.deleteMany({DatabaseId: db.UUID})
const new_recs = []
for ( const rec of req.body ) {
const data = {DatabaseId: db.UUID}
if ( rec.UUID ) data.UUID = rec.UUID
delete rec.UUID
data.RowData = rec
const dbe = new DBEntry(data)
await dbe.save()
dbe.RowData.UUID = dbe.UUID
new_recs.push(dbe)
}
2020-02-19 07:11:28 +00:00
return res.api(await this._set_indices(db, new_recs))
2020-02-09 05:09:18 +00:00
}
async drop_database(req, res) {
const PageId = req.params.PageId
let page = await Page.findOne({UUID: PageId})
if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
if ( !(await page.is_accessible_by(req.user, 'update')) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
const NodeId = req.params.NodeId
let node = await Node.findOne({UUID: NodeId})
if ( !node ) return res.status(404).message('Node not found with that ID.').api({})
const DatabaseId = req.params.DatabaseId
const db = await Database.findOne({UUID: DatabaseId})
if ( !db ) return res.status(404).message('Database not found with that ID.').api({})
// if ( !db.accessible_by(req.user) ) return req.security.deny()
2020-02-09 05:09:18 +00:00
await DBEntry.deleteMany({DatabaseId: db.UUID})
await db.delete()
return res.api({})
2020-02-09 05:09:18 +00:00
}
2020-02-19 07:11:28 +00:00
async _set_indices(db, data) {
const index_columns = await ColumnDef.find({DatabaseId: db.UUID, Type: 'index'})
for ( const col of index_columns ) {
let max_val = 0
data.forEach(row => {
const val = row.RowData[col.field]
if ( val && val > max_val ) max_val = val
});
let next_val = max_val + 1
for ( const row of data ) {
if ( !row.RowData[col.field] ) {
row.RowData[col.field] = next_val
next_val += 1
await row.save()
}
}
}
return data
}
2020-02-09 05:09:18 +00:00
}
module.exports = exports = FormDatabase