@opengis/admin 0.2.122 → 0.2.123

package/module/settings/menu.json

@@ -39,26 +39,34 @@
     "icon": "IconSettingsCog",
     "menu": [
       {
-        "path": "admin.user-cls",
-        "ua": "Довідники ",
-        "component": "user-cls-page"
-      },
-      {
-        "path": "admin.properties",
-        "table": "admin.properties.table",
+        "path": "admin.settings",
+        "component": "admin-properties-page" , 
         "ua": "Налаштування",
         "en": "Settings"
       },
       {
-        "path": "admin.table_settings",
-        "ua": "Налаштування таблиць",
+        "path": "admin.templates",
+        "ua": "Друк ",
+        "component": "template-print-page"
+      },
+     {
+        "path": "admin.interfaces",
+        "ua": "Таблиці",
         "component": "table-settings-page"
       },
       {
-        "path": "admin.admin_properties",
-        "ua": "Налаштування адміна",
-        "component": "admin-properties-page"
-      }
+        "path": "admin.user-cls",
+        "ua": "Довідники ",
+        "component": "user-cls-page"
+      },
+      {
+        "path": "admin.reports",
+        "ua": "Звіти  ",
+        "component": "reports-page"
+      },
+       { "path": "admin.admin_properties",
+        "ua": "Налаштування адміна", 
+         "table": "admin.properties.table"}
     ]
   }
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/admin",
-  "version": "0.2.122",
+  "version": "0.2.123",
   "description": "This project Softpro Admin",
   "main": "dist/admin.js",
   "type": "module",
@@ -48,9 +48,9 @@
     "@fullcalendar/vue3": "^6.1.15",
     "@opengis/fastify-auth": "^1.0.70",
     "@opengis/fastify-file": "^1.0.42",
-    "@opengis/fastify-table": "^1.2.10",
+    "@opengis/fastify-table": "^1.2.11",
     "@opengis/v3-core": "^0.3.45",
-    "@opengis/v3-filter": "^0.0.68",
+    "@opengis/v3-filter": "^0.0.71",
     "@tabler/icons-vue": "^3.28.1",
     "@tiptap/core": "^2.8.0",
     "@tiptap/extension-color": "^2.8.0",

package/server/plugins/hook.js

@@ -83,10 +83,22 @@ export default async function plugin(fastify) {
         const printTemplateList = getTemplatePath('print');
         printTemplateList.filter(el => el[2] === 'json').map((el) => {
             const settings = JSON.parse(readFileSync(el[1]) || '{}');
+            const htmlPath = printTemplateList.find(item => item[0] === el[0] && ['hbs', 'html'].includes(item[2]))?.[1];
+            const html = htmlPath ? readFileSync(htmlPath, 'utf-8') : null;
+            Object.assign(settings, { html });
             printTemplates[el[0]] = settings;
         });
         if (client?.pk?.['admin.templates']) {
-            console.log('insert into admin.templates', printTemplateList); // test!
+            const arr = Object.keys(printTemplates || {}).map(el => ({ name: el, ...printTemplates?.[el] || {} }));
+
+            const { rowsCount = 0 } = await pgClients.client.query(`delete from admin.templates where not (name=any($1::text[])) and type = 'demo'`, [arr.map(el => el.name)]);
+            console.log('delete deprecated templates', 'ok', rowsCount);
+            const { rowsCount: empty = 0 } = await pgClients.client.query('delete from admin.templates where body is null');
+            console.log('delete empty templates', 'ok', empty);
+
+            const q = arr.map(el => `insert into admin.templates(name, route_id, title, type, body) values ('${el.name.replace(/'/g, "''")}', '${el.route.replace(/'/g, "''")}', '${el.title.replace(/'/g, "''")}', 'demo', '${(el.html || '').replace(/'/g, "''")}') on conflict(name, type) do update set route_id=excluded.route_id, title=excluded.title`).join(';');
+            const res = await pgClients.client.query(q);
+            console.log('insert print templates', 'ok', (Array.isArray(res) ? res : [res]).length);
         }
     });
 

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

@@ -1,6 +1,6 @@
 
 import { join } from 'path';
