@opengis/admin 0.1.78 → 0.1.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/admin",
-  "version": "0.1.78",
+  "version": "0.1.79",
   "description": "This project Softpro Admin",
   "main": "dist/admin.js",
   "type": "module",
@@ -35,7 +35,7 @@
     "@opengis/admin": "^0.1.69",
     "@opengis/fastify-auth": "^1.0.44",
     "@opengis/fastify-file": "^1.0.27",
-    "@opengis/fastify-table": "^1.1.59",
+    "@opengis/fastify-table": "^1.1.60",
     "@opengis/v3-core": "^0.2.36",
     "@opengis/v3-filter": "^0.0.39",
     "@tiptap/core": "^2.8.0",

package/server/helpers/controllers/token.js

@@ -0,0 +1,16 @@
+import { config, setToken } from "@opengis/fastify-table/utils.js";
+
+export default function token(params) {
+    const { data, hash } = params;
+    if (!hash || typeof hash !== 'object') return '-';
+
+    const id = hash?.edit ? hash?.id : data?.root?.id;
+
+    const [token] = setToken({
+        ids: [JSON.stringify({ ...hash, id })],
+        mode: hash?.edit ? 'w' : 'a',
+        uid: config?.auth?.disable ? '1' : data?.root?.user?.uid,
+        array: 1,
+    });
+    return token;
+}

package/server/helpers/index.mjs

@@ -3,6 +3,7 @@ import _vue from "./controllers/vue.js";
 import map from "./controllers/map.js";
 import _mls from "./controllers/mls.js";
 import badge from "./controllers/badge.js";
+import token from "./controllers/token.js";
 
 import { handlebars } from "@opengis/fastify-table/utils.js";
 
@@ -12,4 +13,5 @@ export default async function route(fastify) {
     handlebars.registerHelper('map', map);
     handlebars.registerHelper('mls', _mls);
     handlebars.registerHelper('badge', badge);
+    handlebars.registerHelper('token', token);
 }

package/server/plugins/hook.js

