@opengis/cms 0.0.2 → 0.0.3

package/server/routes/builder/controllers/cms.builder.get.js

@@ -0,0 +1,17 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function builderGet({ pg = pgClients.client, params = {} }) {
+
+
+  const { pk } = await getMeta({ table: 'site.content_types' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const { rows, rowCount: total } = await pg.query(
+    `select a.content_type_id as id, a.* FROM site.content_types a
+   where a.content_type_id=$1`, [params.id]
+  );
+  return { message: { total, rows }, status: 200 };
+}

package/server/routes/builder/controllers/cms.builder.list.js

@@ -0,0 +1,16 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function builderList({ pg = pgClients.client, query = {} }) {
+
+  const { pk } = await getMeta({ table: 'site.content_types' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+  const sql = `select a.content_type_id as id, a.* FROM site.content_types a
+  where ${query.content_type_id ? 'content_type_id=$1' : '1=1'}`
+
+  const { rows, rowCount: total } = await pg.query(sql, [query.content_type_id].filter((el) => el));
+
+  return { message: { total, rows }, status: 200 };
+}

package/server/routes/builder/controllers/cms.builder.post.js

@@ -0,0 +1,21 @@
+import { dataInsert, getMeta } from "@opengis/fastify-table/utils.js";
+
+export default async function builderPost(req) {
+  const { user = {}, body = {} } = req;
+
+  const { pk } = await getMeta({ table: "site.content_types" });
+
+  if (!pk) {
+    return { message: "table not found", status: 404 };
+  }
+
+  const resData = await dataInsert({
+    table: "site.content_types",
+    data: body,
+    uid: user?.uid,
+  });
+//   console.log(resData);
+  const res = resData?.rows[0];
+
+  return { id: res.content_type_id, rows: [res] };
+}

package/server/routes/builder/controllers/cms.builder.put.js

@@ -0,0 +1,23 @@
+import { dataUpdate, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function builderPut(req) {
+  const { user = {}, body = {}, params = {} } = req;
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.content_types' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const resData = await dataUpdate({
+    table: 'site.content_types', 
+    data: body, 
+    id: params.id,
+  });
+//   console.log(resData)
+  const res = resData;
+
+  return { id: res.content_type_id, rows: [res] };
+}

package/server/routes/builder/index.mjs

@@ -0,0 +1,22 @@
+import cmsBuilderGet from './controllers/cms.builder.get.js';
+import cmsBuilderList from './controllers/cms.builder.list.js';
+import cmsBuilderPut from './controllers/cms.builder.put.js';
+import cmsBuilderPost from './controllers/cms.builder.post.js';
+import cmsBuilderDelete from './controllers/cms.builder.delete.js';
+
+export default async function route(app) {
+  // builder add
+  app.post('/cms-builder', { config: { policy: ['site'] }}, cmsBuilderPost);
+
+  // builder edit
+  app.put('/cms-builder/:id', { config: { policy: ['site'] }}, cmsBuilderPut);
+
+  // builder list
+  app.get('/cms-builder',  { config: { policy: ['site'] }}, cmsBuilderList);
+
+  // builder get
+  app.get('/cms-builder/:id', { config: { policy: ['site'] }}, cmsBuilderGet);
+
+  // builder delete
+  app.delete('/cms-builder/:id', { config: { policy: ['site'] }}, cmsBuilderDelete);
+}

package/server/routes/category/controllers/cms.category.delete.js

@@ -0,0 +1,21 @@
+import { dataDelete, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function categoryDelete({ user = {}, params = {} }) {
+
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.categories' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const res = await dataDelete({
+    table: 'site.categories', 
+    id: params.id,
+    uid: user?.uid
+  });
+
+  return { id: res.category_id, rows: [res] };
+}

package/server/routes/category/controllers/cms.category.get.js

@@ -0,0 +1,17 @@
+import { pgClients, getMeta, getTemplate } from '@opengis/fastify-table/utils.js';
+
+export default async function categoryGet({ pg = pgClients.client, params = {} }) {
+
+  const { pk } = await getMeta({ table: 'site.categories' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const { rows, rowCount: total } = await pg.query(
+    `select a.category_id as id, a.* FROM site.categories a
+   where a.category_id=$1`,
+    [params.id]
+  );
+  return { message: { total, rows }, status: 200 };
+}

package/server/routes/category/controllers/cms.category.list.js

@@ -0,0 +1,16 @@
+import { pgClients, getTemplate, getMeta }  from '@opengis/fastify-table/utils.js';
+
+export default async function categoryList({ pg = pgClients.client, query = {} }) {
+
+  const { pk } = await getMeta({ table: 'site.categories' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+  const sql = `select a.category_id as id, a.* FROM site.categories a
+  where ${query.category_id ? 'category_id=$1' : '1=1'}`
+
+  const { rows, rowCount: total } = await pg.query(sql, [query.category_id].filter((el) => el));
+
+  return { message: { total, rows }, status: 200 };
+}

package/server/routes/category/controllers/cms.category.post.js

@@ -0,0 +1,21 @@
+import { dataInsert, getMeta } from "@opengis/fastify-table/utils.js";
+
+export default async function categoryPost(req) {
+  const { user = {}, body = {} } = req;
+
+  const { pk } = await getMeta({ table: "site.categories" });
+
+  if (!pk) {
+    return { message: "table not found", status: 404 };
+  }
+
+  const resData = await dataInsert({
+    table: "site.categories",
+    data: body,
+    uid: user?.uid,
+  });
+//   console.log(resData);
+  const res = resData?.rows[0];
+
+  return { id: res.category_id, rows: [res] };
+}

package/server/routes/category/controllers/cms.category.put.js

@@ -0,0 +1,23 @@
+import { dataUpdate, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function categoryPut({ body = {}, params = {} }) {
+
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.categories' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const resData = await dataUpdate({
+    table: 'site.categories', 
+    data: body, 
+    id: params.id,
+  });
+//   console.log(resData)
+  const res = resData;
+
+  return { id: res.category_id, rows: [res] };
+}

package/server/routes/category/index.mjs

@@ -0,0 +1,22 @@
+import cmsCategoryGet from './controllers/cms.category.get.js';
+import cmsCategoryList from './controllers/cms.category.list.js';
+import cmsCategoryPut from './controllers/cms.category.put.js';
+import cmsCategoryPost from './controllers/cms.category.post.js';
+import cmsCategoryDelete from './controllers/cms.category.delete.js'
+
+export default async function route(app) {
+  // category add
+  app.post('/cms-category', {}, cmsCategoryPost);
+
+  // category edit
+  app.put('/cms-category/:id', {}, cmsCategoryPut);
+
+  // category list
+  app.get('/cms-category', {  config: { policy: ['site'] }}, cmsCategoryList);
+
+  // category get
+  app.get('/cms-category/:id', {}, cmsCategoryGet);
+
+  // category delete
+  app.delete('/cms-category/:id', {  config: { policy: ['site'] }}, cmsCategoryDelete);
+}

package/server/routes/manager/controllers/cms.manager.delete.js

@@ -0,0 +1,22 @@
+import { dataDelete, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function managerDelete({ user = {}, params = {} }) {
+
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.contents' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const res = await dataDelete({
+    table: 'site.contents', 
+    id: params.id,
+    uid: user?.uid
+  });
+
+
+  return { id: res.content_id, rows: [res] };
+}

package/server/routes/manager/controllers/cms.manager.get.js

@@ -0,0 +1,21 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function managerGet({ pg = pgClients.client, params = {} }) {
+
+  if (!params.template && params.id) return { message: 'bad request', status: 400 }
+
+  const { pk } = await getMeta({ table: 'site.contents' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const { rows, rowCount: total } = await pg.query(
+    `select a.content_id as id, a.* FROM site.contents a
+   where template=$1 and content_id=$2`, [params.template, params.id]
+  );
+
+  const { rows: type } = await pg.query(`select name, template, description, type from site.content_types where template=$1`, [params.template])
+
+  return { message: { total, rows, type: type[0] }, status: 200 };
+}

package/server/routes/manager/controllers/cms.manager.list.js

@@ -0,0 +1,31 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+const types = {
+  enabled: 'Switcher'
+};
+
+export default async function builderList({ pg = pgClients.client, params = {} }) {
+  if (!params.template) {
+    return { message: 'not enougn params: template', status: 400 }
+  }
+
+  if (!pg.pk?.['site.contents']) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const { columns = [] } = await getMeta({ table: 'site.contents' });
+
+  const { rows, rowCount: total } = await pg.query(
+    `select a.content_id as id, a.* FROM site.contents a
+   where template=$1`, [params.template]
+  );
+
+  const { rows: type } = await pg.query(`select name, template, description, type, columns from site.content_types where template=$1`, [params.template])
+
+  const columns1 = (type[0]?.columns || []).concat(
+    columns
+      .filter(el => !['cdate', 'editor_date', 'uid', 'editor_date'].includes(el.name))
+      .map(({ title, name }) => ({ title, name, type: types[name] || 'Text' }))
+  );
+  return { message: { total, rows, type: type[0], columns: columns1 }, status: 200 };
+}

package/server/routes/manager/controllers/cms.manager.post.js

@@ -0,0 +1,28 @@
+import { dataInsert, getMeta } from "@opengis/fastify-table/utils.js";
+
+export default async function builderPost(req) {
+  const { user = {}, params= {}, body = {} } = req;
+
+  if (!params.template) return { message: 'bad request', status: 400 }
+  
+  const { pk } = await getMeta({ table: "site.contents" });
+
+  if (!pk) {
+    return { message: "table not found", status: 404 };
+  }
+
+  const bodyModified = Object.assign(body, {
+    template: params.template
+  });
+
+    
+  const resData = await dataInsert({
+    table: "site.contents",
+    data: bodyModified,
+    uid: user?.uid,
+  });
+//   console.log(resData);
+  const res = resData?.rows[0];
+
+  return { id: res.content_id, rows: [res] };
+}

package/server/routes/manager/controllers/cms.manager.put.js

@@ -0,0 +1,23 @@
+import { dataUpdate, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function managerPut({ body = {}, params = {} }) {
+
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.contents' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const resData = await dataUpdate({
+    table: 'site.contents', 
+    data: body, 
+    id: params.id,
+  });
+  // console.log(resData)
+  const res = resData;
+
+  return { id: res.content_id, rows: [res] };
+}

package/server/routes/manager/index.mjs

@@ -0,0 +1,22 @@
+import cmsManagerGet from './controllers/cms.manager.get.js';
+import cmsManagerList from './controllers/cms.manager.list.js';
+import cmsManagerPut from './controllers/cms.manager.put.js';
+import cmsManagerPost from './controllers/cms.manager.post.js';
+import cmsManagerDelete from './controllers/cms.manager.delete.js';
+
+export default async function route(app) {
+  // manager add
+  app.post('/cms-manager/:template',  {  config: { policy: ['site'] }}, cmsManagerPost);
+
+  // manager edit
+  app.put('/cms-manager/:id', {  config: { policy: ['site'] }}, cmsManagerPut); 
+
+  // manager list
+  app.get('/cms-manager/:template', {  config: { policy: ['site'] }}, cmsManagerList);
+
+  // manager get
+  app.get('/cms-manager/:template/:id', {  config: { policy: ['site'] }}, cmsManagerGet);
+
+  // manager delete
+  app.delete('/cms-manager/:id', {  config: { policy: ['site'] }}, cmsManagerDelete);
+}

package/server/routes/media/controllers/delete.js

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+
+import { config, getToken, dataDelete, getFolder, pgClients } from "@opengis/fastify-table/utils.js";
+
+const rootDir = getFolder(config, 'local');
+
+export default async function deleteMedia({
+    pg = pgClients.client, params = {}, user = {},
+}, reply) {
+
+    if (!params?.token) {
+        return reply.status(400).send('not enough params: token');
+    }
+
+    const tokenData = await getToken({
+        uid: user?.uid || 0,
+        token: params.token,
+        json: 1,
+    });
+
+    const { dir, name, relpath, id } = pg.pk?.['crm.media'] && tokenData?.type !== 'dir'
+        ? await pg.query(`select media_id as id, uploaded_name as name, file_path as "relpath" from crm.media where $1 in (media_id, file_path)`, [tokenData?.id || tokenData?.relpath || params.token])
+            .then(el => el.rows?.[0] || {})
+        : tokenData;
+
+    if (!dir && !(id && relpath)) {
+        return reply.status(403).send('access restricted: root dir');
+    }
+
+    // delete file
+    if (id && relpath) {
+        const res = await dataDelete({
+            id,
+            table: 'crm.media',
+            uid: user?.uid || 0,
+        });
+        const filepath = path.join(rootDir, relpath);
+
+        if (existsSync(filepath)) {
+            await rm(filepath, { recursive: true });
+        }
+
+        return {
+            id: tokenData?.id || id,
+            name: res?.uploaded_name,
+            size: res?.size,
+            extension: res?.ext,
+            caption: res?.caption,
+            altname: res?.altname,
+        };
+    }
+
+    // delete directory
+    const dirpath = path.join(rootDir, relpath);
+    await rm(dirpath, { recursive: true });
+    return reply.status(200).send({ name: path.basename(relpath) });
+}

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

@@ -0,0 +1,94 @@
+import path from 'node:path';
+import { rename, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+
+import { config, getToken, getFolder, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
+
+const rootDir = getFolder(config, 'local');
+
+export default async function editMedia({
+    pg = pgClients.client, params = {}, user = {}, body = {},
+}, reply) {
+
+    const tokenData = await getToken({
+        uid: user?.uid || 0,
+        token: params.token,
+        json: 1,
+    });
+
+    const objdata = pg.pk?.['crm.media'] && !tokenData
+        ? await pg.query(`select media_id as id, uploaded_name as name, file_path as "relpath" from crm.media where media_id=$1`, [params.token]).then(el => el.rows?.[0] || {})
+        : tokenData;
+
+    const { id, name } = objdata;
+    const relpath = (objdata?.relpath || tokenData?.relpath)?.replace(/\\/g, '/');
+
+    if ((tokenData?.type === 'file' && !id) || !relpath) {
+        return reply.status(400).send('invalid params: token');
+    }
+
+    const data = {};
+    const oldfilepath = path.join(rootDir, relpath);
+
+    if (tokenData?.type === 'dir' && !body?.name) {
+        return reply.status(400).send('not enough body params: name');
+    }
+
+    if (body?.name) {
+        const newfilepath = path.join(rootDir, path.dirname(relpath), body.name);
+
+        if (!existsSync(oldfilepath)) {
+            return reply.status(404).send('file / directory not found');
+        }
+
+        if (existsSync(newfilepath)) {
+            return reply.status(400).send('file / directory with such name already exists');
+        }
+
+        // sync file path in db data
+        const arr = tokenData?.type === 'dir' ? await readdir(oldfilepath, { withFileTypes: true }) : [];
+
+        await rename(oldfilepath, newfilepath);
+
+        if (tokenData?.type === 'dir') {
+            const relpaths = arr.filter(el => el.isFile()).map(el => path.join(tokenData.relpath, el.name).replace(/\\/g, '/'));
+            const { rows = [] } = pg.pk?.['crm.media'] ? await pg.query(`select media_id as id, file_path as relpath from crm.media where file_path=any($1::text[])`, [relpaths]) : {};
+            await Promise.all(rows.map(async (el) => dataUpdate({
+                id: el.id,
+                table: 'crm.media',
+                data: {
+                    file_path: el.relpath.replace(relpath.replace(/\\/g, '/'), path.join(path.dirname(relpath), body.name).replace(/\\/g, '/'))
+                },
+                uid: user?.uid || 0,
+            })));
+            return reply.status(200).send({
+                name: body.name,
+                relpath: path.join(path.dirname(relpath), body.name).replace(/\\/g, '/'),
+            });
+        }
+        Object.assign(data, {
+            uploaded_name: body.name,
+            file_path: path.join(path.dirname(relpath), body.name).replace(/\\/g, '/'),
+        });
+    }
+
+    if (body?.caption) Object.assign(data, { caption: body.caption });
+    if (body?.altname) Object.assign(data, { altname: body.altname });
+
+    const res = await dataUpdate({
+        id,
+        table: 'crm.media',
+        data,
+        uid: user?.uid || 0,
+    });
+
+    return {
+        id: tokenData?.id || id,
+        name: res?.uploaded_name,
+        relpath: res?.file_path,
+        size: res?.size,
+        extension: res?.ext,
+        caption: res?.caption,
+        altname: res?.altname,
+    };
+}

package/server/routes/media/controllers/list.js

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+
+import { config, getFolder, pgClients, setToken } from '@opengis/fastify-table/utils.js';
+
+const rootDir = getFolder(config, 'local');
+mkdirSync(path.join(rootDir, 'media'), { recursive: true });
+
+export default async function listMedia(req, reply) {
+    const { pg = pgClients.client, query = {}, user = {} } = req;
+    const { dir } = query;
+    const dirpath = path.join(rootDir, 'media', dir || '');
+
+    if (dir && (typeof dir !== 'string' || dir.includes('..'))) {
+        return reply.status(403).send('invalid params: dir');
+    }
+
+    if (!existsSync(dirpath)) {
+        return { data: [], dir };
+    }
+
+    const token = setToken({
+        ids: [JSON.stringify({ dir, name: dir, relpath: path.join('/media', dir || '').replace(/\\/g, '/') })],
+        uid: user?.uid || 0,
+        array: 1,
+    })?.[0];
+
+    const isDirectory = (await stat(dirpath)).isDirectory();
+
+    const items = isDirectory ? await readdir(dirpath) : [];
+
+    const relpaths = items.map(el => path.join('/media', dir || '', el).replace(/\\/g, '/'));
+    const { rows = [] } = await pg.query(`select media_id as id, uploaded_name as name, file_path as relpath from crm.media where file_path = any($1::text[])`, [relpaths]);
+    const ids = rows.reduce((acc, curr) => Object.assign(acc, { [curr.relpath]: curr.id }), {});
+
+    const data = await Promise.all(items.map(async (item) => {
+        const itempath = path.join(dirpath, item);
+        const extension = path.extname(item) === '' ? null : path.extname(item).split('.').pop();
+        const { ctime, mtime, size } = await stat(itempath);
+        const type = (await stat(itempath)).isDirectory() ? 'dir' : 'file';
+        const childList = type === 'dir' ? await readdir(itempath) : [];
+        const count = type === 'dir' ? childList.length : undefined;
+        return {
+            id: ids[path.join('/media', dir || '', item).replace(/\\/g, '/')],
+            name: item,
+            type,
+            count,
+            size,
+            extension,
+            token: setToken({
+                ids: [JSON.stringify({
+                    id: ids[path.join('/media', dir || '', item).replace(/\\/g, '/')],
+                    dir,
+                    relpath: path.join('/media', dir || '', item).replace(/\\/g, '/'),
+                    name: item,
+                    type,
+                })],
+                uid: user?.uid || 0,
+                array: 1,
+            })[0],
+            ctime,
+            mtime,
+        };
+    }));
+
+    const result = { dir, token, data };
+
+    if (config.debug) {
+        Object.assign(result, { rootDir });
+    }
+
+    return result;
+}

package/server/routes/media/controllers/metadata.js

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+
+import { config, getToken, getFolder, pgClients } from "@opengis/fastify-table/utils.js";
+
+const rootDir = getFolder(config, 'local');
+
+export default async function metadataMedia({
+    pg = pgClients.client, params = {}, user = {},
+}, reply) {
+    if (!params.token) {
+        return reply.status(400).send('not enough params: token');
+    }
+
+    const tokenData = await getToken({
+        uid: user?.uid || 0,
+        token: params.token,
+        json: 1,
+    });
+
+    const { relpath, caption, altname, id } = !tokenData && pg.pk?.['crm.media']
+        ? await pg.query(`select media_id as id, file_path as "relpath", caption from crm.media where media_id=$1`, [params.token]).then(el => el.rows?.[0] || {})
+        : {};
+
+    if ((!tokenData?.name || tokenData?.type !== 'file') && !relpath) {
+        return reply.status(400).send('invalid params: token');
+    }
+
+    const filepath = tokenData?.name
+        ? path.join(rootDir, 'media', tokenData.dir || '', tokenData.name)
+        : path.join(rootDir, relpath);
+
+    if (!existsSync(filepath)) {
+        return reply.status(404).send('file not found');
+    }
+
+    const stats = await stat(filepath);
+    const { ctime, mtime, size } = stats;
+
+    return reply.status(200).send({
+        id: tokenData?.id || id,
+        name: path.basename(filepath),
+        size,
+        extension: path.extname(filepath)?.split?.('.')?.pop?.(),
+        ctime, // creation timestamp
+        mtime, // last modification timestamp
+        caption,
+        altname,
+    });
+}