@opengis/gis 0.2.176 → 0.2.178

package/server/routes/permissions/permissions.schema.js

@@ -1,44 +1,44 @@
-export const getCatalogPermissionsSchema = {
-    params: {
-        type: 'object',
-        required: ['uid'],
-        properties: {
-            uid: {
-                type: 'string', pattern: '^([\\d\\w._-]+)$'
-            },
-        },
-    },
-};
-
-export const editCatalogPermissionsSchema = {
-    params: {
-        type: 'object',
-        required: ['uid'],
-        properties: {
-            uid: {
-                type: 'string', pattern: '^([\\d\\w._-]+)$'
-            },
-        },
-    },
-    body: {
-        type: 'array',
-        items: {
-            type: 'object',
-            required: ['service_id', 'actions'],
-            properties: {
-                service_id: {
-                    type: 'string', pattern: '^([\\d\\w._-]+)$'
-                },
-                actions: {
-                    type: 'array',
-                    items: {
-                        type: 'string',
-                        enum: ['view', 'edit', 'add', 'del']
-                    }
-                }
-            }
-        }
-    }
-};
-
+export const getCatalogPermissionsSchema = {
+    params: {
+        type: 'object',
+        required: ['uid'],
+        properties: {
+            uid: {
+                type: 'string', pattern: '^([\\d\\w._-]+)$'
+            },
+        },
+    },
+};
+
+export const editCatalogPermissionsSchema = {
+    params: {
+        type: 'object',
+        required: ['uid'],
+        properties: {
+            uid: {
+                type: 'string', pattern: '^([\\d\\w._-]+)$'
+            },
+        },
+    },
+    body: {
+        type: 'array',
+        items: {
+            type: 'object',
+            required: ['service_id', 'actions'],
+            properties: {
+                service_id: {
+                    type: 'string', pattern: '^([\\d\\w._-]+)$'
+                },
+                actions: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: ['view', 'edit', 'add', 'del']
+                    }
+                }
+            }
+        }
+    }
+};
+
 export default null;

package/server/routes/registers/functions/add.registry.js

@@ -1,37 +1,37 @@
-import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
-import { BadRequestError } from "@opengis/fastify-table/errors.js";
-
-export default async function addGisRegistry({
-    method, body, slug, uid,
-}, pg = pgClients.client) {
-    if (method === 'POST' && !body?.register_key) {
-        throw BadRequestError('not enough body params: register_key');
-    }
-
-    if (method === 'POST') {
-        const res = await dataInsert({
-            pg,
-            id: slug,
-            table: 'gis.registers',
-            data: body,
-            uid,
-        });
-        return res.data;
-    }
-
-    if (!slug) {
-        throw BadRequestError('not enough params: slug');
-    }
-
-    const id = await pg.query('select register_id from gis.registers where register_key=$1', [slug]).then(r => r.rows?.[0]?.register_id) || slug;
-
-    const row = await dataUpdate({
-        pg,
-        id,
-        table: 'gis.registers',
-        data: body,
-        uid,
-    });
-
-    return row;
-}
+import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
+
+export default async function addGisRegistry({
+    method, body, slug, uid,
+}, pg = pgClients.client) {
+    if (method === 'POST' && !body?.register_key) {
+        throw BadRequestError('not enough body params: register_key');
+    }
+
+    if (method === 'POST') {
+        const res = await dataInsert({
+            pg,
+            id: slug,
+            table: 'gis.registers',
+            data: body,
+            uid,
+        });
+        return res.data;
+    }
+
+    if (!slug) {
+        throw BadRequestError('not enough params: slug');
+    }
+
+    const id = await pg.query('select register_id from gis.registers where register_key=$1', [slug]).then(r => r.rows?.[0]?.register_id) || slug;
+
+    const row = await dataUpdate({
+        pg,
+        id,
+        table: 'gis.registers',
+        data: body,
+        uid,
+    });
+
+    return row;
+}

package/server/routes/registers/functions/classifiers.js

