@opengis/admin 0.2.86 → 0.2.88

package/module/settings/menu.json

@@ -1,60 +1,64 @@
 [
-    {
-        "ua": "Доступ",
-        "en": "Management",
-        "name": "administration",
-        "icon": "IconLockCode",
-        "order": 9,
-        "menu": [
-            {
-                "path": "admin.users",
-                "table": "admin.users.table",
-                "ua": "Користувачі",
-                "en": "Users"
-            },
-            {
-                "path": "admin.roles",
-                "table": "admin.roles.table",
-                "ua": "Ролі/Групи",
-                "en": "Roles"
-            },
-            {
-                "path": "admin.routes",
-                "table": "admin.routes.table",
-                "ua": "Інтерфейси",
-                "en": "Routes"
-            },
-            {
-                "path": "auth.logs",
-                "table": "auth.logs.table",
-                "ua": "Логи інтерфейсів"
-            }
-        ]
-    },
-    {
-        "ua": "Управління",
-        "en": "Management",
-        "name": "administration",
-        "order": 10,
-        "icon": "IconSettingsCog",
-        "menu": [
-            {
-                "path": "admin.user-cls",
-                "ua": "Довідники ",
-                "component": "user-cls-page"
-            },
-            {
-                "path": "admin.properties",
-                "table": "admin.properties.table",
-                "ua": "Налаштування",
-                "en": "Settings"
-            },
-            {
-                "path": "admin.table_properties",
-                "table": "admin.table_properties.table",
-                "ua": "Налаштування таблиць (test)",
-                "en": "Table settings"
-            }
-        ]
-    }
-]
+  {
+    "ua": "Доступ",
+    "en": "Management",
+    "name": "administration",
+    "icon": "IconLockCode",
+    "order": 9,
+    "menu": [
+      {
+        "path": "admin.users",
+        "table": "admin.users.table",
+        "ua": "Користувачі",
+        "en": "Users"
+      },
+      {
+        "path": "admin.roles",
+        "table": "admin.roles.table",
+        "ua": "Ролі/Групи",
+        "en": "Roles"
+      },
+      {
+        "path": "admin.routes",
+        "table": "admin.routes.table",
+        "ua": "Інтерфейси",
+        "en": "Routes"
+      },
+      {
+        "path": "auth.logs",
+        "table": "auth.logs.table",
+        "ua": "Логи інтерфейсів"
+      }
+    ]
+  },
+  {
+    "ua": "Управління",
+    "en": "Management",
+    "name": "administration",
+    "order": 10,
+    "icon": "IconSettingsCog",
+    "menu": [
+      {
+        "path": "admin.user-cls",
+        "ua": "Довідники ",
+        "component": "user-cls-page"
+      },
+      {
+        "path": "admin.properties",
+        "table": "admin.properties.table",
+        "ua": "Налаштування",
+        "en": "Settings"
+      },
+      {
+        "path": "admin.table_settings",
+        "ua": "Налаштування таблиць",
+        "component": "table-settings-page"
+      },
+      {
+        "path": "admin.admin_properties",
+        "ua": "Налаштування адміна",
+        "component": "admin-properties-page"
+      }
+    ]
+  }
+]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/admin",
-  "version": "0.2.86",
+  "version": "0.2.88",
   "description": "This project Softpro Admin",
   "main": "dist/admin.js",
   "type": "module",
@@ -49,7 +49,7 @@
     "@opengis/admin": "^0.2.82",
     "@opengis/fastify-auth": "^1.0.61",
     "@opengis/fastify-file": "^1.0.40",
-    "@opengis/fastify-table": "^1.1.146",
+    "@opengis/fastify-table": "^1.1.148",
     "@opengis/v3-core": "^0.3.33",
     "@opengis/v3-filter": "^0.0.62",
     "@tabler/icons-vue": "^3.28.1",

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

@@ -1,29 +1,32 @@
 const table = 'admin.properties';
 
-import { config, getRedis } from '@opengis/fastify-table/utils.js';
+import { config, getRedis, pgClients, getTemplatePath, getTemplate } from '@opengis/fastify-table/utils.js';
 
 import { getSettings } from '../../../../utils.js';
 