-import { userTemplateDir, config, getAccess, pgClients } from '@opengis/fastify-table/utils.js';
+import { userTemplateDir, config, pgClients } from '@opengis/fastify-table/utils.js';
 
 import { existsSync, readdirSync, readFileSync } from 'fs';
 const menuCache = [];
@@ -38,8 +38,14 @@ export default async function adminMenu({ user = {}, session, pg = pgClients.cli
 
     if (session && user?.uid && !config.local && !config.admin && !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)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
+        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] || {}); */

package/server/routes/print/controllers/printTemplate.add.js

@@ -0,0 +1,37 @@
+import { pgClients, dataInsert } from '@opengis/fastify-table/utils.js';
+
+export default async function printTemplateAdd({
+    pg = pgClients.client, body = {}, user = {},
+}) {
+    if (!user?.uid) {
+        return { message: 'access restricted', status: 403 };
+    }
+
+    const { name, title, route, html } = body;
+
+    if (!name) {
+        return { message: 'not enough body params: name', status: 400 };
+    }
+
+    if (!html) {
+        return { message: 'not enough body params: html', status: 400 };
+    }
+
+    const id = await pg.query(`select template_id as id from admin.templates where $1 in (template_id, name)`, [name])
+        .then(el => el.rows?.[0]?.id);
+
+    if (id) {
+        return { message: 'access restricted: template exists', status: 403 };
+    }
+
+    const res = await dataInsert({
+        pg,
+        table: 'admin.templates',
+        data: { name, title, route_id: route, body: html, type: 'user' },
+        uid: user?.uid,
+    })
+
+    const data = res.rows?.[0];
+
+    return { id: data?.template_id, data };
+}

package/server/routes/print/controllers/printTemplate.delete.js

@@ -0,0 +1,29 @@
+import { pgClients, dataDelete } from '@opengis/fastify-table/utils.js';
+
+export default async function printTemplateDelete({
+    pg = pgClients.client, params = {}, user = {},
+}) {
+    if (!user?.uid) {
+        return { message: 'access restricted', status: 403 };
+    }
+
+    const { id, type } = await pg.query(`select template_id as id, type from admin.templates where enabled and $1 in (template_id, name)`, [params.id])
+        .then(el => el.rows?.[0] || {});
+
+    if (!id) {
+        return { message: 'template not found', status: 404 };
+    }
+
+    if (type === 'demo') {
+        return { message: 'access restricted: demo', status: 403 };
+    }
+
+    const res = await dataDelete({
+        pg,
+        table: 'admin.templates',
+        id,
+        uid: user?.uid,
+    });
+
+    return { id: res?.template_id, data: res };
+}

package/server/routes/print/controllers/printTemplate.edit.js

@@ -0,0 +1,42 @@
+import { pgClients, dataInsert } from '@opengis/fastify-table/utils.js';
+
+export default async function printTemplateEdit({
+    pg = pgClients.client, params = {}, body = {}, user = {},
+}) {
+    if (!user?.uid) {
+        return { message: 'access restricted', status: 403 };
+    }
+
+    if (!params?.id) {
+        return { message: 'not enough params: id', status: 400 };
+    }
+
+    const { html, route, title } = body;
+
+    if (!html) {
+        return { message: 'not enough body params: html', status: 400 };
+    }
+
+    const { id, name } = await pg.query(`select template_id as id, name from admin.templates where $1 in (template_id, name)`, [params.id])
+        .then(el => el.rows?.[0] || {});
+
+    if (!id) {
+        return { message: 'template not found', status: 404 };
+    }
+
+    await pg.query(`delete from admin.templates where $1 in (template_id, name)`, [id]);
+
+    const data = { name, body: html, type: 'user' };
+    if (title) Object.assign(data, { title });
+    if (route) Object.assign(data, { route_id: route });
+
+    const res = await dataInsert({
+        pg,
+        table: 'admin.templates',
+        id,
+        data,
+        uid: user?.uid,
+    });
+
+    return { id: res.rows?.[0]?.template_id, data: res.rows?.[0] };
+}

package/server/routes/print/controllers/printTemplate.js

@@ -3,8 +3,6 @@ import { createHash } from 'node:crypto';
 import { config, getFilterSQL, getTemplate, handlebars, pgClients } from '@opengis/fastify-table/utils.js';
 import { grpc } from '@opengis/fastify-file/utils.js';
 