@@ -17,8 +17,12 @@ export default async function plugin(fastify) {
         const json = await getMenu({ user: { uid: 1 } });
         // insert interface list to db (user access management)
         if (client?.pk?.['admin.routes'] && json?.length) {
-            const menuList = json.filter((el) => el?.menu?.length && el?.ua || el?.en || el?.name);
-            const interfaces = menuList.reduce((acc, curr) => { curr.menu?.forEach((el) => acc.push(el.path)); return acc; }, []);
+            const menuList = json.filter((el) => (el?.table || el?.menu?.length) && el?.ua || el?.en || el?.name);
+            const interfaces = menuList.reduce((acc, curr) => {
+                if (curr.table) { acc.push(curr.path); }
+                curr.menu?.forEach((el) => acc.push(el.path));
+                return acc;
+            }, []);
             await client.query('update admin.routes set enabled=false where not array[route_id] <@ $1::text[]', [interfaces]);
 
             const q = `insert into admin.menu(name, ord) values${menuList.map((el, i) => `('${(el?.ua || el?.en || el?.name).replace(/'/g, '’')}', ${i}) `).join(',')
@@ -27,7 +31,11 @@ export default async function plugin(fastify) {
             await client.query('update admin.menu set enabled=false where not array[menu_id] <@ $1::text[]', [rows.map((el) => el.menu_id)]);
 
             const menus = rows.reduce((acc, curr) => Object.assign(acc, { [curr.menu_id]: menuList.find((item) => (item?.ua || item?.en || item?.name) === curr.name) }), {});
-            const values = Object.entries(menus).reduce((acc, curr) => { curr[1]?.menu?.forEach((el) => acc.push({ ...el, menuId: curr[0] })); return acc; }, []);
+            const values = Object.entries(menus).reduce((acc, curr) => {
+                if (curr[1].table) { acc.push({ ...curr[1], menuId: curr[0] }); }
+                curr[1]?.menu?.forEach((el) => acc.push({ ...el, menuId: curr[0] }));
+                return acc; 
+            }, []);
 
             await Promise.all(values.filter((el) => el?.table).map(async (el) => {
                 const loadTable = await getTemplate('table', el.table);
@@ -38,11 +46,12 @@ export default async function plugin(fastify) {
                 });
             }));
 
-            const q1 = `insert into admin.routes(route_id, alias, title, menu_id, table_name, actions, access) 
-          values ${values.map((el) => `('${el.path}', '${el.table}', ${(el.title || el.ua) ? `'${el.title || el.ua}'` : 'null'}, '${el.menuId}', '${el.table1}', 
-          ${el.actions?.length ? `'{ ${el.actions} }'::text[]` : 'null'}, ${el.access ? `'${el.access}'` : 'null'})`).join(',')} 
-          on conflict (route_id) do update set menu_id=excluded.menu_id, alias=excluded.alias, title=excluded.title, enabled=true,
-          table_name=excluded.table_name, actions=excluded.actions, access=excluded.access returning route_id, table_name`;
+            const q1 = `insert into admin.routes(route_id, alias, title, menu_id, table_name, actions, access, query) 
+            values ${values.filter((el) => el?.table).map((el) => `('${el.path}', '${el.table}', ${(el.title || el.ua) ? `'${el.title || el.ua}'` : 'null'}, '${el.menuId || null}', '${el.table1}', 
+            ${el.actions?.length ? `'{ ${el.actions} }'::text[]` : 'null'}, ${el.access ? `'${el.access}'` : 'null'}, ${el.query ? `'${el.query.replace(/'/g,"''")}'` : '\'1=1\''})`).join(',')} 
+            on conflict (route_id) do update set menu_id=excluded.menu_id, alias=excluded.alias, title=excluded.title, enabled=true, query=excluded.query,
+            table_name=excluded.table_name, actions=excluded.actions, access=excluded.access returning route_id, table_name`;
+
             try {
                 const { rowCount } = values?.length ? await client.query(q1) : {};
                 console.log('interface insert ok', /* values, */ rowCount);

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

@@ -10,80 +10,79 @@ export default async function calendarData({
     }
     const { date, sql } = query;
     
-    try {
-        const body = await getTemplate('calendar', name);
 
-        if (!body) {
-            return { message: `calendar not found: ${name}`, status: 404 };
-        }
+    const body = await getTemplate('calendar', name);
 
-        const {
-            title,
-            table,
-            query: query1 = '1=1',
-            meta = {},
-            filter = [],
-        } = body;
+    if (!body) {
+        return { message: `calendar not found: ${name}`, status: 404 };
+    }
+
+    const {
+        title,
+        table,
+        query: query1 = '1=1',
+        meta = {},
+        filter = [],
+    } = body;
 
-        if (!table) {
-            return { message: 'not enough calendar params: table', status: 404 };
-        }
-        if (!pg.pk?.[table]) {
-            return { message: `table pkey not found: ${table}`, status: 404 };
-        }
+    if (!table) {
+        return { message: 'not enough calendar params: table', status: 404 };
+    }
+    if (!pg.pk?.[table]) {
+        return { message: `table pkey not found: ${table}`, status: 404 };
+    }
 
-        const filterWhere = filter?.length && query.filter?.length
-            ? filter.filter((el) => (Object.hasOwn(el, 'enabled') ? el?.enabled : true))
-                .map((el) => {
-                    const val = query.filter.split(',').find((e) => e?.split('=')?.shift()?.includes(el.column || el.name))?.split('=')?.pop();
-                    if (val) return el.column && val ? `(${[`${el.column}::text='${val.replace(/'/g,"''")}'::text`, el.query].filter((el) => el).join(' and ')})` : el.query;
-                }).filter((el) => el).join(' and ')
-            : undefined;
-        // console.log(filterWhere);
+    const filterWhere = filter?.length && query.filter?.length
+        ? filter.filter((el) => (Object.hasOwn(el, 'enabled') ? el?.enabled : true))
+            .map((el) => {
+                const val = query.filter.split(',').find((e) => e?.split('=')?.shift()?.includes(el.column || el.name))?.split('=')?.pop();
+                if (val) return el.column && val ? `(${[`${el.column}::text='${val.replace(/'/g,"''")}'::text`, el.query].filter((el) => el).join(' and ')})` : el.query;
+            }).filter((el) => el).join(' and ')
+        : undefined;
+    // console.log(filterWhere);
 
         const queryWhere = await handlebars.compile(query1)({ uid });
         const filterDate = date ? `date_trunc('month', "${meta?.date || meta?.start}"::date)='${date}'::date` : undefined;
         const where = [queryWhere, filterDate, filterWhere].filter((el) => el).join(' and ');
 
