@opengis/cms 0.0.16 → 0.0.18

package/server/routes/feedback/controllers/news.subscriptions.js

@@ -0,0 +1,44 @@
+import { pgClients, config } from '@opengis/fastify-table/utils.js';
+
+const refererAllow = config?.refererAllow || ['127.0.0.1', 'localhost', 'softpro.ua', 'opengis.info'];
+
+function checkReferer(headers) {
+  if (config?.local) return true;
+  if (!headers?.referer) return false;
+  return refererAllow.some(allowed => headers.referer.includes(allowed));
+}
+
+export default async function subscribeToNews({
+  body = {},
+  pg = pgClients.client,
+  headers
+}, reply) {
+  reply
+    .header('Access-Control-Allow-Origin', '*')
+    .header('Access-Control-Allow-Methods', 'POST, OPTIONS')
+    .header('Access-Control-Allow-Headers', 'Content-Type');
+
+  if (!checkReferer(headers)) {
+    return reply.status(403).send('access restricted');
+  }
+
+  const { email } = body;
+  if (!email) return reply.status(400).send('email is required');
+
+  const { rows: subscriptions } = await pg.query(`
+    SELECT subscription_id
+    FROM site.subscription
+    WHERE email = $1
+    LIMIT 1
+  `, [email]);
+
+  if (subscriptions?.length === 0) {
+    await pg.query(`
+      INSERT INTO site.subscription (email)
+      VALUES ($1)
+    `, [email]);
+
+  } 
+
+  return reply.status(200).send('Успішно');
+}

package/server/routes/feedback/index.mjs

@@ -0,0 +1,72 @@
+import feedback from './controllers/feedback.js';
+import newsSubs from './controllers/news.subscriptions.js';
+import feedbackList from './controllers/feedback.list.js';
+import emailList from './controllers/email.list.js';
+
+export default async function route(fastify) {
+    fastify.route({
+        method: 'POST',
+        url: '/cms-feedback/:type',
+        handler: feedback,
+        config: {
+            policy: ['public'],
+        },
+    });
+
+    fastify.route({
+        method: 'GET',
+        url: '/feedback',
+        handler: feedbackList,
+        config: {
+            policy: ['public'],
+        },
+    });
+
+    fastify.route({
+        method: 'GET',
+        url: '/email-list',
+        handler: emailList,
+        config: {
+            policy: ['public'],
+        },
+    });
+    
+    fastify.route({
+        method: 'OPTIONS',
+        url: '/cms-feedback/:type',
+        handler: (req, reply) => {
+            reply
+                .header('Access-Control-Allow-Origin', '*')
+                .header('Access-Control-Allow-Methods', 'POST, OPTIONS')
+                .header('Access-Control-Allow-Headers', 'Content-Type')
+                .send();
+        },
+        config: {
+            policy: ['public'],
+        },
+    });
+
+    fastify.route({
+        method: 'POST',
+        url: '/cms-subscribtion',
+        handler: newsSubs,
+        config: {
+            policy: ['public'],
+        },
+    });
+
+    fastify.route({
+        method: 'OPTIONS',
+        url: '/cms-subscribtion',
+        handler: (req, reply) => {
+            reply
+                .header('Access-Control-Allow-Origin', '*')
+                .header('Access-Control-Allow-Methods', 'POST, OPTIONS')
+                .header('Access-Control-Allow-Headers', 'Content-Type')
+                .send();
+        },
+        config: {
+            policy: ['public'],
+        },
+    });
+}

