zet-lib 1.0.0

package/lib/zCache.js

@@ -0,0 +1,326 @@
+const myCache = require("./cache");
+const connection = require('./connection');
+const Util = require('./Util');
+const path = require('path');
+const fs = require('fs-extra');
+const directory = "./";
+const zRoute = require('./zRoute');
+
+const zCache = {};
+
+//constants
+zCache.KEYS = {
+    ROUTES: "ROUTES",
+    TABLES: "TABLES",
+    MYMODELS: "MYMODELS",
+    ROLES: "ROLES",
+    CONFIG: "CONFIG",
+    MENU: "MENU",
+    MENU_SYSTEMS: "MENU_SYSTEMS",
+    ZFUNCTIONS:"ZFUNCTIONS",
+    VERSIONS:"VERSIONS",
+    MODELS_RELATIONS:"MODELS_RELATIONS"
+};
+
+zCache.STATICS = zCache.KEYS;
+zCache.myCache = myCache;
+
+zCache.get = (name) => {
+    if (!myCache.has(name)) {
+        zCache[name]();
+    } else {
+        return myCache.get(name);
+    }
+};
+
+zCache.set = (X, Y) => {
+    myCache.set(X, Y);
+};
+
+zCache.cache = async(req, res, next) => {
+    await cache();
+    next();
+};
+
+const cache = async()=> {
+    zCache.VERSIONS();
+    let i = 0;
+    if (myCache.has("ROLES")) {
+        //console.log("cache ROLES has exist " + i)
+        i = i + 1;
+    } else {
+        //console.log("cache ROLES not exist " + i)
+        await zCache.ROLES();
+    }
+    if (myCache.has("ROUTES")) {
+        i = i + 1;
+    } else {
+        await zCache.ROUTES();
+    }
+    if (myCache.has("TABLES")) {
+        i = i + 1;
+    } else {
+        //console.log("cache TABLES not exist " + i)
+        await zCache.TABLES();
+    }
+    if (myCache.has("CONFIG")) {
+        i = i + 1;
+    } else {
+        //console.log("cache CONFIG not exist " + i)
+        await zCache.CONFIG();
+    }
+    if (myCache.has("MENU")) {
+        i = i + 1;
+    } else {
+        //console.log("cache MENU not exist " + i);
+        //zup.menu();
+        await zCache.MENU();
+    }
+    if (myCache.has("MENU_SYSTEMS")) {
+        //i = i + 1;
+    } else {
+        await zCache.MENU_SYSTEMS();
+    }
+    //console.log(i)
+    if (myCache.has("ZFUNCTIONS")) {
+        //i = i + 1;
+    } else {
+        await zCache.ZFUNCTIONS();
+    }
+    //await zCache.CURRENCIES();
+    //console.log(i)
+    if (i < 5) {
+        await cache();
+    } else {
+        return i;
+    }
+    //cache relations on startup
+    await zCache.MODELS_RELATIONS();
+};
+
+zCache.renew = async()=> {
+    zCache.VERSIONS();
+    await zCache.ROLES();
+    await zCache.MENU();
+    await zCache.CONFIG();
+    await zCache.TABLES();
+    await zCache.ROUTES();
+    await zCache.MENU_SYSTEMS();
+    await zCache.MODELS_RELATIONS();
+};
+
+zCache.ROUTES = () => {
+    if(myCache.has("ROUTES")) {
+        return myCache.get("ROUTES");
+    } else {
+        const routes = zRoute.ROUTES();
+        myCache.set("ROUTES", routes);
+        return routes;
+    }
+};
+
+zCache.TABLES = () => {
+    let routes = zCache.get("ROUTES");
+    let modelsDirectory = path.join(directory, 'models');
+    let tables = [], obj = {};
+    routes.forEach((table) => {
+        if (fs.existsSync(modelsDirectory + "/" + table + ".js")) {
+            tables.push(table);
+            let MYMODEL = require("./../models/" + table);
+            obj[table] = MYMODEL;
+        }
+    });
+    myCache.set("TABLES", tables);
+    myCache.set("MYMODELS", obj);
+    //add to version after set
+    zCache.updateVersions("TABLES")
+    zCache.updateVersions("MYMODELS")
+
+};
+
+zCache.ROLES = async() => {
+    let r = 0;
+    let results = await connection.results({table: "zrole"});
+    let obj = Util.arrayToObject(results, "id");
+    await myCache.set("ROLES", obj);
+    //add to version after set
+    zCache.updateVersions("ROLES");
+    r = 1;
+    return r;
+};
+
+zCache.ZFUNCTIONS = async() => {
+    let query = await connection.results({
+        table : "zfunction",
+        where : {
+            active : 1
+        }
+    })
+    if (query.length) {
+        let results = await connection.results({table: "zfunction"});
+        let obj = Util.arrayToObject(results, "title");
+        await myCache.set("ZFUNCTIONS", obj);
+        //add to version after set
+        zCache.updateVersions("ZFUNCTIONS")
+    }
+};
+
+zCache.VERSIONS = () => {
+    if(myCache.has("VERSIONS")) {
+        //console.log("VERSIONS")
+        return myCache.get("VERSIONS")
+    } else {
+        let obj = {}
+        for(let key in zCache.KEYS) {
+            obj[key] = 0;
+        }
+        myCache.set("VERSIONS",obj);
+        //console.log(JSON.stringify(myCache.get("VERSIONS")))
+        return obj;
+    }
+};
+
+zCache.CONFIG = async() => {
+    let results = async() => {
+        return await connection.results({
+            table: "zconfig"
+        });
+    };
+    let companies = await connection.results({
+        table: "zcompany"
+    });
+    let r = await results();
+    let configObj = Util.arrayToObject(r, "company_id");
+    for (let i = 0; i < companies.length; i++) {
+        let item = companies[i];
+        if (!configObj[item.id]) {
+            await connection.insert({
+                table: "zconfig",
+                data: {
+                    company_id: item.id,
+                    layout: 0,
+                    json: JSON.stringify(CONFIG),
+                    created_at: Util.now(),
+                    updated_at: Util.now()
+                }
+            });
+        }
+    }
+
+    myCache.set(zCache.KEYS.CONFIG, Util.arrayToObject(await results(), "company_id"));
+    //add to version after set
+    zCache.updateVersions(zCache.KEYS.CONFIG)
+};
+
+zCache.MYMODELS = () => {
+    zCache.TABLES();
+}
+
+zCache.MENU = async() => {
+    let results = async() => {
+        return await connection.results({
+            table: "zmenu",
+            where: {
+                active: 1
+            }
+        });
+    };
+    const r = await results();
+    const builder = async() => {
+        let obj = {}
+        let arr = await results();
+        arr.map((item)=> {
+            obj[item.company_id] = item.json || [];
+        });
+        myCache.set("MENU", obj);
+        //add to version after set
+        zCache.updateVersions("MENU")
+    };
+    if (r.length) {
+        await builder();
+    }
+};
+
+zCache.MENU_SYSTEMS = () => {
+    let obj = {};
+    obj.users = [{
+        text: "Users",
+        href: "zuser",
+    },
+        {
+            text: "Company",
+            href: "zcompany",
+        },
+        {
+            text: "User Access",
+            href: "zuser_company",
+        },
+        {
+            text: "Access Role",
+            href: "zrole",
+        }];
+    obj.systems = [
+        {
+            text: "Generator",
+            href: "zgenerator",
+        },
+        {
+            text: "Menu Generator",
+            href: "zmenu",
+        },
+        {
+            text: "Grid Default",
+            href: "zgrid_default",
+        },
+        {
+            text: "Routers",
+            href: "zpage",
+        },
+        {
+            text: "Functions",
+            href: "zfunction",
+        },
+        {
+            text: "Layouts",
+            href: "zlayout",
+        },
+        {
+            text: "Custom Report",
+            href: "zreport",
+        },
+        {
+            text: "Menu Collections",
+            href: "zmenu_collections",
+        },
+        {
+            text: "Log Errors",
+            href: "zerror",
+        }
+    ];
+    myCache.set("MENU_SYSTEMS", obj);
+};
+
+zCache.updateVersions = (name)=> {
+    let obj = myCache.get("VERSIONS") || {}
+    if(!obj.ROLES){
+        zCache.VERSIONS();
+        obj = myCache.get("VERSIONS");
+    }
+    let value = obj[name] || 0;
+    value++;
+    obj[name] = value;
+    myCache.set("VERSIONS",obj);
+};
+
+
+zCache.MODELS_RELATIONS = async() => {
+    if(myCache.has("MODELS_RELATIONS")) {
+        return myCache.get("MODELS_RELATIONS")
+    } else {
+        const obj = await zRoute.modelsCache();
+        myCache.set('MODELS_RELATIONS',obj);
+        return obj;
+    }
+};
+
+module.exports = zCache;

