@opengis/admin 0.3.118 → 0.3.119

package/server/routes/data/controllers/tableData.js

@@ -1,45 +0,0 @@
-import { getOpt, getMeta, getTemplate, getData, pgClients } from '@opengis/fastify-table/utils.js';
-
-export default async function getTableData(req) {
-    const { user = {}, params = {}, query = {}, pg = pgClients.client } = req;
-    const { filter, limit, page, search, sql, state, order } = query || {};
-    const { id } = params || {};
-
-    const tokenData = await getOpt(params.table, user?.uid);
-
-    if (tokenData?.table) {
-        const loadTable = await getTemplate('table', tokenData.table);
-
-        if (!loadTable) {
-            // const resp = await getData({ id, table: params.table, pg, filter, state, limit, page, search, order, user, sql, contextQuery: tokenData.query, sufix: false });
-            // return resp;
-            const { rows = [], fields = [] } = await pg.query(`select ${tokenData.columns || '*'} from ${tokenData.table} where ${tokenData.query || 'true'} limit 10`);
-            const meta = await getMeta({ pg, table: tokenData.table });
-            const columns = (meta?.columns || fields).map(el => ({ name: el.name, type: pg.pgType?.[el.dataTypeID], title: el.title }));
-            return { rows, columns };
-        }
-
-        const resp = await getData({ id, table: tokenData.table, pg, filter, state, limit, page, search, order, user, sql, contextQuery: tokenData.query });
-        return resp;
-    }
-
-    // Це можна 1 раз на старті 
-    const interfaceName = req.headers?.referer?.match(/.*\/([^?]+)/)?.[1];
-    const { query: interfaceQuery } = interfaceName ?
-        await pg.query(`select query from admin.routes where route_id=$1`, [interfaceName])
-            .then(el => el.rows?.[0] || {}) : {};
-
-    // це можна від користувача
-    const { rows = [] } = pg.pk?.['admin.rules'] ? await pg.query(`select attr,(select rule_values from admin.account_grants where account_id in (select account_id from admin.account_users where user_uid=$2) and rule_id=r.rule_id limit 1) from admin.rules r where (select route_id from admin.routes where $1 in (alias,table_name)) = any(routes)`, [params.table, user.uid]) : {};
-
-    const context = rows.filter(el => el.rule_values).map(el => `${el.attr} = any ('{${el.rule_values}}')`).join(' and ');
-    const contextQuery = [interfaceQuery, context].filter(el => el).join(' and ') || ' 2=2 ';
-
-    const res = await getData({
-        id, table: params.table, pg, filter, state, limit, page, search, order, user, sql, contextQuery,
-    });
-    // console.log('contextQuery', contextQuery);
-
-    return res;
-
-}

package/server/routes/data/controllers/tableDataId.js

@@ -1,28 +0,0 @@
-import { handlebars } from "@opengis/fastify-table/utils.js";
-
-import getTemplate from "../../templates/funcs/getTemplate.js";
-import getTableData from "./tableData.js";
-
-export default async function tableDataId({ pg, params = {}, session = {}, user }, reply) {
-    const { name, id } = params;
-
-    const data = await getTemplate('pt', `${name}.pt`);
-
-
-    if (!data) {
-        return { message: `invalid template: ${name}.pt`, status: 400 };
-    }
-    debugger;
-    const { message, status = 500, rows = [] } = await getTableData({ pg, params: { name, id }, session, user });
-    if (message) {
-        return { message, status };
-    }
-
-    if (!rows.length) {
-        return { message: `data not found: ${name}/${id}`, status: 404 };
-    }
-
-    const htmlContent = await handlebars.compile(data)(rows[0]);
-
-    return reply.headers({ 'Content-Type': 'text/html; charset=utf-8' }).send(htmlContent);
-}

package/server/routes/data/controllers/tableFilter.js

@@ -1,10 +0,0 @@
-import { getFilter } from "@opengis/fastify-table/utils.js";
-
-export default async function tableFilter(req) {
-    const { pg, params = {}, query = {}, user = {} } = req;
-
-    const { table } = params;
-    const { filter, custom, state, search } = query;
-    const result = await getFilter({ table, pg, filter, custom, state, search, user });
-    return result;
-}