-export default async function getSettingsAPI({
-  pg = {}, params = {}, query = {},
+const redis = getRedis();
+
+export default async function getSettingsApp({
+  pg = pgClients.client, params = {}, query = {},
 }) {
   if (!pg.pk?.[table]) {
     return { message: 'table not found', status: 404 };
   }
 
-  const redis = getRedis();
   const keyCache = `${pg.options?.database}:settings:${params?.key || 'all'}:${query?.json ? 'json' : 'plain'}:${table}`;
-
   const cache = await redis.get(keyCache);
-  if (cache && !config?.local) return JSON.parse(cache);
 
-  try {
-    const res = await getSettings({
-      pg, key: params.key, json: query.json, redis, table,
-    });
-    return { message: res, status: 200 };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 500 };
+  if (cache && !config?.local) {
+    return JSON.parse(cache);
   }
+
+  const settings = await getSettings({
+    pg, key: params.key, json: query.json, redis, table,
+  });
+
+  const forms = await Promise.all(getTemplatePath('setting')
+    .map(async (el) => ({ name: el[0], body: await getTemplate('setting', el[0]) }))
+  );
+
+  return { message: { forms, settings }, status: 200 };
 }

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

@@ -2,7 +2,7 @@ const table = 'admin.properties';
 
 import { setSettings } from '../../../../utils.js';
 
-export default async function postSettingsAPI({
+export default async function postSettingsApp({
   pg, session = {}, body = {},
 }) {
   if (session.passport?.user?.user_type !== 'superadmin') {

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

@@ -0,0 +1,120 @@
+import { pgClients, getMeta, getTemplate } from '@opengis/fastify-table/utils.js';
+
+import getColumnMetaData from '../utils/getColumnMetaData.js';
+
+/**
+ *
+ * @method GET
+ * @priority 4
+ * @alias getSettingsTable
+ * @type api
+ * @tag custom
+
+ * @returns {String} message and status
+ */
+
+export default async function getSettingsTable({
+  pg = pgClients.client, params = {}, user = {}, query = {},
+}) {
+  const { table, entity } = params;
+  const { uid } = user;
+  const time = [];
+
+  if (!uid) {
+    return { message: 'access restricted', status: 401 };
+  }
+
+  if (!table) {
+    return { message: 'not enough params: table', status: 400 };
+  }
+
+  const loadTable = await getTemplate('table', table);
+
+  const tableName = loadTable?.table || table;
+  const meta = await getMeta({ pg, table: tableName });
+  const { view, pk } = meta || {};
+  time.push(Date.now());
+
+  if (!pk && !view) {
+    return {
+      message: `table primary key not found: ${tableName}`,
+      status: 400,
+    };
+  }
+
+  const { rows: geometry } = meta?.geom
+    ? await pg.queryCache(`select st_geometrytype(${meta?.geom}) as type ,count(*) 
+    from ${tableName} group by st_geometrytype(${meta?.geom})`, { table: tableName }) : [];
+  time.push(Date.now());
+
+  const stat = !view ? await getColumnMetaData({ pg, table: tableName }) : {};
+  time.push(Date.now());
+
+  const { total = 0 } = await pg.queryCache(`select count(*) as total from ${tableName}`, { table: tableName })
+    .then(el => el.rows?.[0] || {});
+  time.push(Date.now());
+
+  const { property_json: customColumns = [] } = await pg.query(`select property_json::json from setting.property 
+  where property_entity='customColumn' and object_id=$1`, [table]).then(el => el.rows?.[0] || {});
+
+  const { property_json: tableSettingColumns } = await pg.query(`select property_json::json from setting.property 
+  where property_entity='column' and object_id=$1`, [table]).then(el => el.rows?.[0] || {});
+
+  const columns = (tableSettingColumns || loadTable?.columns || meta?.columns)?.map((el) => ({ ...el, title: el.title || el.name }))
+    ?.filter((value, index, array) => array?.map((el) => el.name).indexOf(value.name) === index); // get unique columns
+
+  const cls = columns?.filter((el) => ['badge', 'select'].includes(el.format) && (el.option || el.data))
+    ?.map((el) => (el.option || el.data))
+    ?.filter((value, index, array) => array.indexOf(value) === index); // get unique cls
+
+  const { property_json: userFilterList } = await pg.query(`select property_json::json from setting.property
+    where property_entity='filter' and object_id=$1`, [table]).then(el => el.rows?.[0] || {});
+
+  const { property_json: customQuery } = await pg.query(`select json_agg(json_build_object('id',property_id,'name', property_key,
+  'query', property_text, 'disabled', coalesce((property_json::json->>'disabled')::boolean,false) )) as property_json
+  from setting.property where 1=1 and property_entity='customQuery' and object_id=$1`, [table]).then(el => el.rows?.[0] || {});
+
+  time.push(Date.now());
+
+  const debug = user?.user_type?.includes('admin') && query?.debug
+    ? {
+      view,
+      tableName,
+      opt,
+      colModel,
+      metaColumns: meta?.columns,
+      columnProperties: tableSettingColumns,
+    }
+    : undefined;
+
+  const res = {
+    message: {
+      time: {
+        geom: time[1] - time[0],
+        stat: time[2] - time[1],
+        count: time[3] - time[2],
+        total: time[4] - time[0],
+      },
+      debug,
+      model: tableName,
+      total,
+      geometry,
+      stat,
+      cls,
+      columns,
+      filters: userFilterList?.length
+        ? userFilterList
+        : loadTable?.filters?.map((el) => ({ ...el, title: el.title || el.ua })),
+      customQuery: customQuery?.length ? customQuery : [],
+      customColumns,
+      customFilters: userFilterList || [],
+    },
+    status: 200,
+  };
+
+  if (entity) {
+    return { [entity]: res.message[entity] };
+  }
+
+  return res;
+};

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

@@ -0,0 +1,115 @@
+import { getRedis, pgClients } from '@opengis/fastify-table/utils.js';
+
+import refreshData from '../utils/refreshData.js';
+
+const rclient = getRedis();
+
+/**
+ *
+ * @method POST
+ * @priority 4
+ * @alias postSettingsTable
+ * @type api
+ * @tag custom
+ * @returns {String} message and status
+ */
+
+export default async function postTablpostSettingsTableeProperties({
+  pg = pgClients.client, params = {}, body = {}, user = {},
+}) {
+  const { table } = params;
+  const { uid } = user;
+
+  if (!uid) {
+    return { message: 'access restricted', status: 401 };
+  }
+
+  if (!table) {
+    return { message: 'not enough params: table', status: 400 };
+  }
+
+  const {
+    deleted = [],
+    columns = [],
+    filters = [],
+    customColumns = [],
+    customQuery = [],
+  } = body;
+
+  const cacheKey = `${pg.options?.database}:filter-list:${table}`;
+
+  if (Array.isArray(deleted) && deleted?.length) {
+    const sqlList = {
+      columns: `delete from setting.property where property_entity='column' and object_id=$1`,
+      filters: `delete from setting.property where property_entity='filter' and object_id=$1`,
+      customColumns: `delete from setting.custom_data where attr in (select cf_id from setting.custom_field where object_id=$1);
+      delete from setting.custom_field where object_id=$1;
+      delete from setting.property where property_entity='customColumn' and object_id=$1;`,
+      customQuery: `delete from setting.property where property_entity='customQuery' and object_id=$1;`,
+    };
+    const q = deleted.map((item) => sqlList[item])?.filter((el) => el)?.join(' ');
+    const { rowCount = 0 } = await pg.query(q, [table]);
+
+    if (['customColumn', 'column'].find((el) => deleted.includes(el))) {
+      // await funcs.applyHook('preTemplate', { pg, name: table, type: 'table' });
+    }
+    if (['customQuery', 'filter'].find((el) => deleted.includes(el))) {
+      await rclient.del(cacheKey);
+    }
+
+    if (rowCount === 0) {
+      return { message: 'nothing to restore', status: 200 };
+    }
+
+    return {
+      message: {
+        command: 'DELETE',
+        deleted,
+        table,
+        result: 'success',
+      },
+      status: 200,
+    };
+  }
+
+  const result = {};
+  // custom filter query (sql)
+  if (customQuery?.length) {
+    const res = await refreshData({ pg, entity: 'customQuery', table, uid, data: customQuery });
+    if (res?.error) return res;
+    Object.assign(result, { customQuery: res });
+  }
+
+  // columns
+  if (columns?.length) {
+    const res = await refreshData({ pg, entity: 'column', table, uid, data: columns });
+    if (res?.error) return res;
+    Object.assign(result, { columns: res });
+  }
+
+  // custom columns
+  if (customColumns?.length) {
+    const colModel = await pg.query(`select property_json::json from setting.property
+    where property_entity='customColumn' and object_id=$1`, [table]).then((el) => el.rows?.[0]?.property_json);
+
+    const res = await refreshData({ pg, entity: 'customColumn', table, uid, data: customColumns, colModel });
+    if (res?.error) return res;
+    Object.assign(result, { customColumns: res });
+  }
+
+  // filters
+  if (filters?.length) {
+    const res = await refreshData({ pg, entity: 'filter', table, uid, data: filters });
+    if (res?.error) return res;
+    Object.assign(result, { filters: res });
+  }
+
+  if (columns?.length || customColumns?.length) {
+    // await funcs.applyHook('preTemplate', { pg, type: 'table', name: table });
+  }
+  if (filters?.length || customQuery?.length) {
+    await rclient.del(cacheKey);
+  }
+
+  return { message: result, status: 200 };
+};

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

@@ -4,7 +4,7 @@ import { getRedis } from '@opengis/fastify-table/utils.js';
 
 import { getSettings } from '../../../../utils.js';
 
-export default async function getUserProperties({
+export default async function getSettingsUser({
   pg = {}, params = {}, query = {}, session = {},
 }) {
   const { uid } = session.passport?.user || {};
@@ -25,6 +25,6 @@ export default async function getUserProperties({
   const res = await getSettings({
     pg, key: params.key, json: query.json, redis, table, uid,
   });
-  
+
   return { message: res, status: 200 };
 }

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

@@ -2,7 +2,7 @@ const table = 'admin.user_properties';
 
 import { setSettings } from '../../../../utils.js';
 
-export default async function postUserProperties({
+export default async function postSettingsUser({
   pg, session = {}, body = {},
 }) {
   const { uid } = session.passport?.user || {};

package/server/routes/properties/funcs/setSettings.js

@@ -1,7 +1,7 @@
 import { getRedis } from '@opengis/fastify-table/utils.js';
 
 import { getSettings } from '../../../../utils.js';
-import dataInsert from './utils/dataInsert.js';
+import dataInsert from '../utils/dataInsert.js';
 
 function checkValueType(val) {
   if (val) {

package/server/routes/properties/index.mjs

@@ -1,14 +1,21 @@
-import getAdminProperties from './controllers/admin.properties.get.js';
-import postAdminProperties from './controllers/admin.properties.post.js';
+import getSettingsApp from './controllers/admin.properties.get.js';
+import postSettingsApp from './controllers/admin.properties.post.js';
 
-import getUserProperties from './controllers/user.properties.get.js';
-import postUserProperties from './controllers/user.properties.post.js';
+import getSettingsUser from './controllers/user.properties.get.js';
+import postSettingsUser from './controllers/user.properties.post.js';
+
+import getSettingsTable from './controllers/table.properties.get.js';
+import postSettingsTable from './controllers/table.properties.post.js';
 
 import { propertiesSchema } from './schema.js';
 
 export default async function route(fastify) {
-  fastify.get('/admin-properties/:key?', {  scheme: propertiesSchema }, getAdminProperties);
-  fastify.get('/user-properties/:key?', { scheme: propertiesSchema }, getUserProperties);
-  fastify.post('/admin-properties', { config: { policy: ['superadmin'] } }, postAdminProperties);
-  fastify.post('/user-properties',  postUserProperties);
+  fastify.get('/settings-app/:key?', { scheme: propertiesSchema }, getSettingsApp);
+  fastify.post('/settings-app', { config: { policy: ['superadmin'] } }, postSettingsApp);
+
+  fastify.get('/settings-user/:key?', { scheme: propertiesSchema }, getSettingsUser);
+  fastify.post('/settings-user', {}, postSettingsUser);
+
+  fastify.get('/settings-table/:table/:entity?', {}, getSettingsTable);
+  fastify.post('/settings-table/:table', {}, postSettingsTable);
 }

package/server/routes/properties/utils/getColumnMetaData.js

@@ -0,0 +1,17 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function getColumnMetaData({
+  pg = pgClients.client, table,
+}) {
+  if (!table) return null;
+
+  const { columns = [] } = await getMeta({ pg, table });
+  const columnList = columns.filter(el => !['files', 'uid', 'editor_date', 'editor_id', 'cdate'].includes(el.name)).map(el => el.name);
+
+  const sql = `select count(*) as total, ${columnList.map((item) => `(count(*) filter(where ${item} is not null)) as "${item}"`).join(',')} from ${table}`;
+  const res = await pg.queryCache(sql, { table }).then(el => el.rows?.[0] || {});
+
+  return columns
+    .filter(el => !['files', 'uid', 'editor_date', 'editor_id', 'cdate'].includes(el.name))
+    .map((row) => Object.assign(row, { percent: ((+res[row.name] / +res.total) * 100).toFixed(0) }));
+};

package/server/routes/properties/utils/refreshData.js

@@ -0,0 +1,128 @@
+import { randomUUID, createHash } from 'crypto';
+
+import { dataInsert, pgClients } from '@opengis/fastify-table/utils.js';
+
+function prepareResult(res) {
+  const arr = (res.rows || (Array.isArray(res) ? res : Object.values(res || {})));
+  return {
+    command: 'INSERT',
+    count: arr.filter((el) => el.command === 'INSERT')
+      ?.map((el) => ({ result: 'success', count: el.rowCount }))
+      ?.reduce((acc, curr) => acc + curr.count, 0),
+  };
+}
+
+export default async function refreshData({
+  pg = pgClients.client, entity, table, uid, data,
+}) {
+  if (!['filter', 'column', 'customQuery', 'customColumn'].includes(entity)) {
+    return { message: 'invalid params: entity', status: 400 };
+  }
+
+  const client = await pg.connect();
+
+  /* getMeta support */
+  client.options = pg.options;
+  client.tlist = pg.tlist;
+  client.pgType = pg.pgType;
+  client.pk = pg.pk;
+  client.relkinds = pg.relkinds;
+
+  const result = {};
+
+  try {
+    await client.query('BEGIN');
+
+    if (['filter', 'column'].includes(entity)) {
+      data?.forEach((el) => Object.assign(el, { id: el.id || randomUUID() }));
+      await client.query('delete from setting.property where object_id=$1 and property_entity=$2', [table, entity]);
+
+      const res = dataInsert({
+        pg: client,
+        table: 'setting.property',
+        data: {
+          property_entity: entity,
+          object_id: table,
+          property_json: JSON.stringify(data)?.replace(/'/g, "''"),
+        },
+        uid,
+      });
+      Object.assign(result, res);
+    }
+
+    if (['customQuery'].includes(entity)) {
+      await client.query('delete from setting.property where object_id=$1 and property_entity=$2', [table, entity]);
+
+      const res = await Promise.all(data?.map(async (el) => dataInsert({
+        pg: client,
+        table: 'setting.property',
+        data: {
+          property_entity: entity,
+          object_id: table,
+          property_key: el.name,
+          property_text: el.query,
+          property_json: { disabled: el.disabled },
+        },
+        uid,
+      })));
+      Object.assign(result, res);
+    }
+
+    if (entity === 'customColumn') {
+      const prefix = createHash('md5').update(table).digest('hex').substr(0, 10);
+      const data1 = [];
+
+      await Promise.all(data.map(async (el, index) => {
+        const obj = {
+          cf_id: `col_${prefix}_${index}`,
+          cf_name: el.title || el.ua || el.name,
+          cf_type: el.format || el.type,
+          cf_default: el.default,
+          cf_notnull: el.notnull,
+          object_id: table,
+          tablename: table,
+        };
+
+        data1.push({
+          name: obj.cf_id,
+          title: obj.cf_name,
+          format: obj.cf_type,
+          option: data[index]?.option,
+          hidden: data[index]?.hidden,
+          custom: true,
+        });
+
+        await dataInsert({
+          pg: client,
+          table: 'setting.custom_field',
+          data: obj,
+          uid,
+        });
+      }));
+
+      await client.query('delete from setting.custom_field where $1 in (tablename, object_id)', [table]);
+      await client.query('delete from setting.property where object_id=$1 and property_entity=$2', [table, entity]);
+
+      const data2 = JSON.stringify(data1?.filter((value, index, array) => array.indexOf(value) === index))?.replace(/'/g, "''");
+      const res = await dataInsert({
+        pg: client,
+        table: 'setting.property',
+        data: {
+          property_entity: 'customColumn',
+          object_id: table,
+          property_json: data2,
+        },
+        uid,
+      });
+      Object.assign(result, res);
+    }
+    await client.query('COMMIT');
+    return prepareResult(result);
+  } catch (err) {
+    await client.query('ROLLBACK');
+    return { error: err.toString(), status: 500 };
+  }
+  finally {
+    client.release();
+  }
+};

package/server/routes/widget/controllers/widget.get.js

@@ -1,7 +1,7 @@
 import { getMeta, getToken, pgClients } from '@opengis/fastify-table/utils.js';
 
 const galleryExtList = ['png', 'svg', 'jpg', 'jpeg', 'gif', 'mp4', 'mov', 'avi'];
-const username = `coalesce(u.sur_name,'')||coalesce(' '||u.user_name,'') ||coalesce(' '||u.father_name,'') as username`;
+const username = `coalesce(u.sur_name,'')||coalesce(' '||u.user_name,'') ||coalesce(' '||u.father_name,'')`;
 
 /**
  * Дістає CRM для widget
@@ -85,6 +85,7 @@ export default async function widgetGet({
 
   const q = tableName && pg.pk['admin.users'] ? `select ${username} as author, u.login, a.cdate, a.editor_date from ${tableName} a 
   left join admin.users u on a.uid=u.uid where a.${pk}=$1 limit 1` : undefined;
+
   const data = pk && q ? await pg.one(q, [objectid]) : {};
 
   if (query.debug && user?.user_type === 'admin') {