@opengis/admin 0.2.71 → 0.2.73

package/server/plugins/hook.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { readFileSync } from 'node:fs';
 
 import {
     getTemplatePath, addHook, getToken, getTemplate, config, pgClients,
@@ -6,6 +7,7 @@ import {
 } from '@opengis/fastify-table/utils.js';
 
 import getMenu from '../routes/menu/controllers/getMenu.js';
+import printTemplates from '../routes/print/controllers/printTemplates.js';
 
 const { client } = pgClients;
 
@@ -76,12 +78,24 @@ export default async function plugin(fastify) {
         }
     });
 
+    fastify.addHook('onListen', async () => {
+        // insert document templates to db (print API)
+        const printTemplateList = getTemplatePath('print');
+        printTemplateList.filter(el => el[2] === 'json').map((el) => {
+            const settings = JSON.parse(readFileSync(el[1]) || '{}');
+            printTemplates[el[0]] = settings;
+        });
+        if (client?.pk?.['admin.templates']) {
+            console.log('insert into admin.templates', printTemplateList); // test!
+        }
+    });
+
     fastify.addHook('onListen', async () => {
         const clsQuery = [];
         if (!client?.pk?.['admin.cls']) return;
 
-        const selectList = await getTemplatePath('select');
-        const clsList = (await getTemplatePath('cls'))?.filter((el) => !(selectList?.map((el) => el?.[0]) || []).includes(el[0]));
+        const selectList = getTemplatePath('select');
+        const clsList = (getTemplatePath('cls'))?.filter((el) => !(selectList?.map((el) => el?.[0]) || []).includes(el[0]));
         const cls = (selectList || []).concat(clsList || [])
             ?.map((el) => ({ name: el[0], module: path.basename(path.dirname(path.dirname(el[1]))), type: { 'json': 'cls', 'sql': 'select' }[el[2]] }))
         if (!cls?.length) return;

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

@@ -1,15 +1,21 @@
-import { handlebars, getMeta, getTemplate } from '@opengis/fastify-table/utils.js';
+import { getMeta, getTemplate, pgClients, handlebarsSync } from '@opengis/fastify-table/utils.js';
+
+const isValidDate = (dateStr) => (new Date(dateStr)).toString() !== 'Invalid Date';
 
 export default async function calendarData({
-    pg, params = {}, query = {}, session = {},
+    pg = pgClients.client, params = {}, query = {}, session = {},
 }) {
     const { name } = params;
-    const { uid } = session.passport?.user || {};
+    const { granularity = 'month' } = query;
+    const { user = {} } = session.passport || {};
+
     if (!name) {
         return { message: 'not enough params: name', status: 400 };
     }
-    const { date, sql } = query;
-    
+
+    if (query.granularity && !['day', 'month', 'week', 'year'].includes(granularity)) {
+        return { message: 'invalid query params: granularity', status: 400 };
+    }
 
     const body = await getTemplate('calendar', name);
 
@@ -20,10 +26,8 @@ export default async function calendarData({
     const {
         title,
         table,
-        query: query1 = '1=1',
         meta = {},
-        filter = [],
-    } = body;
+    } = body || {};
 
     if (!table) {
         return { message: 'not enough calendar params: table', status: 404 };
@@ -32,57 +36,91 @@ export default async function calendarData({
         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))
+    const filterList = (body?.filter || [])
+        .concat(body?.filterInline || [])
+        .concat(body?.filterCustom || [])
+        .concat(body?.filterState || [])
+        .concat(body?.filterList || [])
+        .concat(body?.filters || [])
+        .concat(body?.filter_list || []);
+
+    const { columns = [] } = await getMeta({ pg, table });
+    const columnList = columns?.map((el) => el?.name);
+
+    const dateColumn = columns?.find((el) => el?.name === (meta?.date || meta?.start))?.name
+        || columns?.find((el) => el?.name === 'cdate')?.name;
+
+    if (query.date && !dateColumn) {
+        return { message: 'invalid template params: date column not found', status: 400 };
+    }
+
+    if (query.date && !isValidDate(query.date)) {
+        return { message: 'Invalid date: out of range or incorrect format', status: 400 };
+    }
+
+    const filterWhere = filterList?.length && query.filter?.length
+        ? filterList
+            .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 ')
+                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 queryWhere = handlebarsSync.compile(body.query || '1=1')({ user, uid: user?.uid });
+    const filterDate = query.date ? `date_trunc('${granularity}', "${dateColumn}"::date)='${query.date}'::date` : undefined;
+
+    const where = [queryWhere, filterDate, filterWhere].filter((el) => el).join(' and ');
+
+    const filtersByColumn = filterList.filter((el) => (Object.hasOwn(el, 'enabled') ? el?.enabled : true) && el?.column);
 
-    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] );
+            const { rows: filterData = [] } = await pg.query(`select ${el.column.replace(/'/g, "''")} as id, count(*) from ${table} 
+            where ${el.query || '1=1'} and ${filterWhere || '1=1'} group by ${el.column.replace(/'/g, "''")}`);
             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));
+
+            const clsData = await getTemplate(['cls', 'select'], el.cls);
+
+            if (!el.cls || !clsData?.length) {
+                filterData.forEach((item) => filters.push(item));
                 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((filter) => {
+                const cls = clsData.find((item) => item.id === filter.id.toString());
+                Object.assign(filter, { title: cls?.text, color: cls?.color });
+                filters.push(filter);
             });
         }));
     }
 