package/lib/zComponent.js

@@ -0,0 +1,27 @@
+const zFn = require('./zFn');
+const connection = require('./connection');
+
+const components = async (...args) => {
+    let title = "", params = [];
+    for (let i = 0; i < args.length; i++) {
+        if(i == 0) {
+            title = args[i];
+        } else {
+            params.push(args[i])
+        }
+    }
+    const result = await connection.result({
+        table : "zcomponent",
+        where : {
+            title : title,
+            active : 1
+        }
+    });
+    if(result.id) {
+        return await zFn(result.code, params);
+    } else {
+        return;
+    }
+};
+
+module.exports = components;

package/lib/zFn.js

@@ -0,0 +1,59 @@
+const moment = require('moment');
+const zRoute = require('./zRoute');
+const io = require("./io");
+const qs = require('qs');
+const axios = require('axios');
+const myCache = require("./cache");
+const connection = require('./connection');
+const Util = require("./Util");
+const moduleLib = require('./moduleLib');
+const zCache = require('./zCache');
+
+const running =  (scripts, params, obj={}) => {
+    const MYMODELS = zRoute.MYMODELS();
+    let stringParams = "";
+    const defaultCall = {
+        Util: Util,
+        connection: connection,
+        io: io,
+        qs: qs,
+        moment:moment,
+        axios:axios,
+        myCache:myCache,
+        zCache:zCache,
+        params:params,
+        MYMODELS:MYMODELS,
+        moduleLib:moduleLib
+    };
+
+    const CALL = Object.assign(defaultCall,obj);
+
+    stringParams = "";
+    for (const keys in CALL) {
+        stringParams += `var ${keys} = this.${keys};`
+    }
+
+    const AsyncFunction = Object.getPrototypeOf(async function () {
+    }).constructor;
+
+    try {
+        return AsyncFunction(`
+        try {
+            ${stringParams};
+            ${scripts};
+        } catch(error) {
+           console.log('error in zfn', error.toString());
+           return {
+                error:true,
+                status : 0,
+                message:error.toString()
+           };
+        }
+    `).call(CALL);
+    } catch (e) {
+        throw new Error(e);
+        return;
+    }
+};
+
+module.exports = running;