-import printTemplates from './printTemplates.js';
-
 const { htmlToPdf } = grpc();
 
 export default async function printTemplate(req, reply) {
@@ -12,110 +10,57 @@ export default async function printTemplate(req, reply) {
         pg = pgClients.client,
         params = {},
         query = {},
-        user = {},
     } = req;
 
     if (!params?.name) {
         return { message: 'not enough params: name', status: 400 };
     }
 
-    const printBody = await getTemplate('print', params.name);
-
-    /* -- params.name === interface -- */
-    if (!printBody?.route) {
-        const where = user?.user_type?.includes('admin')
-            ? '1=1'
-            : `coalesce(b.user_uid, d.user_uid)='${user?.uid?.replace(/'/g, "''")}'::text`;
-
-        const { route_id: routeId, alias } = await pg.query(`select a.route_id, alias
-        from admin.routes a 
-        left join admin.role_access b on 
-            a.route_id=b.route_id
-        left join admin.roles c on 
-            b.role_id=c.role_id 
-            and c.enabled
-        left join admin.user_roles d on 
-            c.role_id=d.role_id 
-            and ( case when 
-                    d.expiration is not null 
-                    then d.expiration > CURRENT_DATE 
-                    else 1=1 
-                end )
-        where $1 in (a.route_id, a.alias, a.table_name) and ${where}`, [params.name])
-            .then(el => el.rows?.[0] || {});
-
-        if (!routeId || !alias) {
-            return { message: `access restricted: route (${params.name}/${routeId})`, status: 403 };
-        }
-
-        const rows = Object.keys(printTemplates)
-            .filter(key => printTemplates[key]?.route === routeId)
-            .map(key => ({ key, title: printTemplates[key]?.title }));
-
-        return { rows };
+    if (!params?.id) {
+        return { message: 'not enough params: id', status: 400 };
     }
 
-    if (!query.preview && !query?.demo && !params?.id) {
-        return { message: 'not enough params: id', status: 400 };
+    const { id, route, body = '' } = await pg.query(`select template_id as id, body, route_id as route from admin.templates where $1 in (template_id,name)`, [params.name])
+        .then(el => el.rows?.[0] || {});
+
+    if (!id) {
+        return reply.status(404).send('template not found');
     }
 
     /* -- params.name === document template -- */
     const format = query.format || (config.debug ? 'html' : 'pdf');
 
     const hash = createHash('md5')
-        .update([query?.preview, query?.demo, params?.name, params?.id].join())
+        .update([params?.name, params?.id].join())
         .digest('hex');
 
     const headers = format === 'pdf'
         ? { 'Content-Disposition': `inline; filename=${hash}.pdf`, 'Content-Type': 'application/pdf' }
         : { 'Content-Type': 'text/html; charset=utf-8' };
 
-    const pt = printBody?.hbs || printBody?.html;
-
-    if (query?.preview) {
-        const matches = pt.match(/{{(?!\!)([^}]*)}}/g);
-        const preview = `<style> #toggle { background: yellow; } </style>`
-            + matches.reduce((acc, curr) => acc.replace(curr, curr.replace(/{{(?!\!)([^}]*)}}/g, `<div id="toggle">${curr.replace(/{/g, '%7B').replace(/}/g, '%7D')}</div>`)), pt);
-
-        const html = await handlebars.compile(preview)({});
+    const table = await pg.query(`select alias from admin.routes where route_id=$1`, [route])
+        .then(el => el.rows?.[0]?.alias);
 
-        if (format == 'html') {
-            return reply.headers(headers).send(html.replace(/%7B/g, '{').replace(/%7D/g, '}'));
-        }
-
-        const result = await htmlToPdf({ html: html.replace(/%7B/g, '{').replace(/%7D/g, '}') });
-        const buffer = Buffer.from(result.result, 'base64');
-        return reply.headers(headers).send(buffer);
+    if (!table) {
+        return { message: 'route table not found', status: 404 };
     }
 
-    if (query?.demo || params?.id) {
-        const table = await pg.query(`select alias from admin.routes where route_id=$1`, [printBody.route])
-            .then(el => el.rows?.[0]?.alias);
-
-        if (!table) {
-            return { message: 'route table not found', status: 404 };
-        }
-
-        const loadTable = await getTemplate('table', table);
-        const { optimizedSQL } = await getFilterSQL({ table, pg });
+    const loadTable = await getTemplate('table', table);
+    const { optimizedSQL } = await getFilterSQL({ table, pg });
 
-        const where = query.demo
-            ? ' 1=1 limit 1'
-            : `${loadTable?.key || pg.pk?.[loadTable?.table || table]}=$1`;
+    const where = `${loadTable?.key || pg.pk?.[loadTable?.table || table]}=$1`;
 
-        const q = `select * from (${optimizedSQL})q where ${loadTable?.query || '1=1'} and ${where}`;
+    const q = `select * from (${optimizedSQL})q where ${loadTable?.query || '1=1'} and ${where}`;
 
-        const obj = await pg.query(q, [params.id].filter(el => el && !query.demo))
-            .then(el => el.rows?.[0] || {});
+    const obj = await pg.query(q, [params.id]).then(el => el.rows?.[0] || {});
 
-        const html = await handlebars.compile(pt)(obj);
+    const html = await handlebars.compile(body)(obj);
 
-        if (format == 'html') {
-            return reply.headers(headers).send(html);
-        }
-
-        const result = await htmlToPdf({ html });
-        const buffer = Buffer.from(result.result, 'base64');
-        return reply.headers(headers).send(buffer);
+    if (format == 'html') {
+        return reply.headers(headers).send(html);
     }
+
+    const result = await htmlToPdf({ html });
+    const buffer = Buffer.from(result.result, 'base64');
+    return reply.headers(headers).send(buffer);
 }

package/server/routes/print/controllers/printTemplateList.js

@@ -0,0 +1,20 @@
+import { pgClients } from "@opengis/fastify-table/utils.js";
+
+const maxLimit = 100;
+
+export default async function printTemplateList({
+    pg = pgClients.client, query = {},
+}) {
+    const { page = 1 } = query;
+
+    const limit = Math.min(maxLimit, +(query.limit || 20));
+
+    const offset = page && page > 0 ? (page - 1) * limit : '0';
+
+    const q = `select template_id as id, name, title, route_id as route, type from admin.templates
+    where enabled limit ${limit} offset ${offset}`;
+
+    const { rows = [] } = pg.pk?.['admin.templates'] ? await pg.query(q) : {};
+
+    return { page, limit, rows };
+}

package/server/routes/print/controllers/printTemplatePreview.js

@@ -0,0 +1,81 @@
+import { createHash } from 'node:crypto';
+
+import { config, getFilterSQL, getTemplate, handlebars, pgClients } from '@opengis/fastify-table/utils.js';
+import { grpc } from '@opengis/fastify-file/utils.js';
+
+const { htmlToPdf } = grpc();
+
+export default async function printTemplate(req, reply) {
+    const {
+        pg = pgClients.client,
+        params = {},
+        query = {},
+    } = req;
+
+    if (!params?.name) {
+        return reply.status(404).send('not enough params: name');
+    }
+
+    const { id, name, title, body = '', route } = await pg.query(`select template_id as id, name, title, body, route_id as route from admin.templates where $1 in (template_id,name)`, [params.name])
+        .then(el => el.rows?.[0] || {});
+
+    if (!id) {
+        return reply.status(404).send('template not found');
+    }
+
+    /* -- params.name === document template -- */
+    const format = query.format || (config.debug ? 'html' : 'pdf');
+
+    const hash = createHash('md5')
+        .update([query?.preview, query?.demo, params?.name].join())
+        .digest('hex');
+
+    const headers = format === 'pdf'
+        ? { 'Content-Disposition': `inline; filename=${hash}.pdf`, 'Content-Type': 'application/pdf' }
+        : { 'Content-Type': 'text/html; charset=utf-8' };
+
+    if (query?.preview) {
+        const matches = body?.match?.(/{{(?!\!)([^}]*)}}/g) || [];
+        const preview = `<style> #toggle { background: yellow; } </style>`
+            + matches.reduce((acc, curr) => acc.replace(curr, curr.replace(/{{(?!\!)([^}]*)}}/g, `<div id="toggle">${curr.replace(/{/g, '%7B').replace(/}/g, '%7D')}</div>`)), body);
+
+        const html = await handlebars.compile(preview)({});
+
+        if (format == 'html') {
+            return reply.headers(headers).send(html.replace(/%7B/g, '{').replace(/%7D/g, '}'));
+        }
+
+        const result = await htmlToPdf({ html: html.replace(/%7B/g, '{').replace(/%7D/g, '}') });
+        const buffer = Buffer.from(result.result, 'base64');
+        return reply.headers(headers).send(buffer);
+    }
+
+    if (query?.demo) {
+        const table = await pg.query(`select alias from admin.routes where route_id=$1`, [route])
+            .then(el => el.rows?.[0]?.alias);
+
+        if (!table) {
+            return reply.status(404).send('route table not found');
+        }
+
+        const loadTable = await getTemplate('table', table);
+        const { optimizedSQL } = await getFilterSQL({ table, pg });
+
+        const q = `select * from (${optimizedSQL})q where ${loadTable?.query || '1=1'} limit 1`;
+
+        const obj = await pg.query(q).then(el => el.rows?.[0] || {});
+
+        const html = await handlebars.compile(body)(obj);
+
+        if (format == 'html') {
+            return reply.headers(headers).send(html);
+        }
+
+        const result = await htmlToPdf({ html });
+        const buffer = Buffer.from(result.result, 'base64');
+        return reply.headers(headers).send(buffer);
+    }
+
+    // for body edit
+    return { name, title, html: body, route };
+}