@@ -1,101 +1,101 @@
-import { getSelectVal, getSelect, getTemplates } from '@opengis/fastify-table/utils.js';
-
-export async function attachClassifiers(rowOrRows, classifiers, table) {
-    const rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
-
-    const list = getTemplates(['cls', 'select']);
-
-    // classifiers as object
-    if (table) {
-        await Promise.all(rows.map(async row => {
-            await Promise.all(Object.keys(row).filter(key => classifiers?.[key] || list.map(el => el[0]).includes(`${table}.${key}`) || list.map(el => el[0]).includes(key)).map(async key => {
-                const clsAsColumn = list.map(el => el[0]).includes(key);
-                const arr = await getSelectVal({ name: classifiers?.[key] || (clsAsColumn ? key : `${table}.${key}`), values: [row[key]], ar: true });
-                const val = arr?.find?.(el => el.id && el.id.toString() === row[key].toString());
-                if (val?.text) { row[`${key}_data`] = val; }
-                row[key] = val?.text || val || row[key]; // for frontend
-                row[`${key}_text`] = val?.text || val || row[key]; // legacy?
-            }));
-        }));
-        return rowOrRows;
-    }
-
-    // classifiers as array of objects
-    await Promise.all(rows.map(async row => {
-        (classifiers || []).filter(item => item.classifier && item.name && row[item.name]).map(async ({ name, classifier }) => {
-            const arr = await getSelectVal({ name: classifier, values: [row[name]], ar: true });
-            const val = arr?.find?.(el => el.id === row[name]);
-            if (val?.text) { row[`${name}_data`] = val; }
-            row[name] = val?.text || val || row[name]; // for frontend
-            row[`${name}_text`] = val?.text || val || row[name]; // legacy?
-        });
-    }));
-
-    /* for (const row of rows) {
-        for (const { name, classifier } of classifiers) {
-            const value = row[name];
-            if (value != null && classifier) {
-
-                const match = await getSelectVal({ name: classifier, values: [value] });
-                const matchVal = Object.values(match)?.[0]
-
-                if (typeof matchVal === 'object' && matchVal !== null) {
-                    row[`${name}_data`] = matchVal;
-                } else if (
-                    typeof matchVal === 'string' && matchVal !== null
-                ) {
-                    row[`${name}_text`] = matchVal;
-                };
-                
-            }
-        }
-    } */
-
-    return rowOrRows;
-}
-
-export async function populateFilterOptions({ pg, table, filters, columns, whereConditions, args = [] }) {
-    if (!filters?.length || !table || !columns?.length) return;
-
-    const optimizedSQL = `select * from ${table} where ${whereConditions || '1=1'}`;
-
-    await Promise.all(
-        filters
-            .filter(
-                (el) =>
-                    el.id &&
-                    el.type !== "Autocomplete" &&
-                    !el.sql &&
-                    !el.options?.find?.((item) => item.sql)
-            )
-            .map(async (el) => {
-                const cls = el.data ? await getSelect(el.data, pg) : null;
-
-                if (!cls && !el.type?.includes?.("Check")) return;
-                const { dataTypeID } = (columns || []).find((item) => item.name === el.id) || {};
-
-                const q = pg.pgType[dataTypeID || '']?.includes("[]")
-                    ? `select unnest(${el.id})::text as id,count(*) from (${optimizedSQL})q group by unnest(${el.id}) limit 100`
-                    : `select ${el.id}::text as id,count(*) from (${optimizedSQL})q group by ${el.id} limit 100`;
-
-                const countArr = await pg.queryCache(q, { args, table });
-
-                if (countArr.timeout) {
-                    Object.assign(el, { timeout: countArr.timeout });
-                    console.warn("timeout filter", table, el.id);
-                }
-
-                const ids = countArr.rows.map((el1) => el1.id);
-
-                const clsData = await getSelectVal({ pg, values: ids, name: el.data });
-
-                const options = countArr.rows.map((cel) => {
-                    const data = cls?.arr?.find?.(
-                        (c) => c.id?.toString?.() === cel.id?.toString?.()
-                    ) || { text: clsData?.[cel.id]?.text || clsData?.[cel.id] || cel.id };
-                    return { ...cel, id: cel.id === null ? "null" : cel.id, ...data };
-                });
-                Object.assign(el, { options });
-            })
-    );
+import { getSelectVal, getSelect, getTemplates } from '@opengis/fastify-table/utils.js';
+
+export async function attachClassifiers(rowOrRows, classifiers, table) {
+    const rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
+
+    const list = getTemplates(['cls', 'select']);
+
+    // classifiers as object
+    if (table) {
+        await Promise.all(rows.map(async row => {
+            await Promise.all(Object.keys(row).filter(key => classifiers?.[key] || list.map(el => el[0]).includes(`${table}.${key}`) || list.map(el => el[0]).includes(key)).map(async key => {
+                const clsAsColumn = list.map(el => el[0]).includes(key);
+                const arr = await getSelectVal({ name: classifiers?.[key] || (clsAsColumn ? key : `${table}.${key}`), values: [row[key]], ar: true });
+                const val = arr?.find?.(el => el.id && el.id.toString() === row[key].toString());
+                if (val?.text) { row[`${key}_data`] = val; }
+                row[key] = val?.text || val || row[key]; // for frontend
+                row[`${key}_text`] = val?.text || val || row[key]; // legacy?
+            }));
+        }));
+        return rowOrRows;
+    }
+
+    // classifiers as array of objects
+    await Promise.all(rows.map(async row => {
+        (classifiers || []).filter(item => item.classifier && item.name && row[item.name]).map(async ({ name, classifier }) => {
+            const arr = await getSelectVal({ name: classifier, values: [row[name]], ar: true });
+            const val = arr?.find?.(el => el.id === row[name]);
+            if (val?.text) { row[`${name}_data`] = val; }
+            row[name] = val?.text || val || row[name]; // for frontend
+            row[`${name}_text`] = val?.text || val || row[name]; // legacy?
+        });
+    }));
+
+    /* for (const row of rows) {
+        for (const { name, classifier } of classifiers) {
+            const value = row[name];
+            if (value != null && classifier) {
+
+                const match = await getSelectVal({ name: classifier, values: [value] });
+                const matchVal = Object.values(match)?.[0]
+
+                if (typeof matchVal === 'object' && matchVal !== null) {
+                    row[`${name}_data`] = matchVal;
+                } else if (
+                    typeof matchVal === 'string' && matchVal !== null
+                ) {
+                    row[`${name}_text`] = matchVal;
+                };
+                
+            }
+        }
+    } */
+
+    return rowOrRows;
+}
+
+export async function populateFilterOptions({ pg, table, filters, columns, whereConditions, args = [] }) {
+    if (!filters?.length || !table || !columns?.length) return;
+
+    const optimizedSQL = `select * from ${table} where ${whereConditions || '1=1'}`;
+
+    await Promise.all(
+        filters
+            .filter(
+                (el) =>
+                    el.id &&
+                    el.type !== "Autocomplete" &&
+                    !el.sql &&
+                    !el.options?.find?.((item) => item.sql)
+            )
+            .map(async (el) => {
+                const cls = el.data ? await getSelect(el.data, pg) : null;
+
+                if (!cls && !el.type?.includes?.("Check")) return;
+                const { dataTypeID } = (columns || []).find((item) => item.name === el.id) || {};
+
+                const q = pg.pgType[dataTypeID || '']?.includes("[]")
+                    ? `select unnest(${el.id})::text as id,count(*) from (${optimizedSQL})q group by unnest(${el.id}) limit 100`
+                    : `select ${el.id}::text as id,count(*) from (${optimizedSQL})q group by ${el.id} limit 100`;
+
+                const countArr = await pg.queryCache(q, { args, table });
+
+                if (countArr.timeout) {
+                    Object.assign(el, { timeout: countArr.timeout });
+                    console.warn("timeout filter", table, el.id);
+                }
+
+                const ids = countArr.rows.map((el1) => el1.id);
+
+                const clsData = await getSelectVal({ pg, values: ids, name: el.data });
+
+                const options = countArr.rows.map((cel) => {
+                    const data = cls?.arr?.find?.(
+                        (c) => c.id?.toString?.() === cel.id?.toString?.()
+                    ) || { text: clsData?.[cel.id]?.text || clsData?.[cel.id] || cel.id };
+                    return { ...cel, id: cel.id === null ? "null" : cel.id, ...data };
+                });
+                Object.assign(el, { options });
+            })
+    );
 }

package/server/routes/registers/functions/columns.js

@@ -1,3 +1,3 @@
-export function extractVisibleColumns(columns, mode = "table") {
-    return (columns || []).filter((col) => (mode === "card" ? col.hidden_card !== true : col.hidden_register !== true));
-}
+export function extractVisibleColumns(columns, mode = "table") {
+    return (columns || []).filter((col) => (mode === "card" ? col.hidden_card !== true : col.hidden_register !== true));
+}

package/server/routes/registers/functions/content.type.js

@@ -1,10 +1,10 @@
-const ContentType = {
-    xml: 'application/xml',
-    shp: 'application/zip',
-    csv: 'text/csv',
-    geojson: 'application/vnd.geo+json',
-    json: 'application/json',
-    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-};
-
+const ContentType = {
+    xml: 'application/xml',
+    shp: 'application/zip',
+    csv: 'text/csv',
+    geojson: 'application/vnd.geo+json',
+    json: 'application/json',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+};
+
 export default ContentType;

package/server/routes/registers/functions/del.registry.js

@@ -1,15 +1,15 @@
-import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
-
-export default async function deleteGisRegistry({
-    slug, uid,
-}, pg = pgClients.client) {
-    const id = await pg.query('select register_id from gis.registers where register_key=$1', [slug]).then(el => el.rows?.[0]?.register_id) || slug;
-
-    const row = await dataDelete({
-        pg,
-        id,
-        table: 'gis.registers',
-        uid,
-    });
-    return row;
+import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function deleteGisRegistry({
+    slug, uid,
+}, pg = pgClients.client) {
+    const id = await pg.query('select register_id from gis.registers where register_key=$1', [slug]).then(el => el.rows?.[0]?.register_id) || slug;
+
+    const row = await dataDelete({
+        pg,
+        id,
+        table: 'gis.registers',
+        uid,
+    });
+    return row;
 }

package/server/routes/registers/functions/get.info.js

@@ -1,93 +1,93 @@
-import { pgClients } from '@opengis/fastify-table/utils.js';
-import { NotFoundError } from '@opengis/fastify-table/errors.js';
-
-import { attachClassifiers } from '../../registers/functions/classifiers.js';
-
-const pg = pgClients.client;
-
-export default async function getInfo({ finalInfo, format }) {
-  if (!finalInfo) return { error: 'No data found' };
-
-  const table = finalInfo?.table_name;
-  const queryCondition = finalInfo?.query || '1=1';
-  const columns = finalInfo?.columns || finalInfo?.attributes || [];
-  const exportable = columns.filter(c => c.is_export);
-  const selectNames = exportable.map(c => `"${c.name}"`);
-  const selectSQL = `
-    SELECT ${selectNames?.length ? selectNames.join(', ') : ''} ${format === 'geojson' || format === 'shp' ? `${selectNames?.length ? ',' : ''} ST_AsGeoJSON(geom)::json as geom` : ``}
-    FROM ${table}
-    WHERE ${queryCondition} ${format === 'geojson' || format === 'shp' ? `and geom is not null` : ``}
-  `;
-
-  if (format === 'shp') {
-    const { rows: geomTypeRows } = await pg.query(`
-      SELECT DISTINCT ST_GeometryType(geom) AS geom_type
-      FROM ${table}
-      WHERE geom IS NOT NULL
-    `);
-    const geometryTypes = geomTypeRows.map(row => row.geom_type);
-
-    const sqlList = geometryTypes.map(type => {
-      return {
-        type,
-        query: `
-          SELECT ${selectNames.join(', ')} ${selectNames?.length ? ',' : ''}  ST_AsGeoJSON(geom)::json as geom
-          FROM ${table}
-          WHERE ${queryCondition} AND ST_GeometryType(geom) = '${type}' AND geom IS NOT NULL
-        `,
-      };
-    });
-
-    const { rows: [{ srid }] } = await pg.query(`
-      SELECT ST_SRID(geom) AS srid
-      FROM ${table}
-      WHERE geom IS NOT NULL
-      LIMIT 1;
-    `);
-
-    return {
-      columns: exportable,
-      table,
-      srid: srid || 4326,
-      geomTypes: geometryTypes,
-      sqlList
-    };
-  }
-
-  const rows = await pg.query(selectSQL).then(r => r.rows || []);
-
-  if (!rows?.length) {
-    throw NotFoundError('Немає даних, які можна експортувати');
-  }
-
-  const classifiers = exportable
-    .filter(col => col.data && ["select", "badge", "tags"].includes(col.format))
-    .map(col => ({ name: col.name, classifier: col.data }));
-
-  const rowsWithClassifiers = await attachClassifiers(rows, classifiers);
-
-  const simplifiedRows = rowsWithClassifiers.map(row => {
-    const newRow = { ...row };
-
-    for (const key of Object.keys(newRow)) {
-      if (key.endsWith('_data') && typeof newRow[key]?.text === 'string') {
-        const baseKey = key.replace(/_data$/, '');
-        newRow[baseKey] = newRow[key].text;
-      }
-
-      if (key.endsWith('_text') && typeof newRow[key] === 'string') {
-        const baseKey = key.replace(/_text$/, '');
-        newRow[baseKey] = newRow[key];
-      }
-    }
-
-    return newRow;
-  });
-
-  return {
-    rows: simplifiedRows,
-    data: rows,
-    columns: exportable,
-    table
-  };
-}
+import { pgClients } from '@opengis/fastify-table/utils.js';
+import { NotFoundError } from '@opengis/fastify-table/errors.js';
+
+import { attachClassifiers } from '../../registers/functions/classifiers.js';
+
+const pg = pgClients.client;
+
+export default async function getInfo({ finalInfo, format }) {
+  if (!finalInfo) return { error: 'No data found' };
+
+  const table = finalInfo?.table_name;
+  const queryCondition = finalInfo?.query || '1=1';
+  const columns = finalInfo?.columns || finalInfo?.attributes || [];
+  const exportable = columns.filter(c => c.is_export);
+  const selectNames = exportable.map(c => `"${c.name}"`);
+  const selectSQL = `
+    SELECT ${selectNames?.length ? selectNames.join(', ') : ''} ${format === 'geojson' || format === 'shp' ? `${selectNames?.length ? ',' : ''} ST_AsGeoJSON(geom)::json as geom` : ``}
+    FROM ${table}
+    WHERE ${queryCondition} ${format === 'geojson' || format === 'shp' ? `and geom is not null` : ``}
+  `;
+
+  if (format === 'shp') {
+    const { rows: geomTypeRows } = await pg.query(`
+      SELECT DISTINCT ST_GeometryType(geom) AS geom_type
+      FROM ${table}
+      WHERE geom IS NOT NULL
+    `);
+    const geometryTypes = geomTypeRows.map(row => row.geom_type);
+
+    const sqlList = geometryTypes.map(type => {
+      return {
+        type,
+        query: `
+          SELECT ${selectNames.join(', ')} ${selectNames?.length ? ',' : ''}  ST_AsGeoJSON(geom)::json as geom
+          FROM ${table}
+          WHERE ${queryCondition} AND ST_GeometryType(geom) = '${type}' AND geom IS NOT NULL
+        `,
+      };
+    });
+
+    const { rows: [{ srid }] } = await pg.query(`
+      SELECT ST_SRID(geom) AS srid
+      FROM ${table}
+      WHERE geom IS NOT NULL
+      LIMIT 1;
+    `);
+
+    return {
+      columns: exportable,
+      table,
+      srid: srid || 4326,
+      geomTypes: geometryTypes,
+      sqlList
+    };
+  }
+
+  const rows = await pg.query(selectSQL).then(r => r.rows || []);
+
+  if (!rows?.length) {
+    throw NotFoundError('Немає даних, які можна експортувати');
+  }
+
+  const classifiers = exportable
+    .filter(col => col.data && ["select", "badge", "tags"].includes(col.format))
+    .map(col => ({ name: col.name, classifier: col.data }));
+
+  const rowsWithClassifiers = await attachClassifiers(rows, classifiers);
+
+  const simplifiedRows = rowsWithClassifiers.map(row => {
+    const newRow = { ...row };
+
+    for (const key of Object.keys(newRow)) {
+      if (key.endsWith('_data') && typeof newRow[key]?.text === 'string') {
+        const baseKey = key.replace(/_data$/, '');
+        newRow[baseKey] = newRow[key].text;
+      }
+
+      if (key.endsWith('_text') && typeof newRow[key] === 'string') {
+        const baseKey = key.replace(/_text$/, '');
+        newRow[baseKey] = newRow[key];
+      }
+    }
+
+    return newRow;
+  });
+
+  return {
+    rows: simplifiedRows,
+    data: rows,
+    columns: exportable,
+    table
+  };
+}