-        const filtersByColumn = filter.filter((el) => (Object.hasOwn(el, 'enabled') ? el?.enabled : true) && el?.column);
-        
-        const filters = [];
-        if (filtersByColumn?.length) {
-            await Promise.all(filtersByColumn.map(async (el) => {
-                const { rows: filterData = [] } = await pg.query(`select "${el.column}" as id, count(*) from ${table} 
-                where ${el.query || '1=1'} and ${filterWhere || '1=1'} group by "${el.column}"`);
-                if (!filterData?.length) return;
-                
-                // const clsData = await getSelectVal({ pg, name: el.cls, values: filterData.map((el) => el.id) });
-                const clsData = el.cls ? await getTemplate(['cls', 'select'], el.cls) : undefined;
-                
-                if (!el.cls) {
-                    filterData.forEach((el1) => filters.push(el1));
-                    return;
-                }
+    const filtersByColumn = filter.filter((el) => (Object.hasOwn(el, 'enabled') ? el?.enabled : true) && el?.column);
+    
+    const filters = [];
+    if (filtersByColumn?.length) {
+        await Promise.all(filtersByColumn.map(async (el) => {
+            const { rows: filterData = [] } = await pg.query(`select $1 as id, count(*) from $2 
+            where ${el.query || '1=1'} and ${filterWhere || '1=1'} group by $1`, [el.column, table] );
+            if (!filterData?.length) return;
+            
+            // const clsData = await getSelectVal({ pg, name: el.cls, values: filterData.map((el) => el.id) });
+            const clsData = el.cls ? await getTemplate(['cls', 'select'], el.cls) : undefined;
+            
+            if (!el.cls) {
+                filterData.forEach((el1) => filters.push(el1));
+                return;
+            }
 
-                filterData.forEach((el1) => {
-                    const cls = clsData.find((item) => item.id === el1.id.toString());
-                    Object.assign(el1, { title: cls?.text, color: cls?.color });
-                    filters.push(el1);
-                });
-            }));
-        }
+            filterData.forEach((el1) => {
+                const cls = clsData.find((item) => item.id === el1.id.toString());
+                Object.assign(el1, { title: cls?.text, color: cls?.color });
+                filters.push(el1);
+            });
+        }));
+    }
 
-        const tableMeta = await getMeta({ pg, table });
-        const columnList = tableMeta?.columns?.map((el) => el?.name);
-        const columns = Object.keys(meta).filter((el) => ['date', 'start','end','title','status'].includes(el) && columnList.includes(meta[el])).map((el) => `"${meta[el]}" as ${el}`);
-        
-        if (!columns?.length) {
-            return { message: `calendar param meta is invalid: invalid/empty keys`, status: 404 };
-        }
+    const tableMeta = await getMeta({ pg, table });
+    const columnList = tableMeta?.columns?.map((el) => el?.name);
+    const columns = Object.keys(meta).filter((el) => ['date', 'start','end','title','status'].includes(el) && columnList.includes(meta[el])).map((el) => `"${meta[el]}" as ${el}`);
+    
+    if (!columns?.length) {
+        return { message: `calendar param meta is invalid: invalid/empty keys`, status: 404 };
+    }
 
-        const q = `select ${columns.join(',')} from ${table} where ${where}`;
-        if (sql) return q;
+    const q = `select &1 from $2 where $3`;
+    if (sql) return q;
+
+    const { rows = [] } = await pg.query(q, [columns.join(','), table, where]); 
+    
+    return { title, filters, rows };
 
-        const { rows = [] } = await pg.query(q); 
-        return { title, filters, rows };
-    } catch (err) {
-        return { error: err.toString(), status: 500 };
-    }
 }

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

@@ -1,3 +1,5 @@
+import path from 'node:path';
+
 import { config, handlebars, setToken, getTemplate } from "@opengis/fastify-table/utils.js";
 // import yaml from 'js-yaml';
 import getTableData from "./tableData.js";
@@ -7,7 +9,7 @@ export default async function getCardData(req) {
         pg, params = {}, session = {}, user
     } = req;
     const { table, id } = params;
-    const { uid } = session.passport?.user || {};
+    const uid = config?.auth?.disable ? '1' : session.passport?.user?.uid;
 
     const time = Date.now();
 