-    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) {
+    const filtersByPreparedQuery = filterList.filter((el) => (Object.hasOwn(el, 'enabled') ? el?.enabled : true) && !el?.column && el?.query);
+
+    if (filtersByPreparedQuery?.length) {
+        await Promise.all(filtersByPreparedQuery.map(async (el) => {
+            const { rows = [] } = await pg.query(`select ${el.query} as id, count(*) from ${table} 
+            where ${filterWhere || '1=1'} group by ${el.query}`);
+            rows.forEach((item) => filters.push(item));
+        }));
+    }
+
+    const metaColumns = Object.keys(meta)
+        .filter((el) => ['date', 'start', 'end', 'title', 'status'].includes(el) && columnList.includes(meta[el]))
+        .map((el) => `"${meta[el]}" as ${el}`);
+
+    if (!metaColumns?.length) {
         return { message: `calendar param meta is invalid: invalid/empty keys`, status: 404 };
     }
 
-    const q = `select &1 from $2 where $3`;
-    if (sql) return q;
+    const q = `select ${metaColumns.join(',')} from ${table} where ${where}`;
+    if (query?.sql && user?.user_type?.includes('admin')) return q;
+
+    const { rows = [] } = await pg.query(q);
 
-    const { rows = [] } = await pg.query(q, [columns.join(','), table, where]); 
-    
-    return { title, filters, rows };
+    return { title, filters, granularity, sql: user?.user_type?.includes('admin') ? q : undefined, rows };
 
 }

package/server/routes/calendar/schema.js

@@ -3,7 +3,7 @@ const calendarDataSchema = {
     name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
   },
   querystring: {
-    date: { type: 'string', pattern: '^([\\d\\s\\/,.:-]+)$' },
+    date: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$' },
     sql: { type: 'string', pattern: '^(\\d)$' },
   },
 

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

@@ -1,5 +1,7 @@
 import path from 'path';
 import qr from 'qrcode';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
 
 import {
@@ -9,6 +11,8 @@ import {
 import { grpc } from '@opengis/fastify-file/utils.js';
 
 const { htmlToPdf } = grpc();
+const filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(filename);
 
 export default async function cardPrint(req, reply) {
     const { pg = pgClients.client, params = {}, query = {}, user = {} } = req;
@@ -62,7 +66,8 @@ export default async function cardPrint(req, reply) {
         return { message: 'data not found', status: 404 };
     }
 
-    const pt = await getTemplate('pt', template);
+    const pt = await getTemplate('pt', template)
+        || await readFile(path.join(dirname, '../../../templates/pt/card-print.pt.hbs'), 'utf8');
 
     const url = (req.protocol || 'https') + '://' + req.hostname + req.url;
     const qrCode = `<img src="${await qr.toDataURL(url, { type: 'png', ec_level: 'M', size: 5, margin: 4 })}" alt="qrcode">`;

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

@@ -0,0 +1,121 @@
+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) {
+    const {
+        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 (!query.preview && !query?.demo && !params?.id) {
+        return { message: 'not enough params: id', status: 400 };
+    }
+
+    /* -- 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())
+        .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)({});
+
+        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 || 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 where = query.demo
+            ? ' 1=1 limit 1'
+            : `${loadTable?.key || pg.pk?.[loadTable?.table || table]}=$1`;
+
+        const q = `select * from (${optimizedSQL})q where ${loadTable?.query || '1=1'} and ${where}`;
+
+        const obj = await pg.query(q, [params.id].filter(el => el))
+            .then(el => el.rows?.[0] || {});
+
+        const html = await handlebars.compile(pt)(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);
+    }
+}

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

@@ -0,0 +1 @@
+export default {}

package/server/routes/print/index.mjs

@@ -1,5 +1,7 @@
-import cardPrint from './controllers/cardPrint.js';
-
-export default async function route(app) {
-  app.get(`/card-print/:table/:id`, cardPrint);
-}
+import cardPrint from './controllers/cardPrint.js';
+import printTemplate from './controllers/printTemplate.js';
+
+export default async function route(app) {
+  app.get(`/card-print/:table/:id`, cardPrint);
+  app.get('/print-template/:name/:id?', printTemplate);
+}