@opengis/fastify-table 1.4.70 → 1.4.72

package/index.js

@@ -33,6 +33,7 @@ import loggerRoutes from './server/routes/logger/index.js';
 import propertiesRoutes from './server/routes/properties/index.js';
 import tableRoutes from './server/routes/table/index.js';
 import utilRoutes from './server/routes/util/index.js';
+import accessRoutes from './server/routes/access/index.mjs';
 
 // utils
 import addTemplateDir from './server/plugins/table/funcs/addTemplateDir.js';
@@ -138,6 +139,7 @@ async function plugin(fastify, opt) {
   propertiesRoutes(fastify, opt);
   tableRoutes(fastify, opt);
   utilRoutes(fastify, opt);
+  accessRoutes(fastify, opt);
   widgetRoutes(fastify, opt);
 
   menuRoutes(fastify, opt);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.4.70",
+  "version": "1.4.72",
   "type": "module",
   "description": "core-plugins",
   "keywords": [

package/server/plugins/access/funcs/getAdminAccess.js

@@ -0,0 +1,14 @@
+import config from '../../../../config.js';
+
+export default async function getAdminAccess({
+    id, user = {},
+}) {
+    if (!id) {
+        return { message: 'not enough params: id', status: 400 };
+    }
+
+    if (!config?.local && !['admin'].includes(user.user_type, user.type)) {
+        return { message: 'access restricted: admin', status: 403 };
+    }
+    return null;
+}

package/server/plugins/access/index.mjs

@@ -0,0 +1,6 @@
+import getAdminAccess from './funcs/getAdminAccess.js';
+
+async function plugin(fastify) {
+//   fastify.decorate('getAdminAccess', getAdminAccess);
+}
+export default plugin;

package/server/plugins/policy/funcs/checkPolicy.js

@@ -19,7 +19,7 @@ export default function checkPolicy(req, reply) {
     originalUrl: path, hostname, query, params, headers, method, session, routeOptions, unittest,
   } = req;
 
-  if (config.local || unittest) { return null; }
+  if (config.local || unittest || config.env === 'test') { return null; }
 
   const body = JSON.stringify(req?.body || {}).substring(30);
 

package/server/routes/access/controllers/access.group.js

@@ -0,0 +1,28 @@
+import { pgClients, getAdminAccess } from '../../../../utils.js';
+
+export default async function accessGroup({
+    pg = pgClients.client, params = {}, user = {}, unittest,
+}, reply) {
+    if (!params?.id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    // restrict access - admin only
+    const check = await getAdminAccess({
+        id: params.id, user,
+    });
+    if (check?.message && check?.status && !unittest) {
+        return reply.status(check?.status).send(check?.message);
+    }
+
+    const { rows: routes = [] } = await pg.query(`select a.route_id as path, b.actions from admin.routes a 
+    left join admin.role_access b on a.route_id=b.route_id
+    where b.role_id=$1`, [params.id]);
+
+    const { rows: users = [] } = await pg.query(`select user_uid as id, user_name as name, access_granted, 
+    b.cdate as user_created, b.last_activity_date as last_activity from admin.user_roles a
+    left join admin.users b on a.user_uid=b.uid
+    where a.role_id=$1`, [params.id]);
+
+    return { routes, users };
+}

package/server/routes/access/controllers/access.group.post.js

@@ -0,0 +1,57 @@
+import { pgClients, getAdminAccess } from '../../../../utils.js';
+import accessGroup from './access.group.js';
+
+export default async function accessGroupPost({
+    pg = pgClients.client, params = {}, user = {}, body = {}, unittest,
+}, reply) {
+    const { id } = params;
+    if (!user?.uid) {
+        return reply.status(401).send('unauthorized');
+    }
+
+    // restrict access - admin only
+    const check = await getAdminAccess({ id, user });
+    if (check?.message && check?.status && !unittest) {
+        return reply.status(check?.status).send(check?.message);
+    }
+
+    const { users = [], routes = [] } = body;
+
+    if (!routes?.length) {
+        // return { message: 'not enough params: users / routes', status: 400 };
+        await pg.query('delete from admin.role_access where role_id=$1', [id]);
+
+        if (!users?.length) {
+            return reply.status(200).send({ id, routes });
+        }
+    }
+
+    if (routes?.length) {
+        const { routesDB = [] } = await pg.query('select array_agg(route_id) as "routesDB" from admin.routes where enabled')
+            .then((res1) => res1.rows?.[0] || {});
+        await pg.query('delete from admin.role_access where role_id=$1;', [id]);
+
+        const q = 'insert into admin.role_access(role_id,route_id,actions)   values ($1,$2,$3)';
+        await Promise.all(routes.filter(el => routesDB.includes(el.path) && el.actions).map(el => pg.query(q, [id, el.path, el.actions])));
+
+        const { rows } = await pg.query(`select a.route_id as path, b.actions as actions from admin.routes a 
+            left join admin.role_access b on a.route_id=b.route_id
+            where b.role_id=$1`, [id]);
+
+        if (!users?.length) {
+            return reply.status(200).send({ id, routes: rows });
+        }
+    }
+
+    const q = `delete from admin.user_roles where role_id='${id.replace(/'/g, "''")}';
+    insert into admin.user_roles(role_id,user_uid,access_granted)
+    values ${users.filter((el) => el?.id).map((el) => `('${id.replace(/'/g, "''")}','${el.id.replace(/'/g, "''")}','${user?.uid?.replace(/'/g, "''")}')`)}`;
+
+    await pg.query(q);
+
+    const res = await accessGroup({
+        pg, params, user, unittest,
+    }, reply);
+
+    return res;
+}

package/server/routes/access/controllers/access.interface.js

@@ -0,0 +1,37 @@
+import { pgClients, metaFormat, getAdminAccess } from '../../../../utils.js';
+
+const q = `select a.route_id as id, coalesce(b.user_uid, d.user_uid) as user_uid, coalesce(d.actions, b.actions, array['view']) as actions, b.scope, c.role_id
+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 coalesce(b.user_uid, d.user_uid) is not null`;
+
+export default async function accessInterface(req, reply) {
+  const {
+    pg = pgClients.client, params = {}, user = {}, unittest,
+  } = req;
+
+  // restrict access - admin only
+  const check = await getAdminAccess({
+    id: params.name, user,
+  });
+  if (check?.message && check?.status && !unittest) {
+    return reply.status(check?.status).send(check?.message);
+  }
+
+  const { rows = [] } = await pg.query(q, [params.name]);
+
+  const cls = { user_uid: 'core.user_uid', actions: 'core.actions', role_id: 'core.roles' };
+  await metaFormat({ rows, cls, sufix: false });
+  return { rows };
+}

package/server/routes/access/index.mjs

@@ -0,0 +1,12 @@
+import accessGroup from './controllers/access.group.js';
+import accessGroupPost from './controllers/access.group.post.js';
+import accessInterface from './controllers/access.interface.js';
+
+import { accessGroupPostSchema, accessGroupSchema, accessInterfaceSchema } from './schema.mjs';
+
+export default async function route(fastify, config) {
+    const { prefix = '/api' } = config;
+    fastify.get(`${prefix}/access-group/:id`, { schema: accessGroupSchema }, accessGroup);
+    fastify.post(`${prefix}/access-group/:id`, { schema: accessGroupPostSchema }, accessGroupPost);
+    fastify.get(`${prefix}/access-interface/:name`, { schema: accessInterfaceSchema }, accessInterface);
+}

package/server/routes/access/schema.mjs

@@ -0,0 +1,68 @@
+export default null;
+export { accessGroupSchema, accessGroupPostSchema, accessInterfaceSchema }
+
+const accessGroupSchema = {
+    params: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+        },
+        required: ['id'],
+    },
+};
+
+const accessInterfaceSchema = {
+    params: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+        },
+        required: ['name'],
+    },
+};
+
+const accessGroupPostSchema = {
+    params: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+        },
+        required: ['id'],
+    },
+    body: {
+        type: 'object',
+        properties: {
+            users: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        id: {
+                            type: 'string',
+                            pattern: '^([\\d\\w._-]+)$',
+                        },
+                    },
+                },
+            },
+            routes: {
+                type: 'array',
+                /*items: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            pattern: '^([\\d\\w._-]+)$',
+                        },
+                        actions: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                                enum: ['get', 'add', 'edit', 'del'],
+                            },
+                        },
+                    },
+                },*/
+            },
+        },
+    },
+};