@@ -16,9 +18,23 @@ export default async function getCardData(req) {
     const tableTemplate = await getTemplate('table', table);
     const index = template?.find(el => el[0] === 'index.yml')?.[1] || {};
 
-    if (index?.tokens) {
-        console.log('hit');
+    if (index?.tokens && typeof index?.tokens === 'object' && !Array.isArray(index?.tokens)) {
+        Object.keys(index?.tokens).map((key) => {
+            const id1 = index.tokens[key]?.edit ? index.tokens[key]?.id : id;
+            const [token] = setToken({
+                ids: [JSON.stringify({ ...index.tokens[key], id: id1 })],
+                mode: index.tokens[key]?.edit ? 'w' : 'a',
+                uid,
+                array: 1,
+            });
+            index.tokens[key] = token;
+        });
     }
+
+    const vue = template
+        .filter((el) => el[0].endsWith('.vue'))
+        .reduce((acc, curr) => Object.assign(acc, { [path.parse(curr[0]).name]: curr[1].match(/<template[^>]*>([\s\S]*?)<\/template>/)[1].trim() }), {});
+
     if (index?.panels?.length) {
         index?.panels.filter((el) => el.props || el.items?.find((item) => item.props))?.forEach((panel) => {
             if (panel.props) {
@@ -45,18 +61,35 @@ export default async function getCardData(req) {
     }
 
     const data = {};
+    if (index?.data && index?.data?.[0]?.name) {
+        await Promise.all(index.data.filter((el) => el?.name && el?.sql).map(async (el) => {
+            const q = await handlebars.compile(el.sql)({ user, uid: user?.uid, id });
+            const { rows = [] } = await pg.query(q);
+            data[el.name] = rows;
+        }));
+    }
+
     const { message, rows = [] } = await getTableData({ pg, params: { table, id }, session, user });
 
     if (message) return { message };
 
+    const html = {};
     if (template) {
         await Promise.all(template.filter(el => el[0].includes('.hbs')).map(async (el) => {
-            const htmlContent = await handlebars.compile(el[1])(rows[0]);
+            const htmlContent = await handlebars.compile(el[1])({ ...rows[0], user });
             const name = el[0].substring(0, el[0].lastIndexOf('.'))
-            data[name] = htmlContent;
+            html[name] = htmlContent;
         }));
     }
 
-    return { time: Date.now() - time, ...index, data, rows, columns: tableTemplate?.columns || tableTemplate?.colModel };
+    return {
+        time: Date.now() - time,
+        ...index,
+        vue,
+        data,
+        html,
+        rows,
+        columns: tableTemplate?.columns || tableTemplate?.colModel,
+    };
 
 }

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

@@ -1,10 +1,13 @@
-
 import getData from '@opengis/fastify-table/server/routes/table/controllers/data.js';
 // import getData from '../../../../../../npm/fastify-table/server/routes/table/controllers/data.js';
 
 export default async function getTableData(req) {
     //const time = Date.now();
-    req.params.query = '1=1'
+    const interfaceName = req.headers?.referer?.match(/.*\/([^?]+)/)?.[1];
+    const { query = '1=1' } = interfaceName ? await req.pg.query(`select query from admin.routes where route_id=$1`, [interfaceName])
+        .then((res1) => res1.rows?.[0] || {}) : {};
+    
+    req.params.query = query;
     const res = await getData(req);
 
     return res;

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

@@ -34,7 +34,7 @@ export default async function tableFilter(req) {
         if (!cls?.length || !Array.isArray(cls) || !loadTable.table || !name) return;
         const { dataTypeID } = columns.find((item) => item?.name === name) || {};
         if (el.extra && el.type === 'select' && Array.isArray(cls)) {
-            const countArr = await pg.query(`select value_text as id, count(*) from crm.extra_data where property_key='${name}' and property_entity='${params.name}' group by value_text`);
+            const countArr = await pg.query(`select value_text as id, count(*) from crm.extra_data where property_key=$1 and property_entity=$2 group by value_text`, [name, params.name]);
             const options = countArr.rows.map(cel => {
                 const data = cls.find(c => c.id === cel.id);
                 return { ...cel, ...data };

package/server/routes/data/schema.js

@@ -2,10 +2,10 @@ const tableDataSchema = {
     querystring: {
         limit: { type: 'string', pattern: '^(\\d+)$' },
         page: { type: 'string', pattern: '^(\\d+)$' },
-        filter: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s(),.!?;:—_=-]+)$' },
-        search: { type: 'string', pattern: '^[А-Яа-яҐґЄєІіЇї\\d\\w\\s(),.!?;:—_=-]+$' },
+        // 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: '^(desc)|(asc)$' },
+        desc: { type: 'string', pattern: '^(\\d+)$' },
         state: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
         custom: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
         bbox: { type: 'string', pattern: '^([\\d\\s,.-]+)$' },

package/server/routes/notifications/controllers/userNotifications.js

@@ -33,14 +33,12 @@ export default async function userNotifications({
 
 
 
-
-
-  const q = `select notification_id as id, subject, body, cdate,
-    author_id, read, link, entity_id, (select avatar from admin.users where uid=a.author_id limit 1) as avatar from crm.notifications a where addressee_id=$1 order by cdate desc limit ${limit} offset ${offset}`;
+    const q = `select notification_id as id, subject, body, cdate,
+    author_id, read, link, entity_id, (select avatar from admin.users where uid=a.author_id limit 1) as avatar from crm.notifications a where addressee_id=$1 order by cdate desc limit $2 offset $3`;
 
   if (query.sql) return q;
 
-  const { rows = [] } = await pg.query(q, [uid]);
+    const { rows = [] } = await pg.query(q, [userId, limit, offset]);
 
   const values = rows.map((el) => el.author_id)
     ?.filter((el, idx, arr) => el && arr.indexOf(el) === idx);

package/server/routes/properties/controllers/user.properties.get.js

@@ -22,13 +22,9 @@ export default async function getUserProperties({
   const cache = await redis.get(keyCache);
   if (cache) return JSON.parse(cache);
 
-  try {
-    const res = await getSettings({
-      pg, key: params.key, json: query.json, redis, table, uid,
-    });
-    return { message: res, status: 200 };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 500 };
-  }
+  const res = await getSettings({
+    pg, key: params.key, json: query.json, redis, table, uid,
+  });
+  
+  return { message: res, status: 200 };
 }

package/server/routes/templates/index.mjs

@@ -1,8 +1,10 @@
 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`, getTemplateApi);
+    fastify.get(`/template/:type/:name`, { scheme: getTemplateSchema },  getTemplateApi);
 
     /*fastify.addHook('onListen', async () => {
         await addTempateFolder(path.join(process.cwd(), '/module/itree'));

package/server/routes/widget/index.mjs

@@ -2,38 +2,10 @@ import widgetDel from './controllers/widget.del.js';
 import widgetSet from './controllers/widget.set.js';
 import widgetGet from './controllers/widget.get.js';
 
-const tableSchema = {
-  params: {
-    // type: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    objectid: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    id: { type: 'string', pattern: '^([\\d\\w]+)$' },
-  },
-  querystring: {
-    debug: { type: 'string', pattern: '^(\\d+)$' },
-  },
-};
+import {tableSchema} from './schema.js'
 
-async function route(fastify, opt) {
-  fastify.route({
-    method: 'DELETE',
-    url: '/widget/:type/:objectid/:id',
-    schema: tableSchema,
-    handler: widgetDel,
-  });
-  fastify.route({
-    method: 'POST',
-    path: '/widget/:type/:objectid/:id?',
-    schema: tableSchema,
-    handler: widgetSet,
-  });
-  fastify.route({
-    method: 'GET',
-    path: '/widget/:type/:objectid',
-    config: {
-      policy: ['public'],
-    },
-    schema: tableSchema,
-    handler: widgetGet,
-  });
+export default async function route(fastify) {
+  fastify.delete(`widget/:type/:objectid/:id`, { scheme: tableSchema }, widgetDel);
+  fastify.post(`/widget/:type/:objectid/:id?`, { scheme: tableSchema }, widgetSet);
+  fastify.get(`/widget/:type/:objectid`, { config: { policy: ['public'] }, scheme: tableSchema }, widgetGet);
 }
-export default route;

package/server/routes/widget/schema.js

@@ -0,0 +1,13 @@
+const tableSchema = {
+    params: {
+      // type: { type: 'string', pattern: '^([\\d\\w]+)$' },
+      objectid: { type: 'string', pattern: '^([\\d\\w]+)$' },
+      id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+    },
+    querystring: {
+      debug: { type: 'string', pattern: '^(\\d+)$' },
+    },
+  };
+
+export default null;
+export { tableSchema }