package/server/routes/data/controllers/tableInfo.js

@@ -1,112 +0,0 @@
-import {
-  getTemplate, getMeta, metaFormat, applyHook, handlebars, pgClients,
-} from '@opengis/fastify-table/utils.js';
-
-export default async function tableInfo(req) {
-    const {
-        pg = pgClients.client, params = {}, query = {}, user = {},
-    } = req;
-
-    const time = Date.now();
-
-    const { uid } = user;
-
-    if (!uid) {
-        return { message: 'access restricted: uid', status: 403 };
-    }
-
-    if (!params?.id || !params?.table) {
-        return { message: 'not enougn params', status: 400 };
-    }
-
-    const loadTable = await getTemplate('table', params.table);
-
-    if (!loadTable) {
-        return { message: 'template not found', status: 404 };
-    }
-
-    const {
-        table, columns = [], sql, cardSql, filters, form, meta, public: ispublic,
-    } = loadTable;
-
-    if (!meta?.info) {
-        return { message: 'empty meta info', status: 400 };
-    }
-
-    const tableMeta = await getMeta(table);
-
-    if (tableMeta?.view) {
-        if (!loadTable?.key) {
-            return { message: `key not found: ${table}`, status: 404 };
-        }
-        Object.assign(tableMeta, { pk: loadTable?.key });
-    }
-
-    const { pk } = tableMeta || {};
-
-    if (!pk) {
-        return { message: `table not found: ${table}`, status: 404 };
-    }
-
-    const sqlTable = sql
-        ?.filter?.((el) => !el?.disabled && el?.sql?.replace)
-        ?.map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', uid)}) ${el.name || `t${i}`} on 1=1 `)
-        ?.join('') || '';
-
-    const cardSqlFiltered = params.id ? (cardSql?.filter?.((el) => !el?.disabled && el?.name && el?.sql?.replace) || []) : [];
-    const cardSqlTable = cardSqlFiltered.length ? cardSqlFiltered.map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', uid)}) ct${i}  on 1=1 `).join('\n') || '' : '';
-
-    const interfaceQuery = params?.query ? await handlebars.compile(params?.query)({ user, uid }) : undefined;
-    const where = [params.id ? `"${pk}" = $1` : null, loadTable.query, interfaceQuery].filter((el) => el).filter((el) => (user?.user_type === 'superadmin' ? !el.includes('{{uid}}') : true));
-
-    const { fields = [] } = await pg.query(`select * from ${table} where ${sqlTable ? 'true' : (where.join(' and ') || 'true')} limit 0`, ([sqlTable ? null : params.id].filter(el => el)) );
-    const columnList = fields.map(el => el.name);
-
-    const metaInfoCols = meta.info.split(',').filter(el => columnList.includes(el)).map((el) => `"${el}"`);
-
-    if (!metaInfoCols.length) {
-        return { message: 'invalid meta info: columns not found', status: 400 };
-    }
-
-    const q = `select  ${pk ? `"${pk}" as id,` : ''} 
-                        ${metaInfoCols.join(',')} 
-                        from (select * from ${table} where ${sqlTable ? 'true' : (where.join(' and ') || 'true')}) t 
-                        ${sqlTable} 
-                        ${cardSqlTable} 
-                        where ${where.join(' and ') || 'true'} 
-                        limit 1`
-        .replace(/{{uid}}/g, uid);
-    
-    // if (user?.user_type === 'superadmin') console.log(q);
-
-    if (query.sql === '1') { return q; }
-
-    const { rows } = await pg.query(q, [params.id]);
-
-    const qCount = `select 
-                count(*)::int as total,  
-                count(*) FILTER(WHERE ${[interfaceQuery].filter(el => el).join(' and ') || 'true'})::int as filtered 
-                from ${table} t ${sqlTable} 
-                where ${[loadTable.query].filter(el => el).join(' and ') || 'true'} `
-        .replace(/{{uid}}/g, uid);
-
-    const { total, filtered } = params.id ? rows.length
-        : await pg.queryCache(qCount, { table: loadTable.table, time: 5 }).then((el) => el?.rows[0]);
-
-    const cls = meta.info.split(',').filter(el => columnList.includes(el))
-        .map(el => ({ name: el, data: columns.find(col => col.name === el)?.data }))
-        .filter(el => el.data)
-        .reduce((acc, curr) => Object.assign(acc, { [curr.name]: curr.data }), {});
-
-    await metaFormat({ rows, cls /* , sufix: false */ });
-
-    const res = {
-        time: Date.now() - time, public: ispublic, card: loadTable.card, total, filtered, count: rows.length, pk, form, rows, meta, columns, filters,
-    };
-
-    const result = await applyHook('afterData', {
-        table: loadTable.table, payload: res, user,
-    });
-
-    return result || res;
-}