package/server/routes/table/controllers/getFormByTable.js

@@ -1,5 +1,5 @@
 import {
-    config, applyHook, getTemplate, pgClients, getAccess, setToken, getSelectMeta,
+    config, applyHook, getTemplate, pgClients, getAccess, setToken, getSelectMeta, getToken,
 } from '../../../../utils.js';
 
 import getEditData from '../../crud/controllers/table.js';
@@ -29,13 +29,17 @@ export default async function getForm({
         return reply.status(hookData?.status).send(hookData?.message);
     }
 
-    const { form } = await getTemplate('table', hookData?.table || params.name) || {};
+    const tokenData = await getToken({ token: params.name, uid: user?.uid, json: 1 }) || {};
+
+    const table = tokenData?.table || hookData?.table || params.name;
+
+    const { form } = await getTemplate('table', table) || {};
 
     if (!form) {
         return reply.status(404).send('form not found');
     }
 
-    const { actions = [] } = await getAccess({ table: hookData?.table || params.name, form, user }, pg) || {};
+    const { actions = [] } = await getAccess({ table, form, user }, pg) || {};
 
     const loadTemplate = form ? await getTemplate('form', form) : null;
 
@@ -56,13 +60,13 @@ export default async function getForm({
     const res = { mode: 'form', time: 0, schema };
 
     if (user.uid) {
-        if (!actions.includes('add') && !config.local) {
+        if (!actions.includes('add') && !config.local && config.env !== 'test') {
             return reply.status(403).send('access restricted: actions');
         }
         const addTokens = setToken({
             ids: [
                 JSON.stringify({
-                    table: hookData?.table || params.name,
+                    table,
                     form,
                 })],
             uid: user.uid,
@@ -71,17 +75,17 @@ export default async function getForm({
         Object.assign(res, { token: addTokens[0], mode: 'add' });
     }
 
-    if (edit && user.uid) {
-        if (!actions.includes('edit') && !config.local) {
+    if ((edit || tokenData?.id) && user.uid) {
+        if (!actions.includes('edit') && !config.local && config.env !== 'test') {
             return reply.status(403).send('access restricted: actions');
         }
         const editTokens = setToken({
-            ids: [JSON.stringify({ id: edit, table: hookData?.table || params.name, form })],
+            ids: [JSON.stringify({ id: edit || tokenData?.id, table, form })],
             uid: user.uid,
             array: 1,
         });
         const data = await getEditData({
-            pg, params: { table: hookData?.table || params.name, id: edit }, user,
+            pg, params: { table, id: edit || tokenData?.id }, user,
         }, reply, true);
         Object.assign(res, { token: editTokens[0], data, mode: 'edit' });
     }

package/server/routes/util/controllers/code.generator.js

@@ -0,0 +1,94 @@
+import getTemplate from '../../../plugins/table/funcs/getTemplate.js';
+import pgClients from '../../../plugins/pg/pgClients.js';
+import getToken from '../../../plugins/crud/funcs/getToken.js';
+import { handlebarsSync } from '../../../../utils.js';
+
+function dayOfTheYear(date) {
+  const start = new Date(date.getFullYear(), 0, 0);
+  const diff = (date - start) + ((start.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000);
+  const oneDay = 1000 * 60 * 60 * 24;
+  const day = Math.floor(diff / oneDay);
+  return day;
+}
+
+export default async function codeGenerator({
+  pg = pgClients.client, params = {}, user = {}, query = {},
+}, reply) {
+  const { token, column } = params;
+  const data = query.data?.split?.(';') || [];
+
+  if (!token || !column) {
+    return reply.status(400).send('not enough params: token / column');
+  }
+
+  if (!user?.uid) {
+    return reply.status(401).send('unauthorized');
+  }
+
+  const tokenData = await getToken({ token, uid: user?.uid, json: 1 }) || {};
+
+  if (!tokenData?.form || !tokenData?.table) {
+    return reply.status(401).send('token not allow');
+  }
+
+  const loadTemplate = await getTemplate('form', tokenData.form);
+  const schema = loadTemplate?.schema || loadTemplate;
+
+  if (!schema) {
+    return reply.status(404).send('form not found');
+  }
+
+  if (!schema?.[column]?.template) {
+    return reply.status(400).send('template not specified');
+  }
+
+  const columnValue = data.find(el => el.startsWith(column))?.split('=')?.pop();
+
+  const loadTable = await getTemplate('table', tokenData.table);
+  const table = loadTable?.table || tokenData.table;
+
+  if (!pg.pk?.[table]) {
+    return reply.status(404).send('table pk not found');
+  }
+
+  const { count = 0 } = await pg.query(
+    `select count(*) from ${table} where ${columnValue ? `${column}::text = '${columnValue}'` : 'true'} limit 1`,
+  ).then(el => el.rows?.[0] || {});
+
+  const { NUMY = 0 } = await pg.query(
+    `select ${column} as "NUMY" from ${table} where ${column} is not null and date_part('year', cdate) = $1 order by cdate desc limit 1`,
+    [(new Date()).getFullYear()],
+  ).then(el => el.rows?.[0] || {});
+
+  const date = new Date();
+
+  const template = schema[column].template.match(/NUM[M|Y] \d/g)
+    .reduce(
+      (acc, curr) => acc.replace(
+        curr.startsWith('{{{') ? `{{{${curr}}}}` : `{{${curr}}}`,
+        handlebarsSync.compile('{{paddingNumber value padding}}')({ padding: curr.substring(4, curr.length)?.trim?.(), value: curr.startsWith('NUMY') ? NUMY : +count + 1 }),
+      ),
+      schema[column].template,
+    );
+  const result = handlebarsSync.compile(template)({
+    HH: date.getHours(), // hours 24h: 14:00 = 14
+    HH12: (date.getHours() + 24) % 12 || 12, // hours 12h: 14:00 = 2
+    HH24: date.getHours(), // hours 24h: 14:00 = 14
+    MI: date.getMinutes(), // minutes
+    SS: date.getSeconds(), // seconds
+
+    YYYY: date.getFullYear(), // full year: 2025
+    YY: date.getFullYear().toString().substring(2, 4), // last 2 digits of year: 25
+
+    MONTH: date.toLocaleString('en', { month: 'long' }).toUpperCase(), // month name: MARCH
+    MON: date.toLocaleString('en', { month: 'long' }).substring(0, 3).toUpperCase(), // month name abbrev: MAR
+    MM: date.getMonth() + 1, // month number: 1 - january, 12 - december
+
+    D: date.getDay(), // day of the week: 1 - monday, 7 - sunday
+    DD: date.getDate(), // day of the month: january 4 = 4
+    DDD: dayOfTheYear(date), // day of the year: march 4 = 63
+    ...data,
+  });
+
+  return reply.status(200).send(result);
+}

package/server/routes/util/index.js

@@ -1,12 +1,14 @@
 import nextId from './controllers/next.id.js';
 import statusMonitor from './controllers/status.monitor.js';
 import userTokens from './controllers/user.tokens.js';
+import codeGenerator from './controllers/code.generator.js';
 
 async function plugin(app, config = {}) {
   const { prefix = '/api' } = config;
   app.get(`${prefix}/next-id`, { config: { policy: ['public'] } }, nextId);
   app.get(`${prefix}/status-monitor`, {}, statusMonitor);
   app.get(`${prefix}/user-tokens/:token`, { config: { policy: ['user', 'site'] } }, userTokens);
+  app.get(`${prefix}/code-gen/:token/:column/:id?`, { config: { policy: ['user'] } }, codeGenerator);
 }
 
 export default plugin;

package/utils.js

@@ -107,6 +107,8 @@ import getExport from './server/plugins/file/getExport.js';
 import jsonToCsv from './server/routes/file/controllers/utils/jsonToCsv.js';
 import jsonToXls from './server/routes/file/controllers/utils/jsonToXls.js';
 
+export { default as getAdminAccess } from './server/plugins/access/funcs/getAdminAccess.js';
+
 export default null;
 export {
   config,