265 lines
11 KiB
JavaScript
265 lines
11 KiB
JavaScript
const { Controller } = require('libflitter')
|
|
const FakeRequest = require('../../../FakeRequest')
|
|
const { ObjectId } = require('mongodb')
|
|
|
|
class OfflineController extends Controller {
|
|
static get services() {
|
|
return [...super.services, 'models', 'controllers', 'app']
|
|
}
|
|
|
|
async do_prefetch(req, res, next) {
|
|
const PageModel = this.models.get('api:Page')
|
|
const PageNode = this.models.get('api:Node')
|
|
const Codium = this.models.get('api:Codium')
|
|
const Database = this.models.get('api:db:Database')
|
|
const ColumnDef = this.models.get('api:db:ColumnDef')
|
|
const DBEntry = this.models.get('api:db:DBEntry')
|
|
const FileGroup = this.models.get('api:FileGroup')
|
|
const File = this.models.get('upload::File')
|
|
|
|
const pages = (await PageModel.visible_by_user(req.user)).filter(x => x.Active)
|
|
const page_uuids = pages.map(x => x.UUID)
|
|
|
|
const pageNodes = await PageNode.find({ PageId: { $in: page_uuids }})
|
|
|
|
const codiums = await Codium.find({ PageId: { $in: page_uuids }, Active: true })
|
|
|
|
const databases = await Database.find({ PageId: { $in: page_uuids }, Active: true })
|
|
const database_uuids = databases.map(x => x.UUID)
|
|
|
|
const databaseColumns = await ColumnDef.find({ DatabaseId: { $in: database_uuids }})
|
|
|
|
const databaseEntries = await DBEntry.find({ DatabaseId: { $in: database_uuids }})
|
|
|
|
const fileGroups = (await FileGroup.find({ PageId: { $in: page_uuids }}))
|
|
for ( const grp of fileGroups ) {
|
|
grp.files = await File.find({_id: {$in: grp.FileIds.map(x => ObjectId(x))}})
|
|
}
|
|
|
|
return res.api({
|
|
pages,
|
|
pageNodes,
|
|
codiums,
|
|
databases,
|
|
databaseColumns,
|
|
databaseEntries,
|
|
fileGroups,
|
|
})
|
|
}
|
|
|
|
async do_sync(req, res, next) {
|
|
// TODO account for modify date to not overwrite more recent data!!
|
|
|
|
const OfflineDataSync = this.models.get('api:OfflineDataSync')
|
|
const record = await OfflineDataSync.from_request(req)
|
|
|
|
console.log('sync data', record)
|
|
|
|
const return_maps = {}
|
|
|
|
// pages
|
|
if ( Array.isArray(record.pages) ) {
|
|
return_maps.pages = await this.do_sync_pages(req, record.pages)
|
|
}
|
|
|
|
// pageNodes
|
|
if ( Array.isArray(record.pageNodes) ) {
|
|
return_maps.pageNodes = await this.do_sync_page_nodes(req, record.pageNodes, record.pages)
|
|
}
|
|
|
|
// codiums
|
|
if ( Array.isArray(record.codiums) ) {
|
|
return_maps.codiums = await this.do_sync_codiums(req, record.codiums)
|
|
}
|
|
|
|
// databases
|
|
// databaseColumns
|
|
// databaseEntries
|
|
// fileGroups
|
|
|
|
return res.api(return_maps)
|
|
}
|
|
|
|
async do_sync_codiums(req, codium_recs) {
|
|
const FormCodeController = this.controllers.get('api:v1:FormCode')
|
|
const Codium = this.models.get('api:Codium')
|
|
|
|
const uuid_mapping = {}
|
|
|
|
for ( const rec of codium_recs ) {
|
|
const existing_code = await Codium.findOne({ UUID: rec.UUID })
|
|
|
|
const fake_req = this.app.di().make(FakeRequest)
|
|
await fake_req.inflate(req)
|
|
fake_req.params = { PageId: rec.PageId, NodeId: rec.NodeId, CodiumId: rec.UUID }
|
|
fake_req.body = rec
|
|
|
|
if ( !existing_code && !rec.deleted ) {
|
|
// This was created on the client side
|
|
await FormCodeController.create_new(fake_req, fake_req.response)
|
|
uuid_mapping[rec.UUID] = fake_req.response?._api_data?.UUID
|
|
} else {
|
|
if ( rec.deleted ) {
|
|
// The code was deleted
|
|
await FormCodeController.drop_code(fake_req, fake_req.response)
|
|
uuid_mapping[rec.UUID] = false
|
|
} else {
|
|
// The code was updated
|
|
await FormCodeController.set_values(fake_req, fake_req.response)
|
|
uuid_mapping[rec.UUID] = fake_req.response?._api_data?.UUID
|
|
}
|
|
}
|
|
}
|
|
|
|
return uuid_mapping
|
|
}
|
|
|
|
async do_sync_page_nodes(req, page_node_recs, page_recs) {
|
|
const PageController = this.controllers.get('api:v1:Page')
|
|
const PageModel = this.models.get('api:Page')
|
|
const NodeModel = this.models.get('api:Node')
|
|
|
|
const page_id_x_page = {}
|
|
for ( const page of page_recs ) {
|
|
page_id_x_page[page.UUID] = page
|
|
}
|
|
|
|
const uuid_mapping = {}
|
|
|
|
for ( const rec of page_node_recs ) {
|
|
rec.Value = rec.ValueJSON ? JSON.parse(rec.ValueJSON) : {}
|
|
|
|
const existing_node = await NodeModel.findOne({ UUID: rec.UUID })
|
|
const offline_page = page_id_x_page[rec.PageId]
|
|
let online_page = await PageModel.findOne({ UUID: rec.PageId })
|
|
|
|
if ( existing_node && rec.deleted ) {
|
|
// node that exists on the server was deleted
|
|
if ( online_page ) {
|
|
// if it existed in the online page, delete it
|
|
online_page.NodeIds = online_page.NodeIds.filter(x => x !== rec.UUID)
|
|
await online_page.save()
|
|
}
|
|
|
|
await existing_node.delete()
|
|
uuid_mapping[rec.UUID] = false
|
|
} else if ( existing_node ) {
|
|
// if the node exists, we assume it's already in a page structure
|
|
// update the server-side record if the user can access it
|
|
if ( await online_page.is_accessible_by(req.user, 'edit') ) {
|
|
existing_node.Type = rec.Type
|
|
existing_node.Value = rec.Value
|
|
existing_node.UpdatedAt = new Date(rec.UpdatedAt)
|
|
existing_node.UpdateUserId = req.user.id
|
|
|
|
await existing_node.save()
|
|
uuid_mapping[rec.UUID] = existing_node.UUID
|
|
}
|
|
} else if ( !existing_node && online_page && !rec.deleted ) {
|
|
// the node was created offline
|
|
// first, save the node to the page
|
|
const fake_req = this.app.di().make(FakeRequest)
|
|
await fake_req.inflate(req)
|
|
fake_req.params = { PageId: online_page.UUID }
|
|
fake_req.body = { nodeData: {...rec} }
|
|
|
|
await PageController.save_node_to_page(fake_req, fake_req.response)
|
|
const new_uuid = uuid_mapping[rec.UUID] = fake_req.response?._api_data?.UUID
|
|
online_page = await PageModel.findOne({ UUID: rec.PageId }) // to refresh the model's data
|
|
|
|
// now, try to place the node in the correct spot
|
|
// if first in offline page, make first in online page
|
|
if ( Array.isArray(offline_page?.NodeIds) && offline_page.NodeIds[0] === rec.UUID ) {
|
|
online_page.NodeIds = [new_uuid, ...online_page.NodeIds.filter(x => x !== new_uuid && x !== rec.UUID)]
|
|
} else if ( Array.isArray(offline_page?.NodeIds) && offline_page.NodeIds.includes(rec.UUID) ) {
|
|
if ( offline_page.NodeIds.slice(-1)[0] !== rec.UUID ) {
|
|
// We're not first, and we're not last, so try to place in the correct spot
|
|
const index = offline_page.NodeIds.findIndex(x => x.UUID === rec.UUID)
|
|
let predecessor = undefined
|
|
let index_diff = 1
|
|
|
|
while ( !predecessor && (index - index_diff) >= 0 ) {
|
|
const maybe_predecessor = offline_page.NodeIds[index - index_diff]
|
|
if ( online_page.NodeIds.includes(maybe_predecessor) ) {
|
|
predecessor = maybe_predecessor
|
|
} else {
|
|
index_diff += 1
|
|
}
|
|
}
|
|
|
|
if ( predecessor ) {
|
|
// We found the predecessor to insert the child in the existing node
|
|
const newNodeIds = []
|
|
online_page.NodeIds.forEach(uuid => {
|
|
newNodeIds.push(uuid)
|
|
if ( uuid === predecessor ) {
|
|
newNodeIds.push(new_uuid)
|
|
}
|
|
})
|
|
|
|
online_page.NodeIds = newNodeIds
|
|
}
|
|
}
|
|
}
|
|
|
|
await online_page.save()
|
|
}
|
|
|
|
// assuming the pages were created first, we should never have a case
|
|
// where we have !existing_node && !online_page
|
|
}
|
|
|
|
return uuid_mapping
|
|
}
|
|
|
|
async do_sync_pages(req, page_recs) {
|
|
// TODO order pages by create date to prevent child-before-parent errors
|
|
const PageController = this.controllers.get('api:v1:Page')
|
|
const PageModel = this.models.get('api:Page')
|
|
|
|
const uuid_mapping = {}
|
|
|
|
for ( const rec of page_recs ) {
|
|
const UUID = rec.UUID
|
|
if ( !UUID ) continue;
|
|
|
|
const existing_page = await PageModel.findOne({ UUID })
|
|
const fake_req = this.app.di().make(FakeRequest)
|
|
await fake_req.inflate(req)
|
|
fake_req.body = {...rec}
|
|
|
|
if ( !existing_page && !rec.deleted ) {
|
|
// create the new page
|
|
if ( parseInt(rec.ParentId) === 0 ) {
|
|
// Create a new top-level page
|
|
fake_req.body.omit_starter = true
|
|
fake_req.body.name = rec.Name
|
|
await PageController.create_top_level(fake_req, fake_req.response)
|
|
} else {
|
|
// Create a new child page
|
|
fake_req.body.omit_starter = true
|
|
fake_req.body.name = rec.Name
|
|
fake_req.body.parentId = rec.ParentId
|
|
await PageController.create_child(fake_req, fake_req.response)
|
|
}
|
|
} else if ( existing_page ) {
|
|
fake_req.params = { PageId: rec.UUID }
|
|
|
|
if ( rec.deleted ) {
|
|
// The page was deleted on the client
|
|
await PageController.delete_page(fake_req, fake_req.response)
|
|
} else {
|
|
// update an existing page
|
|
await PageController.save_page(fake_req, fake_req.response)
|
|
}
|
|
}
|
|
|
|
uuid_mapping[rec.UUID] = fake_req.response?._api_data?.UUID || false
|
|
}
|
|
|
|
return uuid_mapping
|
|
}
|
|
}
|
|
|
|
module.exports = exports = OfflineController
|