package/server/routes/data/controllers/tokenInfo.js

@@ -1,10 +0,0 @@
-import { getOpt, getToken } from "@opengis/fastify-table/utils.js";
-
-export default async function tokenInfo(req) {
-
-    const { params = {}, user } = req;
-    if (user.user_type !== 'admin') return { status: 403, message: 'access restricted' }
-    const tokenData = await getToken({ uid: user.uid, token: params.token, }) || await getOpt(params.token, user.uid)
-    return tokenData;
-
-} 

package/server/routes/data/controllers/utils/assignTokens.js

@@ -1,31 +0,0 @@
-import { config, setToken } from "@opengis/fastify-table/utils.js";
-
-export default function assignTokens({
-    rows = [], ispublic, uid, loadTable = {},
-}) {
-    if (config?.security?.disableToken) return;
-
-    if (!config?.auth?.disable && !ispublic && !uid) throw new Error('empty user');
-    if (!loadTable?.table || !(loadTable?.form || loadTable?.add_form)) return null;
-
-    const form = loadTable?.form || loadTable?.add_form;
-    const addTokens = setToken({
-        ids: [JSON.stringify({ add: loadTable.table, form })],
-        mode: 'a',
-        uid: config?.auth?.disable || ispublic ? '1' : uid,
-        array: 1,
-    });
-    if (!rows.length) return addTokens[0];
-
-    rows.forEach((row) => {
-        const editTokens = setToken({
-            ids: [JSON.stringify({ id: row.id, table: loadTable.table, form })],
-            mode: 'w',
-            uid: config?.auth?.disable || ispublic ? '1' : uid,
-            array: 1,
-        });
-        Object.assign(row, { token: editTokens[0] });
-    });
-    return addTokens[0];
-
-}

package/server/routes/data/controllers/utils/conditions.js

@@ -1,21 +0,0 @@
-function onCheck(rule, data) {
-    const val = data[rule[0]];
-    // console.log(val, rule[1], rule[2])
-    if (rule[1] === '==') return val === rule[2];
-    if (rule[1] === '!=') return val !== rule[2];
-    if (rule[1] === 'in' && rule[2].split) return rule[2].split(',').includes(val);
-    if (rule[1] === 'in' && rule[2].includes) return rule[2].includes(val);
-
-    if (rule[1] === 'not in' && rule[2].split) return !rule[2].split(',').includes(val);
-    if (rule[1] === 'not in' && rule[2].includes) return !rule[2].includes(val);
-
-    if (rule[1] === '>') return val > rule[2];
-    if (rule[1] === '<') return val < rule[2];
-}
-export default function conditions(rules, data) {
-    if (!rules?.length) return true;
-    const result = Array.isArray(rules[0]) ? !rules.filter(el => !onCheck(el, data)).length : onCheck(rules, data)
-    // console.log(rules, result)
-    return result;
-
-}

package/server/routes/data/controllers/utils/getColumns.js

