zet-lib 1.3.43 → 1.4.1

package/lib/zViewGenerator.js

@@ -0,0 +1,1064 @@
+const express = require('express');
+const router = express.Router();
+const csrf = require('csurf');
+const csrfProtection = csrf({cookie: true});
+const fs = require("fs-extra");
+const Util = require("./Util");
+const connection = require("./connection");
+const myCache = require("./cache");
+const moduleLib = require("./moduleLib");
+const Model = require('./Model')
+const ejs = require('ejs')
+
+router.get('/', csrfProtection, async (req, res) => {
+    const nots = ['index', 'uploads', 'js', 'css', 'log', 'generator', 'zmenu', 'zgenerator', 'zfields', 'zrole', 'zfunction', 'zgrid', 'zgrid_default', 'zpage', 'zlayout', 'zerror', 'zuser_company']
+    let table = req.query.table || '';
+    let view = req.query.view || '';
+    let route = '';
+    let jsonData = {}
+    let zForms = {}
+    let relations = {}
+    const MYMODELS = myCache.get('MYMODELS')
+    let datas = await viewAttributes(view)
+    zForms.obj = {}
+    let sorting = ''
+    let rows = await connection.results({
+        select: `id, "name", "route",labels, details`,
+        table: 'zviews',
+        orderBy: ['name', 'asc'],
+    })
+    if (view) {
+        table = view;
+        let queries = datas.datas.queries;
+        let contentScript = `var ZFIELDS = ${JSON.stringify(rows, null, 2)};${Util.newLine} var queries = ${JSON.stringify(datas.datas.queries)}`
+        moduleLib.addScript(req, res, contentScript)
+        moduleLib.editor(req, res)
+    }
+    let selectView = `<select name="table" id="table" class="form-control"><option value="">Please Select</option>`
+    rows.map((row) => {
+        let selected = view == row.route ? " selected " : ""
+        selectView += `<option value="${row.route}" ${selected} >${row.name}</option>`
+    })
+    selectView += `</select>`
+    const tables = await connection.results({
+        select: `id, "table", "name", "route",tabs,labels, details, "left","right",one_column, sorting, properties,others,json`,
+        table: 'zfields',
+        orderBy: ['table', 'asc'],
+    })
+    let selectTable = `<select class="form-control form-select" id="select_module_joins">
+                            <option value="">Please Select</option>`
+    tables.map((item) => {
+        selectTable += `<option value="${item.table}">${item.table}</option>`
+    })
+    selectTable += `</select>`
+    //console.log(datas)
+    let layout = 'view_generator'
+    const renderData = {
+        datas,
+        table,
+        view,
+        rows,
+        selectView,
+        tables,
+        selectTable,
+        csrfToken: req.csrfToken(),
+        route: view,
+        selects: jsonData.selects,
+        zForms: zForms,
+        relations: relations,
+        routeName: res.locals.routeName
+    }
+    const bodyView = Util.readFile(require.resolve(__dirname + '/views/zview.ejs'))
+    const bodyHTML = ejs.render(bodyView, renderData)
+    const endHTML = ejs.render(Util.readFile(require.resolve(__dirname + '/views/zviewjs.ejs')), renderData)
+    let dataRender = renderData
+    dataRender.bodyHTML = bodyHTML
+    dataRender.endHTML = endHTML
+    res.render(require.resolve(__dirname + '/views/view_layout.ejs'), dataRender)
+})
+
+router.post('/addview', async (req, res) => {
+    try {
+        console.log(req.body)
+        let body = req.body;
+        let route = Util.toName(body.route);
+        let name = body.name;
+        name = name.trim();
+        let json = Util.jsonSuccess("Success")
+        let forbidden = ['group', 'copy', 'command', 'from', 'select', 'distinct', 'where', 'year', 'month', 'day', 'ignore', 'previous', 'next',
+            'start', 'end', 'set', 'setof', 'show', 'size', 'row', 'rows', 'return', 'order'];
+        if (forbidden.includes(name)) {
+            json = Util.flashError("View Name is Forbidden, try using other module name..", "route");
+            return json;
+        }
+        if (!name.length) {
+            json = Util.flashError("View Name Empty", "route");
+            return json;
+        }
+        let datas = {
+            name: name,
+            route: route,
+            table: route,
+            company_id: 1,
+            sorting: JSON.stringify([2, 1]),
+            created_at: Util.now(),
+            updated_at: Util.now(),
+            created_by: res.locals.userId || 1,
+            updated_by: res.locals.userId || 1,
+        }
+        await connection.insert({
+            table: 'zviews',
+            data: datas,
+        })
+        res.json(json)
+    } catch (err) {
+        res.json(Util.flashError(err.toString()))
+    }
+})
+
+router.post('/fields', async (req, res) => {
+    try {
+        let body = req.body
+        let table = body.table || ''
+        let result = {},
+            fields = {},
+            rowsFields = []
+        if (table) {
+            result = await connection.result({table: 'zviews', where: {table: table}})
+        }
+        let datas = await fieldsBox(result);
+        res.json(datas)
+    } catch (e) {
+        console.log(e)
+        res.json(e.toString())
+    }
+})
+
+router.post('/load-form', async (req, res) => {
+    const table = req.body.table
+    console.log(table)
+    let json = Util.flashError('error')
+    const result = await connection.result({
+        table: 'zviews',
+        where: {
+            table: table,
+        },
+    })
+    if (result.id) {
+        json = Util.jsonSuccess('success')
+        if (!result.router) {
+            result.router = Util.readFile(require.resolve(__dirname + '/views/router.txt'))
+        }
+        if (!result.index_ejs) {
+            result.index_ejs = Util.readFile(require.resolve(__dirname + '/views/index_ejs.txt'))
+        }
+        if (!result.indexcss_ejs) {
+            result.indexcss_ejs = Util.readFile(require.resolve(__dirname + '/views/indexcss_ejs.txt'))
+        }
+        if (!result.indexjs_ejs) {
+            result.indexjs_ejs = Util.readFile(require.resolve(__dirname + '/views/indexjs_ejs.txt'))
+        }
+        if (!result.view_ejs) {
+            result.view_ejs = Util.readFile(require.resolve(__dirname + '/views/view_ejs.txt'))
+        }
+        if (!result.queries) {
+            result.queries = {
+                sql: '',
+                fields: [],
+                tables: []
+            }
+        }
+        json.data = result
+    }
+    res.json(json)
+})
+
+router.post('/load-joins', async (req, res) => {
+    let jsonNotif = Util.jsonSuccess('Success')
+    let html = ''
+    try {
+        let body = req.body
+        console.log(body)
+        let table = body.table
+        html = await loadJoins(table)
+        jsonNotif.html = html
+    } catch (e) {
+        console.log(e)
+    }
+    res.json(jsonNotif)
+})
+
+router.post('/remove-joins', async (req, res) => {
+    let jsonNotif = Util.jsonSuccess('Success')
+    let html = ''
+    try {
+        let body = req.body
+        console.log(body)
+        let table = body.table
+        let table_join = body.table_join
+        let result = await connection.result({
+            table: 'zviews',
+            where: {
+                table: table,
+            },
+        })
+        let resultJoins = result.joins || {}
+        delete resultJoins[table_join]
+
+        await connection.update({
+            table: 'zviews',
+            data: {
+                joins: JSON.stringify(resultJoins),
+            },
+            where: {
+                table: table,
+            },
+        })
+    } catch (e) {
+        console.log(e)
+    }
+    res.json(jsonNotif)
+})
+
+router.post('/joins', async (req, res) => {
+    let jsonNotif = Util.jsonSuccess('Success')
+    let html = ''
+    try {
+        let body = req.body
+        console.log(body)
+        let table = body.table
+        let table_join = body.table_join
+        let result = await connection.result({
+            table: 'zviews',
+            where: {
+                route: table,
+            },
+        })
+        let resultJoins = result.joins || {}
+        resultJoins[table_join] = []
+        let myzfield = await connection.update({
+            table: 'zviews',
+            data: {
+                joins: JSON.stringify(resultJoins),
+            },
+            where: {
+                table: table,
+            },
+        })
+        jsonNotif.json = resultJoins
+        html = await joinHTML(resultJoins, myzfield)
+    } catch (e) {
+        console.log(e)
+        jsonNotif = Util.flashError(e + '')
+    }
+    jsonNotif.html = html
+    res.json(jsonNotif)
+})
+
+
+router.delete('/delete-table', csrfProtection, async (req, res) => {
+    let table = req.body.table
+    let json = Util.jsonSuccess('Successfully delete view')
+    try {
+        await connection.delete({
+            table: 'zviews',
+            where: {
+                route: table,
+            },
+        })
+        //await connection.query("DELETE FROM zfields WHERE `table` = ?", [table]);
+        await connection.query(`DROP VIEW "${table}";`)
+        //delete file
+        let modelFile = dirRoot + '/models/' + table + '.js'
+        fs.stat(modelFile, function (err, stats) {
+            console.log(stats) //here we got all information of file in stats variable
+            if (err) {
+                return console.error(err)
+            } else {
+                fs.unlink(modelFile, function (err) {
+                    if (err) return console.log(err)
+                    console.log('file deleted successfully')
+                })
+            }
+        })
+
+        let routesFile = dirRoot + '/routes/' + table + '.js'
+        fs.stat(routesFile, function (err, stats) {
+            console.log(stats) //here we got all information of file in stats variable
+            if (err) {
+                return console.error(err)
+            } else {
+                fs.unlink(routesFile, function (err) {
+                    if (err) return console.log(err)
+                    console.log('file deleted successfully')
+                })
+            }
+        })
+
+        let runtimeFile = dirRoot + '/public/runtime/script/' + table
+        fs.rm(
+            runtimeFile,
+            {
+                recursive: true,
+            },
+            (error) => {
+                if (error) {
+                    console.log(error)
+                } else {
+                    console.log('Recursive: Directories Deleted!')
+                }
+            }
+        )
+        let runtimeFileHead = dirRoot + '/public/runtime/head/' + table
+        fs.rm(
+            runtimeFileHead,
+            {
+                recursive: true,
+            },
+            (error) => {
+                if (error) {
+                    console.log(error)
+                } else {
+                    console.log('Recursive: Directories Deleted!')
+                }
+            }
+        )
+        let runtimeFileEnd = dirRoot + '/public/runtime/end/' + table
+        fs.rm(
+            runtimeFileEnd,
+            {
+                recursive: true,
+            },
+            (error) => {
+                if (error) {
+                    console.log(error)
+                } else {
+                    console.log('Recursive: Directories Deleted!')
+                }
+            }
+        )
+
+        await connection.delete({
+            table: 'zgrid',
+            where: {route_name: table},
+        })
+        if (table) {
+            const viewsFile = dirRoot + '/views/' + table
+            fs.rm(
+                viewsFile,
+                {
+                    recursive: true,
+                },
+                (error) => {
+                    if (error) {
+                        console.log(error)
+                    } else {
+                        console.log('Recursive: Directories Deleted!')
+                    }
+                }
+            )
+        }
+        await connection.delete({
+            table: 'zgrid_default',
+            where: {table: table},
+        })
+    } catch (e) {
+        json = Util.flashError(e.toString(), '')
+    }
+
+    res.json(json)
+})
+
+router.post('/save_and_generate', csrfProtection, async (req, res) => {
+    try {
+        const json = await generate(req, res)
+        res.json(json)
+    } catch (e) {
+        console.log(e)
+        res.status(200).json({message: e + ''})
+    }
+})
+
+//save to table zviews
+
+const generate = async (req, res) => {
+    const body = req.body
+    console.log(body)
+    const table = body.table
+    const MYMODELS = myCache.get('MYMODELS')
+    let MYMODEL = {}
+    let chains = []
+    let datas = {}
+    let results
+    let dummy = false
+    const details = body.details || [];
+    let left = [], right = [], lefts = [], rights = [], oneColumn = [], oneColumns = [], tabLeft = {}, tabRight = {};
+    const obj = {}
+    obj.notabs = []
+    let labels = {};
+    let hasTab = false;
+    let tabs = {};
+    let joins = {}
+    let rows = await connection.results({table: 'zviews', where: {table: table}})
+    labels = rows[0].labels || {};
+    tabs = !rows[0].tabs ? [] : rows[0].tabs;
+    if (tabs.length) {
+        hasTab = true;
+        tabs.forEach(function (item, i) {
+            obj['arr' + i] = [];
+            tabLeft['arr' + i] = [];
+            tabRight['arr' + i] = [];
+        });
+    }
+    details.forEach(function (item, index) {
+        let name = item.name, value = item.value;
+        if (name.includes("_wtf_")) {
+            let split = name.split("_wtf_")
+            if (!joins[split[0]]) {
+                joins[split[0]] = []
+            }
+            joins[split[0]].push(split[1])
+        }
+        if (name.includes("___")) {
+            const explode = name.split("___");
+            //console.log(explode[1], explode[0])
+            obj[explode[1]].push(explode[0])
+            labels[explode[0]] = value;
+        } else {
+            if (name == 'LEFT') {
+                left.push(value);
+            } else if (name == 'RIGHT') {
+                right.push(value);
+            } else if (name == 'ONE_COLUMN') {
+                oneColumn.push(value);
+            } else {
+                obj['notabs'].push(name);
+                labels[name] = value;
+            }
+        }
+    });
+
+    const sorting = details[1].name == "ONE_COLUMN" ? [1, 2] : [2, 1];
+    for (let key in obj) {
+        if (key == "notabs") {
+            lefts = obj[key].filter((item) => left.includes(item));
+            rights = obj[key].filter((item) => right.includes(item));
+            oneColumns = obj[key].filter((item) => oneColumn.includes(item));
+        } else {
+            let myobj = {}
+            myobj[key] = obj[key].filter((item) => left.includes(item));
+            lefts.push(myobj);
+            myobj = {}
+            myobj[key] = obj[key].filter((item) => right.includes(item));
+            rights.push(myobj);
+            myobj = {}
+            myobj[key] = obj[key].filter((item) => oneColumn.includes(item));
+            oneColumns.push(myobj);
+        }
+    }
+
+    //set properties
+    let properties = {}
+    let propertiesKey = {}
+    for (let key in joins) {
+        let zfieldData = await connection.result({
+            table: "zfields",
+            where: {
+                table: key
+            }
+        })
+        if (!propertiesKey[key]) {
+            propertiesKey[key] = {}
+        }
+        propertiesKey[key] = zfieldData.properties
+        let arr = joins[key] || [];
+        arr.map((item) => {
+            properties[`${key}_wtf_${item}`] = propertiesKey[key][item]
+        })
+    }
+
+    datas.labels = JSON.stringify(labels);
+    datas.details = JSON.stringify(obj);
+    datas.left = JSON.stringify(lefts);
+    datas.right = JSON.stringify(rights);
+    datas.one_column = JSON.stringify(oneColumns);
+    datas.sorting = JSON.stringify(sorting);
+    datas.joins = JSON.stringify(joins);
+    datas.queries = JSON.stringify(body.queries);
+    datas.router = body.router;
+    datas.index_ejs = body.index_ejs;
+    datas.indexcss_ejs = body.indexcss_ejs;
+    datas.indexjs_ejs = body.indexjs_ejs;
+    datas.view_ejs = body.view_ejs;
+    datas.properties = JSON.stringify(properties);
+    await connection.update({
+        table: "zviews",
+        data: datas,
+        where: {
+            table: table
+        }
+    })
+    try {
+        await connection.query(`DROP VIEW ${table}`)
+    } catch (e) {
+        console.log(e)
+    }
+    let sql = ` CREATE OR REPLACE VIEW  ${table} AS ${body.queries.sql};`
+    await connection.query(sql)
+    //create model route views file
+    await createAllFiles(table)
+    //restart pm2 module in production
+    if (process.env.NODE_ENV == 'production') {
+        pm2.connect(function (err) {
+            if (err) {
+                console.log(err.toString())
+            }
+            pm2.restart(process.env.PM2_NAME, (err, proc) => {
+                //io.to(room).emit("message","Restart done")
+            })
+        })
+    }
+
+    return Util.jsonSuccess('Success')
+}
+
+router.post('/set-query', async (req, res) => {
+    try {
+        //joins_checks___item_delivery_order___no_barang
+        let body = req.body;
+        let queries = body.queries;
+        let type = body.type;
+        //type = 1 add -1 delete
+        let field = body.name.replace("joins_checks___", "")
+        let table = field.split(".")[0];
+        let tables = queries.tables || []
+        let fields = queries.fields || []
+        if (type == 1) {
+            if (!fields.includes(field)) {
+                fields.push(field)
+            }
+        } else {
+            if (fields.length > 0) {
+                Util.arrayDelete(fields, field)
+            }
+        }
+        let sql = ``
+        let selects = []
+        if (fields.length > 0) {
+            fields.forEach(function (item) {
+                let split = item.split(".");
+                selects.push(`${split[0]}.${split[1]} as ${split[0]}_wtf_${split[1]}`)
+                if (!tables.includes(split[0])) {
+                    tables.push(split[0])
+                }
+            })
+            sql = `SELECT ${selects.join(", ")}, ${tables[0]}.company_id as company_id, ${tables[0]}.id as id  ${Util.newLine}`;
+            sql += `FROM ${tables[0]}  ${Util.newLine}`
+        }
+        if (tables.length > 1) {
+            let tempfks = {}
+            for (let i = 0; i <= tables.length; i++) {
+                //check foreign key
+                let fks = await connection.query(connection.showFields(tables[i]));
+                fks.map((item) => {
+                    tempfks[item.REFERENCED_TABLE_NAME] = `LEFT JOIN ${item.REFERENCED_TABLE_NAME} ON ${item.TABLE_NAME}.${item.COLUMN_NAME} =  ${item.REFERENCED_TABLE_NAME}.${item.REFERENCED_COLUMN_NAME} `
+                })
+                if (i > 0) {
+                    if (tempfks[tables[i]]) {
+                        sql += tempfks[tables[i]];
+                    }
+                }
+            }
+        }
+        res.json({
+            tables: tables,
+            fields: fields,
+            sql: sql
+        })
+    } catch (e) {
+        console.log(e)
+    }
+})
+
+router.post('/setting_field', csrfProtection, async (req, res) => {
+    let json = Util.jsonSuccess("Success")
+    let html = '';
+    try {
+        const body = req.body
+        const table = body.table
+        const name = body.name
+        const result = await connection.result({ table: 'zviews', where: { table: table } })
+        let properties = result.properties ? result.properties : {};
+        let property = !properties[name] ? {} : properties[name];
+        let type = property.type;
+        html = Model.buildWidget(name, type, property.values || {});
+    } catch (e) {
+        console.log(e)
+        html = Util.flashError(e.toString())
+    }
+    res.json(html)
+})
+
+async function fieldsBox(result) {
+    try {
+        const table = result.route || "";
+        let html = '';
+        var datas = {table: '', tabs: [], labels: {}, details: {}, left: [], right: []};
+        let count = 1;
+        let tabView = '';
+        let tabUl = '';
+        let tabContent = '';
+        let left = '', right = '', oneColumn = '';
+        let hasTab = false;
+        let properties = {}
+        let rowsFields;
+        if (table) {
+            if (result.id) {
+                datas = {
+                    details: result.details || {},
+                    labels: result.labels || {},
+                    tabs: result.tabs || [],
+                    left: result.left || [],
+                    right: result.right || [],
+                    oneColumn: result.one_column || [],
+                    sorting: result.sorting || [],
+                    property: result.properties || {},
+                    joins: result.joins
+                };
+                let details = datas.details;
+                properties = datas.property;
+                let tabs = datas.tabs;
+                if (tabs.length) {
+                    hasTab = true;
+                }
+                if (hasTab) {
+                    tabUl += '<ul class="nav nav-tabs" id="myTab" role="tablist">';
+                    tabContent += '<div class="tab-content" id="myTabContent">';
+                    tabs.forEach(function (item, i) {
+                        const navlink = i == 0 ? ' active' : '';
+                        const ariaselected = i == 0 ? "true" : "false";
+                        const showActive = i == 0 ? ' show active ' : '';
+                        const n = i + 1;
+                        const arrName = 'arr' + i;
+                        let dynamicsLeft = '', dynamicsRight = '', dynamicsOneColumn = '';
+                        let tabLeft = [], tabRight = [], tabOneColum = [];
+                        if (datas.left.length) {
+                            datas.left.forEach(function (o) {
+                                if (typeof o == "object") {
+                                    for (var key in o) {
+                                        if (key == arrName) {
+                                            tabLeft = o[key];
+                                        }
+                                    }
+                                }
+                            });
+                        }
+                        if (datas.right.length) {
+                            datas.right.forEach(function (o) {
+                                if (typeof o == "object") {
+                                    for (var key in o) {
+                                        if (key == arrName) {
+                                            tabRight = o[key];
+                                        }
+                                    }
+                                }
+                            });
+                        }
+                        if (datas.oneColumn.length) {
+                            datas.oneColumn.forEach(function (o) {
+                                if (typeof o == "object") {
+                                    for (var key in o) {
+                                        if (key == arrName) {
+                                            tabOneColum = o[key];
+                                        }
+                                    }
+                                }
+                            });
+                        }
+
+                        if (tabLeft.length) {
+                            tabLeft.map((o) => {
+                                if (datas.property[o] && datas.property[o].hasOwnProperty("type")) {
+                                    dynamicsLeft += dragable_with_icon(o, datas.labels[o], i, "LEFT", datas.property[o].type);
+                                }
+                            });
+                        }
+                        if (tabRight.length) {
+                            tabRight.map((o) => {
+                                if (datas.property[o] && datas.property[o].hasOwnProperty("type")) {
+                                    dynamicsRight += dragable_with_icon(o, datas.labels[o], i, "RIGHT", datas.property[o].type);
+                                }
+                            });
+                        }
+
+                        if (tabOneColum.length) {
+                            tabOneColum.map((o) => {
+                                if (datas.property[o] && datas.property[o].hasOwnProperty("type")) {
+                                    dynamicsOneColumn += dragable_with_icon(o, datas.labels[o], i, "ONE_COLUMN", datas.property[o].type);
+                                }
+                            });
+                        }
+
+                        tabView += `<li class="item" draggable="true"><div class='divtabs'>${n}. <span class="tabname"> ${item}</span><input type='hidden' name='tabs[]' value='${item}' /> <button type='button' class='btn btn-sm btn-info edittab' data-toggle="modal" data-target="#modal_tab" data-name="${item}" data-id="${i}" > <i class='fas fa-edit'></i> </button> <button type='button'  onclick='$(this).parent().remove();' class='btn btn-sm btn-danger trashtab'><i class='fas fa-trash'></i> </button></div></li>`;
+                        tabUl += `<li class="nav-item">
+                                            <a class="nav-link ${navlink}" id="tabid${i}" data-toggle="tab" href="#tabgo${i}" role="tab" aria-controls="tabgo${i}" aria-selected="${ariaselected}">${item}</a>
+                                        </li>`;
+
+                        tabContent += `<div class="tab-pane fade ${showActive}" id="tabgo${i}" role="tabpanel" aria-labelledby="tabtabgo${i}">
+                                             <div class="container">
+                                                    <div class="row">
+                                                        <div class="col-md-6"><ol class="mydragable divbox" data-name="LEFT"  id="arr${i}">${dynamicsLeft}</ol></div>
+                                                        <div class="col-md-6"><ol class="mydragable divbox" data-name="RIGHT" id="arr${i}">${dynamicsRight}</ol></div>
+                                                    </div>
+                                                     <div class="row">
+                                                        <div class="col-md-12"><ol class="mydragable divbox" data-name="ONE_COLUMN"  id="arr${i}">${dynamicsOneColumn}</ol></div>
+                                                     </div>
+                                             </div>
+                                      </div>`;
+                    });
+                    //end tabs
+                    tabUl += '</ul>';
+                    tabContent += '</div>';
+                    count = tabs.length + 1;
+                }
+            }
+        }
+        //caption left or right
+        if (datas.left.length) {
+            datas.left.forEach(function (item) {
+                if (properties.hasOwnProperty(item)) {
+                    left += dragable_with_icon(item, datas.labels[item], "", "LEFT", datas.property[item].type);
+                }
+            });
+        }
+        if (datas.right.length) {
+            datas.right.forEach(function (item) {
+                if (properties.hasOwnProperty(item)) {
+                    right += dragable_with_icon(item, datas.labels[item], "", "RIGHT", datas.property[item].type);
+                }
+            });
+        }
+        if (datas.oneColumn.length) {
+            datas.oneColumn.forEach(function (item) {
+                if (properties.hasOwnProperty(item)) {
+                    oneColumn += dragable_with_icon(item, datas.labels[item], "", "ONE_COLUMN", datas.property[item].type);
+                }
+            });
+        }
+        datas.sorting.forEach(function (item, index) {
+            if (item == 1) {
+                html += columnOne(oneColumn);
+            } else {
+                html += `<div class="row sortable"><i class="fa fa-arrows icon-floats"></i>${columnLR(left, "LEFT")}  ${columnLR(right, "RIGHT")}</div>`;
+            }
+        });
+        let json = {}
+        json.html = html;
+        json.datas = datas;
+        json.tabview = tabView;
+        json.count = count;
+        json.tabBox = tabUl + tabContent;
+
+        return json;
+        //res.json(json);
+    } catch (e) {
+        console.log(e)
+        //res.status(400).json({message: e.toString()})
+        //json = {}
+        return {}
+    }
+}
+
+const zFieldsProperty = async (table, fields) => {
+    let data = {}
+    data.table = table;
+    data.name = Util.fieldToName(table);
+    data.route = table;
+    let label = {}
+    let details = [], lefts = [], rights = [];
+    let nots = Util.nots;
+    //let fields = await connection.query(connection.showFullFields(table));
+    fields.forEach(function (item) {
+        label[item.Field] = Util.fieldToName(item.Field);
+    });
+    data.labels = JSON.stringify(label);
+    let num = 1;
+    fields.forEach(function (item) {
+        if (!Util.in_array(item.Field, nots)) {
+            details.push(item.Field);
+            if (num % 2 == 0) {
+                rights.push(item.Field)
+            } else {
+                lefts.push(item.Field)
+            }
+            num++;
+        }
+    });
+    let notabs = {
+        notabs: details
+    }
+
+    data.details = JSON.stringify(notabs);
+    data.left = JSON.stringify(lefts);
+    data.right = JSON.stringify(rights);
+    return data;
+};
+
+const dragable_with_icon = (name, label, tab, leftright, type = "") => {
+    let myname = tab === "" ? name : name + "___arr" + tab;
+    leftright = leftright || "LEFT";
+    var typeName = type ? Model.keys[type] : "";
+    return `<li id="li${name}">
+<div class="input-group">
+        <div class="input-group-prepend">
+            <span class="input-group-text modal_setting" data-type="${typeName}" data-name="${name}" data-label="${label}" ><i class="fa fa-cog text-info modal_setting" data-type="${typeName}" data-name="${name}" data-label="${label}"></i> </span>
+            <span class="input-group-text can-copy"  data-name="${name}" title="click to copy"><i class="fa fa-copy"></i></span>
+            <span class="input-group-text" >${name}</span>
+            <input type="text" class="form-control" data-name="${name}" name="${myname}" value="${label}">
+            <input type="hidden" name="${leftright}" value="${name}">
+        </div>
+</div><br></li>`;
+};
+
+const columnLR = (items, dataName) => {
+    return `<div class="col-md-6"><ol class="mydragable divboxlittle" data-name="${dataName}">${items}</ol></div>`;
+}
+
+const columnOne = (items) => {
+    return `<div class="row sortable"><i class="fa fa-arrows icon-float"></i><div class="col-md-12"><ol class="mydragable divboxlittle" data-name="ONE_COLUMN">${items}</ol></div></div>`;
+}
+
+
+async function loadJoins(table) {
+    let html = ''
+    try {
+        /*  let sql = `select ${table}.* from ${table}  `;
+        console.log(sql)*/
+        let result = await connection.result({
+            table: 'zviews',
+            where: {
+                table: table,
+            },
+        })
+        let joinsObj = result.joins || {}
+        html = await joinHTML(joinsObj, result)
+    } catch (e) {
+        console.log(e)
+        html = e + ''
+    }
+    return html
+}
+
+async function joinHTML(json, myzfield) {
+    let html = ``
+    try {
+        let zfields = await connection.results({
+            table: 'zfields',
+        })
+        let zfieldsObj = Util.arrayToObject(zfields, 'table')
+        for (let key in json) {
+            html += `<div class="joinContainer col-md-4">`
+            html += `<h5>${zfieldsObj[key].name} <button type="button" class="btn btn-danger" onclick="removeJoins('${key}')"><i class="fa fa-trash "></i> </button></h5>`
+            html += fieldHTML(zfieldsObj[key], myzfield)
+            html += `</div>`
+        }
+    } catch (e) {
+        html = e + ''
+    }
+    return html
+}
+
+function fieldHTML(obj, myzfield) {
+    let html = ``
+    try {
+        let labels = obj.labels
+        let table = obj.table
+        let myzfieldJoins = myzfield.joins || {}
+        for (let key in labels) {
+            let mylabel = labels[key]
+            let selected = ''
+            if (myzfieldJoins[table]) {
+                let arr = myzfieldJoins[table] || []
+                arr.map((item) => {
+                    if (item.key == `${table}.${key}`) {
+                        selected = ` checked `
+                        mylabel = item.value
+                    }
+                })
+            }
+            html += `<div class="input-group">
+                                    <div class="input-group-prepend">
+                                        <span class="input-group-text"><input type="checkbox" ${selected} onclick="checked_join(this)" name="joins_checks___${table}.${key}"></span>
+                                        <span class="input-group-text">${key}</span>
+                                        <input type="text" class="form-control" name="joins_labels___${table}.${key}" id="joins___${table}___${key}" value="${mylabel}">
+                                    </div>
+                                </div>`
+        }
+    } catch (e) {
+        html = e + ''
+    }
+    return html
+}
+
+const viewAttributes = async (tableView = '') => {
+    let result = {}
+    let datas = {}
+    let select = {
+        text: 'Text',
+        textarea: 'Textarea',
+        checkbox: 'Checkbox',
+        number: 'Amount',
+        integer: 'Integer',
+        select: 'Select (static) ',
+        relation: 'Select (relation to other module)',
+        image: 'Image Upload',
+        file: 'File Upload',
+        dropzone: 'Drop Files',
+        email: 'Email',
+        password: 'Password',
+        datepicker: 'Date Picker',
+        datetime: 'Date Time',
+        clockpicker: 'Clock Picker',
+        range: 'Range',
+        color: 'Color Picker',
+        switch: 'Switch',
+        tags: 'Tags',
+        editor: 'Editor',
+        tinymce: 'Editor Tiny MCE',
+        ide_editor: 'IDE Editor (code)',
+        multi_line_editor: 'Multi Line Editor',
+        radio: 'Radio ',
+        typeahead: 'Auto Complete',
+        dropdown_multi: 'Dropdown Multi',
+        lexical: 'Lexical Editor (Experimental)',
+        dropdown_checkbox: 'Dropdown Checkbox',
+        table: 'Table',
+        json: 'JSON',
+        location: 'Location (Google Map)',
+        numeric: 'Numeric/Double',
+        dragdrop: 'Drag Drop',
+        ltree: 'LTree',
+        virtual: 'Virtual Field (readonly)',
+        custom: 'Custom'
+    }
+    if (tableView) {
+        datas = await connection.result({
+            table: "zviews",
+            where: {
+                route: tableView
+            }
+        })
+    } else {
+        datas = {table: '', tabs: [], labels: {}, details: {}, queries: []}
+    }
+
+    return {
+        datas: datas,
+        table: tableView,
+        route: datas.route,
+        name: datas.name
+    }
+}
+
+//create model routes views
+const createAllFiles = async (table) => {
+    let result = await connection.result({
+        table: "zviews",
+        where: {
+            table: table
+        }
+    })
+    let json = {
+        table: result.table,
+        routeName: result.route,
+        title: result.name,
+        hasTabs: false,
+        tabs: [],
+        tabsDetail: {
+            notabs: [],
+        },
+        keys: Object.keys(result.labels),
+        keysExcel: Object.keys(result.labels),
+        labels:result.labels
+    }
+    let fields = {}
+    let options = {}
+    let datas = {}
+    let widgets = {}
+    let grids = {
+        visibles:[],
+        invisibles:[]
+    }
+    let joins = result.joins || {}
+    const MYMODELS = myCache.get('MYMODELS')
+    for (let key in joins) {
+        let MYMODEL = MYMODELS[key]
+        let items = joins[key] || []
+        items.map((item) => {
+            fields[`${key}_wtf_${item}`] = MYMODEL.fields[item]
+            options[`${key}_wtf_${item}`] = MYMODEL.options[item]
+            datas[`${key}_wtf_${item}`] = ""
+            widgets[`${key}_wtf_${item}`] = MYMODEL.widgets[item]
+        })
+    }
+    json.fields = fields
+    json.options = options
+    json.hasApproval = false
+    grids.visibles = json.keys
+    json.grids=grids
+    json.datas=datas
+    json.widgets=widgets
+    json.queries=result.queries
+    json.dataJoins=result.joins
+
+    await connection.delete({
+        table: 'zgrid',
+        where: {
+            route_name: table,
+        },
+    })
+    await connection.delete({
+        table: 'zgrid_default',
+        where: {
+            table: table,
+        },
+    })
+    //insert into zgrid default
+    let datagrid = {
+        company_id: 1,
+        updated_by: 1,
+        created_by: 1,
+        created_at: Util.now(),
+        updated_at: Util.now(),
+    }
+    datagrid.table = table
+    datagrid.visibles = JSON.stringify(json.grids.visibles)
+    datagrid.invisibles = JSON.stringify(json.grids.invisibles)
+    datagrid.fields = JSON.stringify([...json.grids.visibles, ...json.grids.invisibles])
+    await connection.insert({
+        table: 'zgrid_default',
+        data: datagrid,
+    })
+    //create model file
+    let modelContent = `let MYMODEL = ${Util.newLine} ${JSON.stringify(json,null,2)} ${Util.newLine}module.exports=MYMODEL`
+    fs.writeFileSync(`${dirRoot}/models/${table}.js`, modelContent)
+    console.log(`The file model of ${table}.js is saved!`)
+    //create route file
+    fs.writeFileSync(`${dirRoot}/routes/${table}.js`, result.router.replace('[[[TABLE_NAME]]]', table))
+    console.log(`The file model of ${table}.js is saved!`)
+    //create views file
+    let DIR_VIEW = `${dirRoot}/views/${table}`
+    if (!fs.existsSync(DIR_VIEW)) {
+        fs.mkdirSync(DIR_VIEW)
+    }
+    fs.writeFileSync(`${DIR_VIEW}/index.ejs`, result.index_ejs)
+    console.log(`The file model of index.ejs is saved!`)
+    fs.writeFileSync(`${DIR_VIEW}/indexcss.ejs`, result.indexcss_ejs)
+    console.log(`The file model of indexcss.ejs is saved!`)
+    fs.writeFileSync(`${DIR_VIEW}/indexjs.ejs`, result.indexjs_ejs)
+    console.log(`The file model of indexjs.ejs is saved!`)
+    fs.writeFileSync(`${DIR_VIEW}/view.ejs`, result.view_ejs)
+    console.log(`The file model of view.ejs is saved!`)
+}
+
+module.exports = router