package/lib/zFunction.js

@@ -0,0 +1,20 @@
+const zFn = require('./zFn');
+const myCache = require("./cache");
+
+module.exports = (...args) => {
+    let title = "", params = [];
+    for (let i = 0; i < args.length; i++) {
+        if(i == 0) {
+            title = args[i];
+        } else {
+            params.push(args[i])
+        }
+    }
+    let results = myCache.get('ZFUNCTIONS');
+    let result = results[title];
+    if(result.id) {
+        return  zFn(result.code, params);
+    } else {
+        return;
+    }
+};

package/lib/zMenuCollections.js

@@ -0,0 +1,62 @@
+module.exports = (req, res, next) => {
+
+    function menu0() {
+        function mainMenu(obj) {
+            let html = "", span = "", dropdown = "", test = "";
+            const parent = (obj, classname = "") => {
+                let href = obj.href ? "/" + obj.href : "#";
+                let hassub = "", sidebarlink = "", aClass = "", span = obj.text;
+                if (obj.hasOwnProperty("children")) {
+                    hassub = "has-sub";
+                    sidebarlink = "sidebar-link";
+                    aClass = `class="${sidebarlink}"`;
+                    span = `<span>${obj.text}</span>`;
+                }
+                let html = '';
+                let icon = obj.icon ? obj.icon.replace('tabler-', '') : '';
+                let aicon = '';
+                if(icon && icon != "empty"){
+                    aicon = icon ? `<img src="/assets/icons/${icon}.svg" class="tabler-icons icons-black-color" >` : `<i class="${obj.icon}"></i>`;
+                }
+                html += `<li class="${classname}">
+                    <a href="${href}" ${aClass} >
+                    ${aicon}
+                    ${span}
+                    </a>`;
+                if (hassub != "") {
+                    html += child(obj.children);
+                }
+                html += `</li>`;
+
+                return html;
+            };
+
+            const child = (arr) => {
+                let html = '<div class="submenu"><ul>';
+                arr.map((item) => {
+                    html += parent(item, "submenu-item");
+                });
+                html += `</ul></div>`;
+                return html;
+            };
+            let arr = obj.items;
+            html += `<ul class="main-menu">`;
+            arr.map((item) => {
+                let classname = "";
+                if (item.hasOwnProperty("children")) {
+                    classname = "has-submenu ";
+                } else {
+                    classname = "";
+                }
+                html += parent(item, classname);
+            });
+            html += `</ul>`;
+            return html;
+        }
+
+        const html = mainMenu({items: res.locals.MENU_ALL, options: {class: "sidebar-nav"}});
+        res.locals.menu_vertical = html;
+    }
+    menu0();
+    next();
+};