@@ -1,9 +0,0 @@
-import { getTemplate } from "@opengis/fastify-table/utils.js";
-
-export default async function getColumns({
-    columns = [], params = {}, opt = {}, loadTable = {}, form, table, dbColumns = [], mode = 'table',
-}) {
-    const columnList = dbColumns.map((el) => el.name || el).join(',');
-    const cols = columns.filter((el) => columnList.includes(el?.name) && el?.name !== 'geom').map((el) => el?.name || el).join(',');
-    return { cols, columnList };
-}

package/server/routes/data/index.mjs

@@ -1,20 +0,0 @@
-
-import tableData from "./controllers/tableData.js";
-import tokenInfo from "./controllers/tokenInfo.js";
-// import tableDataId from "./controllers/tableDataId.js";
-import cardData from "./controllers/cardData.js";
-import cardTabData from './controllers/cardTabData.js';
-import tableFilter from "./controllers/tableFilter.js";
-
-import { tableDataSchema, tableDataIdSchema, tableFilterSchema, cardTabDataSchema } from './schema.js';
-import tableInfo from "./controllers/tableInfo.js";
-
-export default async function route(fastify) {
-    const policy = ['user'];
-    fastify.get(`/token-info/:token`, { config: { policy: ['admin'] } }, tokenInfo);
-    fastify.get(`/table-data/:table`, { config: { policy: ['user', 'no-sql'] }, schema: tableDataSchema }, tableData);
-    fastify.get(`/card-data/:token`, { config: { policy }, scheme: cardTabDataSchema }, cardTabData);
-    fastify.get(`/table-data/:table/:id`, { config: { policy }, schema: tableDataIdSchema }, cardData);
-    fastify.get(`/table-filter/:table`, { config: { policy }, schema: tableFilterSchema }, tableFilter);
-    fastify.get(`/table-info/:table/:id?`, { config: { policy }, schema: tableDataSchema }, tableInfo);
-}

package/server/routes/data/schema.js

@@ -1,54 +0,0 @@
-const tableDataSchema = {
-    querystring: {
-        limit: { type: 'string', pattern: '^(\\d+)$' },
-        page: { type: 'string', pattern: '^(\\d+)$' },
-        // filter: { type: 'string', pattern: '^([\\w\\d_-]+)=([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
-        // search: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
-        order: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-        desc: { type: 'string', pattern: '^(\\d+)$' },
-        state: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-        custom: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-        bbox: { type: 'string', pattern: '^([\\d\\s,.-]+)$' },
-        polyline: { type: 'string', pattern: '^([\\d\\w|@{}~_`]+)$' },
-        // key: { type: 'string', pattern: '^([\\d\\w_]+)$' },
-        sql: { type: 'string', pattern: '^(\\d)$' },
-    },
-    params: {
-        id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-        table: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-    }
-};
-
-const tableDataIdSchema = {
-    params: {
-        id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-        name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-    }
-};
-
-const tableFilterSchema = {
-    params: {
-        name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-    }
-};
-
-const cardDataSchema = {
-    params: {
-        id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-        table: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-    }
-};
-
-const cardTabDataSchema = {
-    querystring: {
-        sql: { type: 'string', pattern: '^(\\d)$' }
-    },
-    params: {
-        token: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    }
-};
-export { 
-    tableDataSchema, tableDataIdSchema, tableFilterSchema,
-    cardDataSchema, cardTabDataSchema
- }
-export default null;

package/server/routes/menu/controllers/getMenu.js

