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

const Controller = require('libflitter/controller/Controller')
const PageModel = require('../../../models/api/Page.model')
const Node = require('../../../models/api/Node.model')

/*
 * Page Controller
 * -------------------------------------------------------------
 * Put some description here!
 */
class Page extends Controller {
    async get_page(req, res) {
        const PageId = req.params.PageId
        const user = req.user

        const page = await PageModel.findOne({UUID: PageId})
        if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
        if ( !page.accessible_by(user) ) return req.security.deny()

        return res.api(page)
    }

    async save_page(req, res) {
        const PageId = req.params.PageId

        let page;
        if ( PageId ) {
            page = await PageModel.findOne({UUID: PageId})
            if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
            if ( !page.accessible_by(req.user, 'update') ) return req.security.deny()
        } else {
            page = new PageModel
            page.CreatedUserId = req.user.id
            page.OrgUserId = req.user._id
        }

        if ( !req.body.Name ) return res.status(400).message('Missing required: Name').api({})
        page.Name = req.body.Name

        if ( 'IsPublic' in req.body ) {
            page.IsPublic = !!req.body.IsPublic
        }

        if ( 'IsVisibleInMenu' in req.body ) {
            page.IsVisibleInMenu = !!req.body.IsVisibleInMenu
        }

        let parent;
        if ( !req.body.ParentId ) return res.status(400).message('Missing required: ParentId').api({})
        else {
            parent = await PageModel.findOne({UUID: req.body.ParentId})
            if ( !parent ) return res.status(404).message('Parent page not found with that ID.').api({})
            if ( !parent.accessible_by(req.user, 'update') ) return req.security.kickout()
        }

        page.UpdatedAt = new Date
        page.UpdateUserId = req.user._id

        await page.save()
        return res.api(page)
    }

    async get_nodes(req, res) {
        const PageId = req.params.PageId

        let page;
        if ( PageId ) {
            page = await PageModel.findOne({UUID: PageId})
            if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
            if ( !page.accessible_by(req.user) ) return req.security.deny()
        }

        const nodes = await Node.find({PageId: page.UUID});
        const assoc_nodes = {}
        nodes.forEach(node => {
            assoc_nodes[node.UUID] = node
        })

        const return_nodes = [];
        for ( const uuid of page.NodeIds ) {
            return_nodes.push(assoc_nodes[uuid])
        }
        return res.api(return_nodes);
    }

    async save_nodes(req, res) {
        const PageId = req.params.PageId

        let page;
        if ( PageId ) {
            page = await PageModel.findOne({UUID: PageId})
            if ( !page ) return res.status(404).message('Page not found with that ID.').api({})
            if ( !page.accessible_by(req.user, 'update') ) return req.security.deny()
        }

        const nodes = await Node.find({PageId: page.UUID})
        const assoc_nodes = {}
        nodes.forEach(node => {
            assoc_nodes[node.UUID] = node
        })

        if ( !Array.isArray(req.body) ) return res.status(400).message('Invalid request body. Should be array of nodes.').api({})

        const updated_node_ids = []
        for ( let node of req.body ) {
            if ( node.UUID && Object.keys(assoc_nodes).includes(node.UUID) ) updated_node_ids.push(node.UUID)
        }

        console.log('req body', req.body)

        const updated_nodes = []
        for ( let node of req.body ) {
            if ( node.UUID && assoc_nodes[node.UUID] ) {
                assoc_nodes[node.UUID].update_from_raw(node)
                assoc_nodes[node.UUID].UpdatedAt = new Date
                assoc_nodes[node.UUID].UpdateUserId = req.user._id
                updated_nodes.push(assoc_nodes[node.UUID])
            } else {
                const node_obj = new Node({
                    Type: node.Type,
                    Value: node.Value,
                    PageId,
                    CreatedUserId: req.user._id,
                    UpdateUserId: req.user._id,
                })
                await node_obj.save()

                updated_nodes.push(node_obj)
            }
        }

        // console.log('updated nodes', updated_nodes)

        let delete_nodes = nodes
        for ( const node of updated_nodes ) {
            await node.save()
            delete_nodes = delete_nodes.filter(n => {
                return n.UUID !== node.UUID
            })
        }

        for ( const node of delete_nodes ) {
            await node.delete()
        }

        console.log('updated nodes', updated_nodes)

        page.NodeIds = updated_nodes.map(x => x.UUID)
        console.log({page})
        await page.save()

        res.api(updated_nodes)

        // Step 1: make sure the updated nodes are updated
        // Make sure the deleted nodes are deleted
        // Make sure the new nodes are created
        // Make sure the order is correct
    }
}

module.exports = exports = Page