package/server/routes/logs/controllers/export.user.logs.js

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import { config, getFolder, jsonToCsv, getFilterSQL } from '@opengis/fastify-table/utils.js';
+
+const rootDir = getFolder(config, 'local');
+
+export default async function exportUserLogs(req, reply) {
+    const { pg, query, user = {} } = req;
+    const { uid } = user;
+    if (!uid) return reply.code(401).send({ message: 'Not authorized', status: 401 });
+
+    const { filter = null } = query;
+
+    const { q: filterQuery } = await getFilterSQL({
+        filter, table: 'log.table_changes'
+    });
+
+    const { rows = [] } = await pg.query(`
+        select 
+        row_number() over(order by cdate desc) as num,
+        change_id,
+        change_type,
+        cdate,
+        entity_type,
+        entity_id,
+        b.data_log 
+        from log.table_changes a
+        left join lateral (
+            select json_agg(
+                row_to_json(q)
+                ) as data_log 
+            from log.table_changes_data q 
+            where change_id=a.change_id 
+            
+        )b on 1=1
+
+        where change_user_id='${uid}' 
+        ${filterQuery ? `and ${filterQuery}` : ''}
+        order by cdate desc
+    `);
+
+    const filePath = path.join(rootDir, `/files/tmp/logs_${uid}.csv`);
+    const ext = path.extname(filePath);
+    const filePathJSON = filePath.replace(ext, '.json');
+
+    await mkdir(path.dirname(filePathJSON), { recursive: true });
+    await writeFile(filePathJSON, JSON.stringify(rows));
+
+    await jsonToCsv({
+        filePath: filePathJSON,
+        colmodel: [
+            { name: 'num', title: '№', ua: '№' },
+            { name: 'change_id', title: 'Ідентифікатор зміни', ua: 'Ідентифікатор зміни' },
+            { name: 'change_type', title: 'Тип зміни', ua: 'Тип зміни' },
+            { name: 'cdate', title: 'Дата та час зміни', ua: 'Дата та час зміни' },
+            { name: 'entity_type', title: 'Тип об\'єкта', ua: 'Тип об\'єкта' },
+            { name: 'entity_id', title: 'Ідентифікатор об\'єкта', ua: 'Ідентифікатор об\'єкта' },
+            { name: 'data_log', title: 'Дані зміни', ua: 'Дані зміни' }
+        ],
+        columnList: [
+            'num',
+            'change_id',
+            'change_type',
+            'cdate',
+            'entity_type',
+            'entity_id',
+            'data_log'
+        ],
+    });
+
+    reply.header('Content-Disposition', `attachment; filename=${encodeURIComponent(path.basename(filePath))}`);
+    reply.header('Content-Type', 'text/csv');
+
+    const fileStream = createReadStream(filePath);
+    return reply.send(fileStream);
+
+}

package/server/routes/logs/controllers/user.logs.js

@@ -0,0 +1,45 @@
+import { getFilterSQL } from '@opengis/fastify-table/utils.js';
+
+export default async function userLogs(req, reply) {
+    const { pg, user = {}, query } = req;
+    const { uid } = user;
+    if (!uid) return reply.code(401).send({ message: 'Not authorized', status: 401 });
+
+    const { page = 1, limit = 16, filter = null } = query;
+    const offset = limit * (page - 1) || 0;
+
+    const { q: filterQuery } = await getFilterSQL({
+        filter, table: 'log.table_changes', filterList: [{ name: 'cdate', type: 'date' }, { name: 'change_type', type: 'check' }]
+    });
+    //return filterData
+
+    const { total, filtered } = await pg.one(`select count(*)::int as total, (count(*) filter(where ${filterQuery ? `${filterQuery}` : '1=1'}))::int as  filtered from log.table_changes where change_user_id=$1`, [uid])
+
+    const { rows = [] } = await pg.query(`
+        select 
+        row_number() over(order by cdate desc) as num,
+        change_id,
+        change_type,
+        cdate,
+        entity_type,
+        entity_id,
+        b.data_log 
+        from log.table_changes a
+        left join lateral (
+            select json_agg(
+                row_to_json(q)
+                ) as data_log 
+            from log.table_changes_data q 
+            where change_id=a.change_id 
+            
+        )b on 1=1
+
+        where change_user_id='${uid}' 
+        ${filterQuery ? `and ${filterQuery}` : ''}
+        order by cdate desc
+        limit ${limit} offset ${offset}
+        `);
+
+    const status = rows?.length ? 200 : 204;
+    return reply.code(status).send({ message: { total, filtered, rows }, status })
+}

package/server/routes/logs/index.mjs

@@ -0,0 +1,9 @@
+import userLogs from './controllers/user.logs.js';
+import exportUserLogs from './controllers/export.user.logs.js';
+
+const params = { config: { policy: ['public'] } };
+
+export default async function route(app) {
+    app.get('/user-logs', params, userLogs);
+    app.get('/export-user-logs', params, exportUserLogs);
+}

package/server/routes/menu/controllers/addMenu.js

@@ -0,0 +1,38 @@
+import { dataInsert, yml2json, json2yml } from "@opengis/fastify-table/utils.js";
+
+export default async function addMenu(req, reply) {
+    const { pg = pgClients.client, params = {}, user = {}, headers = {}, body = {} } = req;
+
+    if (!pg?.pk) {
+        return reply.status(400).send('empty pg');
+    }
+
+    if (!pg?.pk?.['site.menus']) {
+        return reply.status(404).send('table not found');
+    }
+
+    if (!body.name) {
+        return reply.status(404).send('not enough body params: name');
+    }
+
+    if (typeof body.content === 'string') {
+        body.items = yml2json(body.content);
+    } else if (body.items && typeof body.items === 'object') {
+        body.content = json2yml(body.items);
+    }
+
+    const res = await dataInsert({
+        pg,
+        table: 'site.menus',
+        id: params.id,
+        data: body,
+        referer: headers.referer,
+        uid: user.uid,
+    }).then(el => el.rows[0]);
+
+    if (!res) {
+        return reply.status(500).send('insert menu error');
+    }
+
+    return reply.status(200).send(res);
+}