@@ -1,81 +0,0 @@
-
-import { join } from 'path';
-import { userTemplateDir, pgClients, applyHook, config } from '@opengis/fastify-table/utils.js';
-
-import { existsSync, readdirSync, readFileSync } from 'fs';
-const menuCache = [];
-// check module dir
-const moduleDir = join(process.cwd(), 'module');
-const dirs = existsSync(moduleDir) ?
-    readdirSync(moduleDir).map(el => join(moduleDir, el)) : [];
-
-// all menu files module + user 
-
-
-
-const isProduction = process.env.NODE_ENV === 'production';
-// readMenu();
-
-async function readMenu() {
-    const menuList = dirs.concat(userTemplateDir)
-        .map(el => join(el, 'menu.json'))
-        .filter(el => existsSync(el))
-    // const list = menuList.map(el => readFileSync(el, 'utf-8')); // sync 
-    const list = menuList.filter((el, idx, arr) => el && arr.indexOf(el) === idx).map(el => readFileSync(el, 'utf-8')); // sync 
-    const menus = list.reduce((p, el) => p.concat(JSON.parse(el)), [])
-        .map(el => ({ order: 0, ...el }))
-        .sort((a, b) => (a.order > b.order) ? 1 : ((b.order > a.order) ? -1 : 0))
-
-    if (!menuCache.length) menus.forEach(el => menuCache.push(el))
-    return menus;
-}
-export default async function adminMenu({ user = {}, session, pg = pgClients.client }) {
-    const time = Date.now();
-    if (!user.uid) return { status: 403, message: 'access restricted' }
-
-    const menus = isProduction && menuCache.length ? menuCache : await readMenu();
-
-    const { rows } = await pgClients.client.query(`select property_key as key,property_text as val from admin.properties where property_key~'^(${config.settingKeys || 'site|map|admin'})'`);
-    const settings = rows.reduce((p, { key, val }) => { const [k1, k2] = key.split('.'); p[k1] = p[k1] || {}; p[k1][k2] = val; return p }, {});
-
-    if (config.settings) Object.assign(settings, config.settings);
-
-    // update user access
-    const { user_name, sur_name, father_name, email, phone, uid } = user;
-    const result = { settings, user: { uid, user_name, sur_name, father_name, email, phone } };
-    await applyHook('userMenu', result);
-
-    if (session && user?.uid && !user.user_type?.includes?.('admin') && !user.type?.includes?.('admin') && pg.pk['admin.role_access']) {
-        const { type, gl = [], routes = [] } = await pg.query(`select user_type as type, b.gl,routes from admin.users a
-        left join lateral (
-            select array_agg(role_id) as gl from admin.user_roles 
-            where   user_uid=a.uid 
-            and     role_id in ( select role_id from admin.roles where enabled)
-        )b on 1=1
-        left join lateral (
-            select array_agg(route_id) as routes from admin.role_access where role_id=any(b.gl)
-        )r on 1=1
-        where uid=$1`, [user.uid]).then(el => el.rows[0] || {});
-        /* const { interfaces = [] } = await pg.query(`select array_agg(route_id) as interfaces from admin.role_access
-        where user_uid=$1 or role_id=any($2::text[])`, [user.uid, gl]).then((res) => res.rows?.[0] || {}); */
-
-        Object.assign(user, { type, group_list: gl, routes });
-        session?.set?.('passport', { user });
-
-        if (type?.includes?.('admin')) {
-            return { time: Date.now() - time, menus, ...result };
-        }
-
-        const userMenus = menus.map(el => (el.menu ? { ...el, menu: el.menu.filter(item => routes?.includes(item.path)) } : el))
-        const filtered = userMenus.filter(el => el.menu?.length || routes?.includes(el.path));
-        return { time: Date.now() - time, menus: filtered, ...result }
-        // .filter((el, idx, arr) => arr.map((el) => el?.ua || el?.en || el?.name).indexOf(el?.ua || el?.en || el?.name) === idx)
-    }
-
-    // skip dupes?
-    // .filter((el, idx, arr) => arr.map((el) => el?.ua || el?.en || el?.name).indexOf(el?.ua || el?.en || el?.name) === idx)
-
-    return { time: Date.now() - time, menus, ...result };
-
-
-}

package/server/routes/menu/controllers/interfaces.js