package/server/routes/print/index.mjs

@@ -1,7 +1,19 @@
 import cardPrint from './controllers/cardPrint.js';
+import printTemplateAdd from './controllers/printTemplate.add.js';
+import printTemplateEdit from './controllers/printTemplate.edit.js';
+import printTemplateDelete from './controllers/printTemplate.delete.js';
 import printTemplate from './controllers/printTemplate.js';
+import printTemplatePreview from './controllers/printTemplatePreview.js';
+import printTemplateList from './controllers/printTemplateList.js';
+
+const policy = ['user'];
 
 export default async function route(app) {
-  app.get(`/card-print/:table/:id`, cardPrint);
-  app.get('/print-template/:name/:id?', printTemplate);
+  app.get(`/card-print/:table/:id`, { config: { policy } }, cardPrint);
+  app.get('/print-template/:name/:id', { config: { policy } }, printTemplate);
+  app.get('/print-template/:name', { config: { policy } }, printTemplatePreview);
+  app.get('/print-template', { config: { policy } }, printTemplateList);
+  app.post('/print-template', { config: { policy } }, printTemplateAdd);
+  app.put('/print-template/:id', { config: { policy } }, printTemplateEdit);
+  app.delete('/print-template/:id', { config: { policy } }, printTemplateDelete);
 }