package/server/routes/menu/controllers/delMenu.js

@@ -0,0 +1,32 @@
+import { dataDelete } from "@opengis/fastify-table/utils.js";
+
+export default async function delMenu(req, reply) {
+    const { pg = pgClients.client, params = {}, user = {}, headers = {}, body = {} } = req;
+
+    if (!pg?.pk) {
+        return reply.status(400).send('empty pg');
+    }
+
+    if (!pg?.pk?.['site.menus']) {
+        return reply.status(404).send('table not found');
+    }
+
+    if (!params.id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    const res = await dataDelete({
+        pg,
+        table: 'site.menus',
+        id: params.id,
+        data: body,
+        referer: headers.referer,
+        uid: user.uid,
+    });
+
+    if (!res) {
+        return reply.status(500).send('delete menu error');
+    }
+
+    return reply.status(200).send(res);
+}

package/server/routes/menu/controllers/editMenu.js

@@ -0,0 +1,42 @@
+import { dataUpdate, yml2json, json2yml } from "@opengis/fastify-table/utils.js";
+
+export default async function editMenu(req, reply) {
+    const { pg = pgClients.client, params = {}, user = {}, headers = {}, body = {} } = req;
+
+    if (!pg?.pk) {
+        return reply.status(400).send('empty pg');
+    }
+
+    if (!pg?.pk?.['site.menus']) {
+        return reply.status(404).send('table not found');
+    }
+
+    if (!params.id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    if (typeof body.content === 'string') {
+        body.items = yml2json(body.content || '');
+    } else if (body.items && typeof body.items === 'object') {
+        body.content = json2yml(body.items || {});
+    }
+
+    if (!Object.keys(body.items || {}).length) {
+        return reply.status(400).send('access restricted: empty json items / invalid yml content');
+    }
+
+    const res = await dataUpdate({
+        pg,
+        table: 'site.menus',
+        id: params.id,
+        data: body,
+        referer: headers.referer,
+        uid: user.uid,
+    });
+
+    if (!res) {
+        return reply.status(500).send('update menu error');
+    }
+
+    return reply.status(200).send(res);
+}

package/server/routes/menu/controllers/getMenu.js

@@ -0,0 +1,43 @@
+import { pgClients } from "@opengis/fastify-table/utils.js";
+
+const limit = 16;
+
+const err = { error: 'menu not found', code: 404 };
+
+export default async function getMenu(req, reply) {
+    const { pg = pgClients.client, query = {}, params = {} } = req;
+
+    if (!pg?.pk) {
+        return reply.status(400).send('empty pg');
+    }
+
+    if (!pg?.pk?.['site.menus']) {
+        return reply.status(404).send('table not found');
+    }
+
+    const offset = query.page && query.page > 0 ? (query.page - 1) * limit : 0;
+
+    const q = `select menu_id, name, locale, description ${params.id ? ',items::json, content' : ''} from site.menus 
+    where ${params.id ? '$1 in (menu_id, name)' : '1=1'} 
+    and ${query.locale ? `locale='${query.locale.replace(/'/g, "''")}'` : 'true'}
+    order by (case when locale='uk' then false else true end)
+    limit ${limit} offset ${offset}`;
+
+    if (query.sql) return q;
+
+    const rows = await pg.query(q, [params.id].filter(Boolean))
+        .then(el => el.rows || []);
+
+    if (params.id) {
+        if (!rows.length && params.id) {
+            return reply.status(404).send(err);
+        }
+        return reply.status(200).send(rows[0]);
+    }
+
+    if (!rows.length && params.id) {
+        return reply.status(404).send(err);
+    }
+
+    return reply.status(200).send({ rows });
+}

package/server/routes/menu/index.mjs

@@ -0,0 +1,13 @@
+import getMenu from './controllers/getMenu.js';
+import addMenu from './controllers/addMenu.js';
+import editMenu from './controllers/editMenu.js';
+import delMenu from './controllers/delMenu.js';
+
+const params = { config: { policy: ['public'] } };
+
+export default async function route(app) {
+    app.post('/cms-menu/:id?', params, addMenu);
+    app.put('/cms-menu/:id', params, editMenu);
+    app.delete('/cms-menu/:id', params, delMenu);
+    app.get('/cms-menu/:id?', params, getMenu);
+}

package/server/routes/migration/controllers/collectionToCustom.js

@@ -0,0 +1,137 @@
+export default async function collectionToCustom(req, reply) {
+    const { params, pg, query } = req;
+    const { id } = params;
+
+    if (!id) return reply.code(400).send({ status: 400, message: 'Невказаний id або slug колекції!' });
+
+    const selectTableStructure = `
+    select
+    name,
+    title,
+    columns,
+    type
+    from site.content_types
+    where '${id}' in (content_type_id,name) 
+    limit 1
+    `;
+
+    const { name, title, columns, type } = await pg.one(selectTableStructure);
+
+    if (!name || !title) return reply.code(404).send({ status: 404, message: 'За вказаним параметром колекції не існує!' });
+    if (!columns || columns?.length === 0) return reply.code(400).send({ status: 400, message: 'У вказаної колекції відсутня структура колонок!' });
+    if (type !== 'collection') return reply.code(400).send({ status: 400, message: 'У вказаного об\'єкта тип не відповідає колекції' });
+
+    let createTableSql = `
+    CREATE TABLE IF NOT EXISTS data."${name}"(
+        id text not null DEFAULT next_id(),
+        slug text NOT NULL,
+        title text NOT NULL, 
+        status text NOT NULL DEFAULT 'draft'::text,
+        published_at timestamp without time zone NOT NULL,
+        created_at timestamp without time zone NOT NULL DEFAULT now(),
+        updated_at timestamp without time zone NOT NULL DEFAULT now(),
+        CONSTRAINT "${name}_pkey" PRIMARY KEY (id)
+    );
+    COMMENT ON TABLE data."${name}" IS '${title}';
+    `;
+
+    let recordColumns = [];
+    let columnsArrFormat = [];
+    let columnsArr = [];
+
+    columns?.forEach(column => {
+        if (column?.name && column?.type) {
+            const columnType = (() => {
+                switch (column?.type) {
+                    case 'text': return 'text';
+                    case 'number': return 'numeric';
+                    case 'integer': return 'integer';
+                    case 'date': return 'date';
+                    case 'datetime': return 'timestamp without time zone';
+                    case 'select': return 'text';
+                    case 'multiselect': return 'text[]';
+                    case 'radio': return 'text[]';
+                    case 'boolean': return 'boolean';
+                    case 'array':
+                        switch (column?.subtype) {
+                            case 'text': return 'text[]';
+                            case 'number': return 'numeric[]';
+                            case 'integer': return 'integer[]';
+                            case 'date': return 'date[]';
+                            case 'datetime': return 'timestamp without time zone[]';
+                            case 'boolean': return 'boolean[]';
+                            default: return 'text[]';
+                        }
+                    case 'datalist': return 'json';
+                    case 'image': return 'text';
+                    case 'slug': return 'text';
+                    case 'richtext': return 'text';
+                    case 'FileList': return 'text[]';
+                    default: return 'text';
+                }
+            })();
+
+            const columnSql = `\nALTER TABLE data."${name}" ADD COLUMN IF NOT EXISTS "${column.name}" ${columnType};\nCOMMENT ON COLUMN data."${name}"."${column.name}" IS '${column?.label}';
+            `;
+            createTableSql += columnSql;
+
+            const recordColumn = `"${column.name}" ${columnType}`;
+            recordColumns.push(recordColumn);
+            columnsArr.push(`"${column.name}"`);
+            if (columnType === 'json') {
+                columnsArrFormat.push(`replace(replace(replace("${column.name}"::text,'\"','"'),'"[','['), ']"',']')::json as "${column.name}"`);
+            } else {
+                columnsArrFormat.push(`"${column.name}"`);
+            }
+
+
+        }
+    });
+    if (query?.sql == 1) return createTableSql;
+    await pg.query(createTableSql);
+
+    const insertSql = `
+    insert into data."${name}" (
+    id,${columnsArr.join(',')}
+    )
+    SELECT 
+    id,${columnsArrFormat.join(',')}
+    FROM
+
+    (
+    select 
+     jsonb_build_object('id',object_id)||jsonb_object_agg(field_key,field_value) as row
+    from site.content_data
+    where content_id = (
+        select content_id
+        from site.contents
+        where content_type_id = (
+            select content_type_id
+            from site.content_types 
+            where '${id}' in (name,content_type_id)
+            limit 1
+            )
+        limit 1
+    )
+    group by object_id
+    )q,
+    jsonb_to_record(row) AS x(
+        id text,${recordColumns.join(',')}
+    )
+    on conflict (id) do nothing;`;
+    //return insertSql;
+    if (query?.sql == 2) return insertSql;
+    await pg.query(insertSql);
+
+    await pg.one(`
+        update site.content_types
+        set table_name='${name}'
+        where name='${name}'
+        `);
+
+    return reply.code(200).send({
+        status: 200,
+        message: `Табличку data.\"${name}\" успішно створено, дані колекції перенесено.`
+    });
+
+}

