@opengis/admin 0.2.114 → 0.2.115

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

@@ -1,55 +1,55 @@
-import { pgClients } from '@opengis/fastify-table/utils.js';
-
-import { getAdminAccess } from '../../../../utils.js';
-import accessGroup from './access.group.js';
-
-export default async function accessGroupPost({
-    pg = pgClients.client, params = {}, session = {}, body = {},
-}) {
-    const { id } = params;
-    const { user } = session?.passport || {};
-    if (!user) return { status: 403, message: 'access restricted' }
-
-    // restrict access - admin only
-    const check = await getAdminAccess({ id, user });
-    if (check) return check;
-
-    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 { message: { id, routes }, status: 200 };
-        }
-    }
-
-    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 { message: { id, routes: rows }, status: 200 };
-        }
-    }
-
-    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, "''")}','${uid?.replace(/'/g, "''")}')`)}`;
-
-    await pg.query(q);
-
-    const res = await accessGroup({ pg, params, session });
-
-    return res;
+import { pgClients } from '@opengis/fastify-table/utils.js';
+
+import { getAdminAccess } from '../../../../utils.js';
+import accessGroup from './access.group.js';
+
+export default async function accessGroupPost({
+    pg = pgClients.client, params = {}, session = {}, body = {},
+}) {
+    const { id } = params;
+    const { user } = session?.passport || {};
+    if (!user) return { status: 403, message: 'access restricted' }
+
+    // restrict access - admin only
+    const check = await getAdminAccess({ id, user });
+    if (check) return check;
+
+    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 { message: { id, routes }, status: 200 };
+        }
+    }
+
+    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 { message: { id, routes: rows }, status: 200 };
+        }
+    }
+
+    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, "''")}','${uid?.replace(/'/g, "''")}')`)}`;
+
+    await pg.query(q);
+
+    const res = await accessGroup({ pg, params, session });
+
+    return res;
 }

package/server/routes/access/index.mjs

@@ -1,11 +1,11 @@
-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) {
-    fastify.get('/access-group/:id', { schema: accessGroupSchema }, accessGroup);
-    fastify.post('/access-group/:id', { schema: accessGroupPostSchema }, accessGroupPost);
-    fastify.get('/access-interface/:name', { schema: accessInterfaceSchema }, accessInterface);
-}
+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) {
+    fastify.get('/access-group/:id', { schema: accessGroupSchema }, accessGroup);
+    fastify.post('/access-group/:id', { schema: accessGroupPostSchema }, accessGroupPost);
+    fastify.get('/access-interface/:name', { schema: accessInterfaceSchema }, accessInterface);
+}

package/server/routes/access/schema.mjs

@@ -1,68 +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'],
-                            },
-                        },
-                    },
-                },*/
-            },
-        },
-    },
+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/calendar/controllers/calendar.data.js

@@ -1,126 +1,126 @@
-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 = pgClients.client, params = {}, query = {}, session = {},
-}) {
-    const { name } = params;
-    const { granularity = 'month' } = query;
-    const { user = {} } = session.passport || {};
-
-    if (!name) {
-        return { message: 'not enough params: name', status: 400 };
-    }
-
-    if (query.granularity && !['day', 'month', 'week', 'year'].includes(granularity)) {
-        return { message: 'invalid query params: granularity', status: 400 };
-    }
-
-    const body = await getTemplate('calendar', name);
-
-    if (!body) {
-        return { message: `calendar not found: ${name}`, status: 404 };
-    }
-
-    const {
-        title,
-        table,
-        meta = {},
-    } = body || {};
-
-    if (!table) {
-        return { message: 'not enough calendar params: table', status: 404 };
-    }
-    if (!pg.pk?.[table]) {
-        return { message: `table pkey not found: ${table}`, status: 404 };
-    }
-
-    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 ')
-        : undefined;
-
-    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 filters = [];
-    if (filtersByColumn?.length) {
-        await Promise.all(filtersByColumn.map(async (el) => {
-            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 getTemplate(['cls', 'select'], el.cls);
-
-            if (!el.cls || !clsData?.length) {
-                filterData.forEach((item) => filters.push(item));
-                return;
-            }
-
-            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 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 ${metaColumns.join(',')} from ${table} where ${where}`;
-    if (query?.sql && user?.user_type?.includes('admin')) return q;
-
-    const { rows = [] } = await pg.query(q);
-
-    return { title, filters, granularity, sql: user?.user_type?.includes('admin') ? q : undefined, rows };
-
+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 = pgClients.client, params = {}, query = {}, session = {},
+}) {
+    const { name } = params;
+    const { granularity = 'month' } = query;
+    const { user = {} } = session.passport || {};
+
+    if (!name) {
+        return { message: 'not enough params: name', status: 400 };
+    }
+
+    if (query.granularity && !['day', 'month', 'week', 'year'].includes(granularity)) {
+        return { message: 'invalid query params: granularity', status: 400 };
+    }
+
+    const body = await getTemplate('calendar', name);
+
+    if (!body) {
+        return { message: `calendar not found: ${name}`, status: 404 };
+    }
+
+    const {
+        title,
+        table,
+        meta = {},
+    } = body || {};
+
+    if (!table) {
+        return { message: 'not enough calendar params: table', status: 404 };
+    }
+    if (!pg.pk?.[table]) {
+        return { message: `table pkey not found: ${table}`, status: 404 };
+    }
+
+    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 ')
+        : undefined;
+
+    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 filters = [];
+    if (filtersByColumn?.length) {
+        await Promise.all(filtersByColumn.map(async (el) => {
+            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 getTemplate(['cls', 'select'], el.cls);
+
+            if (!el.cls || !clsData?.length) {
+                filterData.forEach((item) => filters.push(item));
+                return;
+            }
+
+            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 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 ${metaColumns.join(',')} from ${table} where ${where}`;
+    if (query?.sql && user?.user_type?.includes('admin')) return q;
+
+    const { rows = [] } = await pg.query(q);
+
+    return { title, filters, granularity, sql: user?.user_type?.includes('admin') ? q : undefined, rows };
+
 }

package/server/routes/calendar/index.mjs

@@ -1,7 +1,7 @@
-import calendarData from "./controllers/calendar.data.js";
-
-import { calendarDataSchema } from './schema.js';
-
-export default async function route(fastify) {
-    fastify.get('/calendar/:name', { schema: calendarDataSchema }, calendarData);
-}
+import calendarData from "./controllers/calendar.data.js";
+
+import { calendarDataSchema } from './schema.js';
+
+export default async function route(fastify) {
+    fastify.get('/calendar/:name', { schema: calendarDataSchema }, calendarData);
+}

package/server/routes/calendar/schema.js

@@ -1,22 +1,22 @@
-const calendarDataSchema = {
-  params: {
-    name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-  },
-  querystring: {
-    date: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$' },
-    sql: { type: 'string', pattern: '^(\\d)$' },
-  },
-
-  // query: {
-  //     type: 'object',
-  //     properties: {
-  //         date: {
-  //             type: 'string',
-  //             format: 'date',
-  //         },
-  //     },
-  // },
-};
-
-export { calendarDataSchema }
+const calendarDataSchema = {
+  params: {
+    name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+  },
+  querystring: {
+    date: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$' },
+    sql: { type: 'string', pattern: '^(\\d)$' },
+  },
+
+  // query: {
+  //     type: 'object',
+  //     properties: {
+  //         date: {
+  //             type: 'string',
+  //             format: 'date',
+  //         },
+  //     },
+  // },
+};
+
+export { calendarDataSchema }
 export default null;