package/server/routes/properties/controllers/admin.properties.post.js

@@ -3,9 +3,9 @@ const table = 'admin.properties';
 import { setSettings } from '../../../../utils.js';
 
 export default async function postSettingsApp({
-  pg, session = {}, body = {},
+  pg, user = {}, body = {},
 }) {
-  if (session.passport?.user?.user_type !== 'superadmin') {
+  if (!user?.user_type?.includes?.('admin')) {
     return { message: 'access restricted', status: 403 };
   }
   const { key, val } = body;

package/server/routes/properties/index.mjs

@@ -11,7 +11,7 @@ import { propertiesSchema } from './schema.js';
 
 export default async function route(fastify) {
   fastify.get('/settings-app/:key?', { scheme: propertiesSchema }, getSettingsApp);
-  fastify.post('/settings-app', { config: { policy: ['superadmin'] } }, postSettingsApp);
+  fastify.post('/settings-app', { config: { policy: ['admin'] } }, postSettingsApp);
 
   fastify.get('/settings-user/:key?', { scheme: propertiesSchema }, getSettingsUser);
   fastify.post('/settings-user', {}, postSettingsUser);

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

@@ -0,0 +1,76 @@
+import { handlebars, pgClients, getTemplate, metaFormat, handlebarsSync } from '@opengis/fastify-table/utils.js';
+
+import getFilterQuery from '../utils/getFilterQuery.js';
+
+const maxLimit = 100;
+
+export default async function reportData({
+    pg = pgClients.client, params = {}, query = {}, user = {},
+}) {
+    if (!params?.name) {
+        return { message: 'not enough params: name', status: 400 };
+    }
+
+    const loadTemplate = await getTemplate('report', params.name);
+
+    if (!loadTemplate?.sql) {
+        return { message: `report not found: ${params.name}`, status: 404 };
+    }
+
+    const { uid } = user;
+
+    const { kpi, sql, meta, filters } = loadTemplate;
+    const { date, columns: metaColumns } = meta || {};
+
+    const granularity = query.granularity && date && false ? `date_trunc('${query.granularity}',${date})::date::text` : null;
+    const groupby = [meta?.groupby, granularity].filter(el => el).join(',');
+
+    const period = query.period && date ? `${date}=${query.period}` : null;
+    const filter = [query.filter, period].filter(el => el).join(';');
+
+    const limit = Math.min(maxLimit, +(query.limit || 20));
+    const offset = query.page && query.page > 0 ? (query.page - 1) * limit : 0;
+
+    const kpiColumns = kpi ? kpi?.map(el => `${el.sql || 'count(*)'} as "${el.name}"`)?.join(',') : '';
+    const columnsList = metaColumns || loadTemplate.columns?.map(el => el.name)?.join(',');
+
+    const qMeta = await handlebars.compile(sql)({ user, uid });
+    const { fields = [] } = await pg.query(`select * from (${qMeta})q limit 0`);
+
+    const where = filter ? getFilterQuery({ pg, filter, fields, filterList: filters })?.map?.(el => el.query)?.join(' and ') : null;
+
+    const qAgg = `select ${kpiColumns || ''} from (${qMeta})q where ${where || '1=1'}`;
+    const q = `select ${columnsList || '*'} from (${qMeta})q where ${where || '1=1'} ${groupby ? `group by ${groupby}` : ''} limit ${limit} offset ${offset}`;
+
+    if (query.sql && user?.user_type?.includes('admin')) return `${qAgg};${q}`;
+
+    const kpiData = await pg.query(qAgg).then(el => el.rows?.[0] || {});
+    kpi?.forEach(el => Object.assign(el, { count: kpiData[el.name] || '0' }));
+
+    const { rows = [] } = await pg.query(q);
+
+    const cls = meta?.cls || loadTemplate.columns
+        ?.filter(el => (el.option || el.data))
+        ?.reduce((acc, curr) => Object.assign(acc, { [curr.name]: (curr.option || curr.data) }), {});
+
+    const titles = meta?.titles
+        || loadTemplate.columns?.reduce((acc, curr) => Object.assign(acc, { [curr.name]: curr.title }), {});
+
+    await metaFormat({ rows, cls, sufix: true });
+
+    const columns = loadTemplate.columns
+        || fields.map(el => ({
+            name: el.name,
+            title: titles?.[el.name] || el.name,
+            type: cls?.[el.name] ? 'Autocomplete' : 'Text',
+            format: pg.pgType?.[el.dataTypeID],
+            data: cls?.[el.name],
+        }));
+
+    return {
+        q: user?.user_type?.includes('admin') ? q : undefined,
+        kpi,
+        rows,
+        columns,
+    };
+}

package/server/routes/report/controllers/list.js

@@ -0,0 +1,18 @@
+import { getTemplatePath, getTemplate } from '@opengis/fastify-table/utils.js';
+
+export default async function reportList({
+    user = {},
+}) {
+    const arr = getTemplatePath('report').filter(el => el[2] === 'json').map(el => el[0]);
+
+    const rows = await Promise.all(arr.map(async (el) => {
+        const loadTemplate = await getTemplate('report', el);
+        return {
+            name: el,
+            filters: loadTemplate?.filters || [],
+            title: loadTemplate?.title || el,
+            sql: user.user_type?.includes('admin') ? loadTemplate?.sql : undefined,
+        };
+    }));
+    return { rows };
+}

package/server/routes/report/index.mjs

@@ -0,0 +1,7 @@
+import reportData from './controllers/data.js';
+import reportList from './controllers/list.js';
+
+export default async function route(app) {
+  app.get('/reports', {}, reportList);
+  app.get('/reports/:name', {}, reportData);
+}