package/server/routes/migration/index.mjs

@@ -0,0 +1,8 @@
+import collectionToCustom from './controllers/collectionToCustom.js';
+
+const params = { config: { policy: ['public'] } };
+
+export default async function route(app) {
+
+    app.get('/collection-to-custom/:id', params, collectionToCustom);
+}

package/server/routes/tags/controllers/add.tags.js

@@ -0,0 +1,25 @@
+import { dataInsert } from "@opengis/fastify-table/utils.js";
+
+export default async function addTags(req, reply) {
+    const { pg, body, user } = req;
+
+    const { uid } = user || {};
+
+    if (!uid) {
+        return reply.code(401).send({ message: 'access restricted', status: 401 })
+    }
+
+    if (!body) {
+        return reply.code(400).send({ message: 'body is empty!', status: 400 });
+    }
+
+    await dataInsert({
+        pg,
+        table: 'site.tags',
+        data: body,
+        uid,
+    });
+
+    return reply.code(201).send({ message: 'Tag added successfully', status: 201 });
+
+}

package/server/routes/tags/controllers/del.tags.js

@@ -0,0 +1,20 @@
+import { pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function delTags(req, reply) {
+    const { pg = pgClients.client, user = {}, params = {} } = req;
+    const { id } = params;
+
+    const { uid } = user;
+
+    if (!uid) {
+        return reply.code(401).send('unauthorized');
+    }
+
+    if (!id) {
+        return reply.code(400).send('id is required!');
+    }
+
+    await pg.query('delete from site.tags where tag_id=$1', [id]);
+
+    return reply.code(200).send({ message: 'Tag deleted', status: 200 });
+};

package/server/routes/tags/controllers/edit.tags.js

@@ -0,0 +1,26 @@
+import { dataUpdate } from "@opengis/fastify-table/utils.js";
+
+export default async function editTags({ pg, body, user, params }, reply) {
+    const { uid } = user || {};
+
+    if (!uid) {
+        return reply.code(401).send({ message: 'access restricted', status: 401 });
+    }
+
+    if (!params?.id) {
+        return reply.code(400).send({ message: 'id is required!', status: 400 });
+    }
+    if (!body) {
+        return reply.code(400).send({ message: 'body is empty!', status: 400 });
+    }
+
+    await dataUpdate({
+        pg,
+        id: params.id,
+        table: 'site.tags',
+        data: body,
+        uid,
+    });
+
+    return reply.code(200).send({ message: 'Tag updated successfully', status: 200 });
+}

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

@@ -0,0 +1,16 @@
+export default async function getTags(req, reply) {
+    const { pg, query } = req;
+    const { page = 1, limit = 16, search } = query;
+    const offset = limit * (page - 1) || 0;
+
+    const { total, filtered } = await pg.one(`select count(*)::int as total, (count(*) filter (where 1=1 ${search ? `and value ilike'%${search}%'` : ''}))::int as filtered from site.tags`);
+
+    const selectSql = `select *,(select count(*)::int as count_data from site.tag_data where tag_id=a.tag_id) from site.tags a 
+    where 1=1 ${search ? `and value ilike'%${search}%'` : ''}
+    order by created_at desc limit ${limit} offset ${offset}`;
+
+    const { rows } = await pg.query(selectSql);
+
+    return reply.code(200).send({ message: { total, filtered, rows }, status: 200 })
+
+}

package/server/routes/tags/index.mjs

@@ -0,0 +1,14 @@
+import getTags from './controllers/get.tags.js';
+import addTags from './controllers/add.tags.js';
+import editTags from './controllers/edit.tags.js';
+import delTags from './controllers/del.tags.js';
+
+const policyPublic = { config: { policy: ['public'] } };
+
+export default async function route(app) {
+    app.get('/tags', policyPublic, getTags);
+    app.post('/tags', policyPublic, addTags);
+    app.put('/tags/:id', policyPublic, editTags);
+    app.delete('/tags/:id', policyPublic, delTags);
+
+}