@@ -1,21 +0,0 @@
-import { pgClients, getTemplatePath } from '@opengis/fastify-table/utils.js';
-
-export default async function adminMenu({ pg = pgClients.client }) {
-    const { rows = [] } = await pg.query(`select route_id, alias, table_name, title, enabled from admin.routes`);
-
-    const interfaces = rows
-        .filter((el, idx, arr) => el.table_name && arr.findIndex(item => item.route_id === el.route_id) === idx)
-        .filter(el => pg.pk?.[el.table_name || ''])
-        .filter(el => !['log.', 'admin.', 'setting.'].find(item => el.table_name.startsWith(item)))
-        .map(el => ({
-            title: el.title,
-            alias: el.alias,
-            table: el.table_name,
-            route: el.route_id,
-            enabled: el.enabled,
-        }));
-
-    const all = getTemplatePath('table').map(el => el[0]);
-
-    return interfaces.filter(el => el.alias && all.includes(el.alias));
-}

package/server/routes/menu/index.mjs

@@ -1,7 +0,0 @@
-import getMenu from './controllers/getMenu.js';
-import interfaces from './controllers/interfaces.js';
-
-export default async function (fastify, opts) {
-  fastify.get(`/user-menu`, getMenu);
-  fastify.get(`/interfaces`, { config: { policy: ['admin'] } }, interfaces);
-}

package/server/routes/templates/controllers/getTemplate.js

@@ -1,45 +0,0 @@
-import { config, applyHook, getTemplate, getToken, setToken, handlebarsSync } from "@opengis/fastify-table/utils.js";
-
-function formatSchema(schema, user, opt) {
-    function parseDataTables(obj) {
-        if (obj?.add) {
-            const obj1 = obj.add?.obj?.includes('{{') && opt ? handlebarsSync.compile(obj.add.obj)(opt) : obj.add?.obj;
-            if (obj.add?.obj) obj.add.obj = obj1;
-            const [token] = setToken({
-                ids: [JSON.stringify({ ...obj.add, table: obj.add?.table || obj.add?.model })],
-                uid: user.uid,
-                array: 1,
-            });
-            Object.assign(obj.add, { token, api: `${config.prefix || '/api'}/table/${token}` });
-        } else if (obj?.type === 'DataTable' && obj.colModel?.length) {
-            obj.colModel.forEach(parseDataTables);
-        }
-    }
-    Object.keys(schema || {}).map(key => ({ key, ...schema[key] })).forEach(parseDataTables);
-}
-
-export default async function getTemplateApi(req) {
-    const { user } = req || {};
-    const { params = {} } = req;
-    const { type, name } = params;
-
-    const tokenData = await getToken({ token: name, uid: user?.uid, json: 1 }) || {};
-
-    const hookData = await applyHook('preTemplate', { name: tokenData.name || name, type, user });
-    if (hookData?.message && hookData?.status) return hookData;
-
-    const data = await getTemplate(type, hookData?.name || tokenData.form || name);
-
-    if (tokenData.obj) {
-        const obj = tokenData.obj.split('#').reduce((p, el) => ({ ...p, [el.split('=')[0]]: el.split('=')[1] }), {})
-        Object.assign(data, { obj });
-    }
-
-    if (type === 'form' && user?.uid) {
-        const schema = data?.schema || data;
-        formatSchema(schema, user, data?.obj);
-    }
-
-    await applyHook('afterTemplate', { name, type, data, user });
-    return data?.html || data || `template not found "${name}"`;
-}

package/server/routes/templates/index.mjs

@@ -1,16 +0,0 @@
-import getTemplateApi from './controllers/getTemplate.js';
-
-import getTemplateSchema from './schema.js'
-
-export default async function route(fastify) {
-    //fastify.decorate('addTempateFolder', addTempateFolder); // call from funcs
-    fastify.get(`/template/:type/:name`, { config: { policy: ['public'] }, scheme: getTemplateSchema },  getTemplateApi);
-
-    /*fastify.addHook('onListen', async () => {
-        await addTempateFolder(path.join(process.cwd(), '/module/itree'));
-        await addTempateFolder(path.join(process.cwd(), '/module/test'));        
-      });*/
-
-
-
-}

package/server/routes/templates/schema.js

@@ -1,9 +0,0 @@
-const getTemplateSchema = {
-    params: {
-        name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-        // type: { type: 'string' },
-    }
-};
-
-export default null;
-export { getTemplateSchema }