@opengis/cms 0.0.1

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,
+    });
+}

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

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+
+import { config, getToken, getFolder } from "@opengis/fastify-table/utils.js";
+import { getMimeType } from '@opengis/fastify-file/utils.js';
+
+const rootDir = getFolder(config, 'local');
+
+export default async function deleteMedia({
+    params = {}, query = {}, 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 } = tokenData || {};
+
+    if (!relpath) {
+        return reply.status(403).send('invalid token');
+    }
+
+    const filepath = path.join(rootDir, relpath);
+
+    if (!existsSync(filepath)) {
+        return reply.status(404).send('file not found');
+    }
+
+    const buffer = await readFile(filepath, { buffer: true });
+
+    if (query?.download) {
+        const headers = {
+            'Content-Type': getMimeType(filepath),
+            'Content-Disposition': `attachment; filename=${path.basename(filepath)}`
+        };
+        return reply.headers(headers).send(buffer);
+    }
+
+    return reply.headers({ 'Content-Type': getMimeType(filepath) }).send(buffer);
+}

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

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import { mkdir, rename } from 'node:fs/promises';
+
+import { config, getToken, getFolder, setToken, dataInsert } from "@opengis/fastify-table/utils.js";
+import { uploadMultiPart } from '@opengis/fastify-file/utils.js';
+
+const rootDir = getFolder(config, 'local');
+
+export default async function uploadMedia(req, reply) {
+    const { params = {}, user = {}, body = {} } = req;
+
+    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,
+    });
+
+    if (!tokenData) {
+        return reply.status(403).send('invalid params: token');
+    }
+
+    const { name: dirname } = tokenData;
+
+    // upload assets
+    if (req.headers['content-type']?.split?.(';')?.shift?.() === 'multipart/form-data') {
+        const file = await uploadMultiPart(req);
+        const filename = `${file.newFilename}${path.extname(file.filepath)}`;
+        const newfilepath = path.join(rootDir, 'media', dirname || '', filename);
+        // console.log(file.filepath, newfilepath);
+        await rename(file.filepath, newfilepath);
+
+        const id = await dataInsert({
+            table: 'crm.media',
+            data: {
+                uploaded_name: file.originalFilename,
+                file_path: path.join('/media', dirname || '', filename).replace(/\\/g, '/'),
+                ext: path.extname(file.filepath)?.split('.')?.pop?.(),
+                size: file.size,
+            },
+            uid: user?.uid || 0,
+        }).then(el => el?.rows?.[0]?.media_id);
+        const result = {
+            dir: dirname,
+            id,
+            name: filename,
+            type: 'file',
+            token: setToken({
+                ids: [JSON.stringify({ id, dir: dirname, relpath: path.join('/media', dirname || '', filename).replace(/\\/g, '/'), name: filename, type: 'file' })],
+                uid: user?.uid || 0,
+                array: 1,
+            })[0],
+        };
+        return reply.status(200).send(result);
+    }
+
+    // create directory
+    if (!body?.name || typeof body.name !== 'string' || body.name.includes('..')) {
+        return reply.status(400).send('invalid body params: name');
+    }
+
+    const subdir = path.join('/media', dirname || '', body.name).replace(/\\/g, '/');
+    const dirpath = path.join(rootDir, subdir);
+    await mkdir(dirpath, { recursive: true });
+
+    return reply.status(200).send({
+        dir: subdir,
+        name: body.name,
+        type: 'dir',
+        token: setToken({
+            ids: [JSON.stringify({ relpath: subdir, name: body.name, type: 'dir' })],
+            uid: user?.uid || 0,
+            array: 1,
+        })[0],
+    });
+}

package/server/routes/media/index.mjs

@@ -0,0 +1,16 @@
+import list from './controllers/list.js';
+import metadata from './controllers/metadata.js';
+import upload from './controllers/upload.js';
+import edit from './controllers/edit.js';
+import del from './controllers/delete.js';
+import preview from './controllers/preview.js';
+
+export default async function route(app) {
+    app.get('/cms-media', { config: { policy: ['site'] } }, list);
+    app.get('/cms-media/:token', { config: { policy: ['site'] } }, preview);
+    app.post('/cms-media/:token', { config: { policy: ['site'] } }, upload); // upload file / create empty dir
+
+    app.get('/cms-media-metadata/:token', { config: { policy: ['site'] } }, metadata);
+    app.put('/cms-media/:token', { config: { policy: ['site'] } }, edit);
+    app.delete('/cms-media/:token', { config: { policy: ['site'] } }, del);
+}

package/server/routes/root.mjs

@@ -0,0 +1,15 @@
+'use strict'
+
+const schema = {
+  querystring: {
+    name: { type: 'string', pattern: "^(\\d+)$" },
+    token: { type: 'string', pattern: "^(\\d+)$" },
+  },
+}
+
+export default async function (fastify, opts) {
+  fastify.get('/test', async function (request, reply) {
+    return { root: true }
+  });
+
+}

package/server/templates/cls/cms.category_type.json

@@ -0,0 +1,10 @@
+[
+    {
+      "id": "1",
+      "text": "Important"
+    },
+    {
+      "id": "2",
+      "text": "Common"
+    }
+  ]

package/server/templates/cls/cms.content_review_status.json

@@ -0,0 +1,10 @@
+[
+    {
+      "id": "1",
+      "text": "Pending"
+    },
+    {
+      "id": "2",
+      "text": "Approved"
+    }
+  ]

package/server/templates/cls/cms.content_status.json

@@ -0,0 +1,10 @@
+[
+    {
+      "id": "1",
+      "text": "Draft"
+    },
+    {
+      "id": "2",
+      "text": "Publish"
+    }
+  ]

package/server/templates/cls/cms.content_type.json

@@ -0,0 +1,10 @@
+[
+    {
+      "id": "1",
+      "text": "Single"
+    },
+    {
+      "id": "2",
+      "text": "Collection"
+    }
+  ]

package/server/templates/cls/cms.lang.json

@@ -0,0 +1,10 @@
+[
+    {
+      "id": "uk",
+      "text": "Українська"
+    },
+    {
+      "id": "en",
+      "text": "English"
+    }
+  ]

package/server/templates/page/login.html

@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html lang="en" dir="">
+
+<head>
+    <!-- scripts -->
+    <script src="https://cdn.tailwindcss.com"></script>
+</head>
+
+<body  class="bg-[#f3f4f6] flex items-center flex-1 w-full h-[100vh] overflow-x-hidden min-h-full ">
+    <main class="w-full">
+    <div class="flex w-full max-w-sm mx-auto overflow-hidden bg-white rounded-lg shadow-lg dark:bg-gray-800 lg:max-w-4xl">
+<div class="hidden bg-cover lg:block lg:w-1/2 bg-center" style="background-image: url('https://nipo.gov.ua/wp-content/uploads/2023/02/Pro_nas_2301-768x512.jpg');"></div>
+
+<div class="w-full px-6 py-8 md:px-8 lg:w-1/2">
+<div class="flex justify-center mx-auto">
+    <img class="w-auto h-7 sm:h-16" src="https://nipo.gov.ua/wp-content/uploads/2023/01/IP_office_logo_UA-1-1.png" alt="logo">
+</div>
+
+<p class="mt-3 mb-[32px] text-xl text-center text-gray-600 dark:text-gray-200">
+    Український національний офіс інтелектуальної власності та інновацій
+</p>
+
+<form action="/api/login" method="get" >
+<div class="mt-4">
+    <label class="block mb-2 text-sm font-medium text-gray-600 dark:text-gray-200" for="LoggingEmailAddress">Електронна пошта / Логін</label>
+    <input name="username" id="LoggingEmailAddress" class="block w-full px-4 py-2 text-gray-700 bg-white border rounded-lg dark:bg-gray-800 dark:text-gray-300 dark:border-gray-600 focus:border-blue-400 focus:ring-opacity-40 dark:focus:border-blue-300 focus:outline-none focus:ring focus:ring-blue-300" type="text">
+</div>
+
+<div class="mt-4">
+    <div class="flex justify-between">
+        <label class="block mb-2 text-sm font-medium text-gray-600 dark:text-gray-200" for="loggingPassword">Пароль</label>
+        <!-- <a class="text-xs text-gray-500 dark:text-gray-300 hover:underline">Forget Password?</a> -->
+    </div>
+
+    <input id="loggingPassword" name="password"   class="block w-full px-4 py-2 text-gray-700 bg-white border rounded-lg dark:bg-gray-800 dark:text-gray-300 dark:border-gray-600 focus:border-blue-400 focus:ring-opacity-40 dark:focus:border-blue-300 focus:outline-none focus:ring focus:ring-blue-300" type="password">
+</div>
+
+<div class="mt-6">
+    <button type="submit"   class="w-full px-6 py-3 text-sm font-medium tracking-wide text-white capitalize transition-colors duration-300 transform bg-gray-800 rounded-lg hover:bg-gray-700 focus:outline-none focus:ring focus:ring-gray-300 focus:ring-opacity-50">
+         Увійти
+    </button>
+</div>
+
+</form>
+</div>
+</div>
+    </main>
+
+</body>
+
+
+<script>
+    const error = location.search.includes('wrong_pass')
+    if (error) {
+        document.getElementById('login_error').innerHTML = 'Не вірний користувач або пароль';
+    }
+</script>
+
+</html>

package/server/templates/select/cms.category_id.sql

@@ -0,0 +1 @@
+select category_id, title from site.categories

package/server/templates/select/cms.type_id.sql

@@ -0,0 +1 @@
+select content_type_id, name from site.content_types

package/test/config.js

@@ -0,0 +1,17 @@
+import config from '../server/config.js';
+
+Object.assign(config, {
+  pg: config.pg || {
+    host: '192.168.3.160',
+    port: 5439,
+    database: 'ip_ukraine',
+    user: 'postgres',
+    password: 'postgres',
+  },
+  redis: config.redis || {
+    host: '192.168.3.160',
+    port: 6379,
+    family: 4,
+  },
+});
+export default config;

package/test/files/eye.svg

@@ -0,0 +1,4 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M1.3335 8C1.3335 8 3.3335 3.33333 8.00016 3.33333C12.6668 3.33333 14.6668 8 14.6668 8C14.6668 8 12.6668 12.6667 8.00016 12.6667C3.3335 12.6667 1.3335 8 1.3335 8Z" stroke="#6B7280" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M8 10C9.10457 10 10 9.10457 10 8C10 6.89543 9.10457 6 8 6C6.89543 6 6 6.89543 6 8C6 9.10457 6.89543 10 8 10Z" stroke="#6B7280" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/test/helper.js

@@ -0,0 +1,30 @@
+// This file contains code that we reuse
+// between our tests.
+import Fastify from 'fastify';
+
+import { redisClients, pgClients } from '@opengis/fastify-table/utils.js';
+
+import appService from '../server/app.js';
+
+// automatically build and tear down our instance
+async function build(t) {
+  // you can set all the options supported by the fastify CLI command
+  // const argv = [AppPath]
+  process.env.NODE_ENV = 'production';
+  const app = Fastify({ logger: false });
+  app.register(appService);
+  // close the app after we are done
+  t.after(() => {
+    Object.keys(pgClients).forEach((key) => {
+      pgClients[key].end();
+    });
+    Object.keys(redisClients || {}).forEach((key) => {
+      redisClients[key].quit();
+    });
+    app.close();
+  });
+
+  return app;
+}
+
+export default build;

package/test/routes/builder.test.js

@@ -0,0 +1,99 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+
+import { config, pgClients } from '@opengis/fastify-table/utils.js';
+import build from '../helper.js';
+
+test('cms builder api', async (t) => {
+  const app = await build(t);
+
+  const pg = pgClients.client;
+
+  const prefix = config.prefix || '/api';
+
+  const testContentTypeId = 'testContentType';
+
+  app.addHook('onRequest', async (req) => {
+    req.session = { passport: { user: { user_type: 'admin', uid: '1' } } };
+    req.user = req.session.passport.user;
+    req.uid = req.user.uid;
+    req.unittest = 1;
+  });
+
+  await t.test('POST /cms-builder', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: `${prefix}/cms-builder`,
+      body: {
+            content_type_id: testContentTypeId,
+            name: 'Created value',
+            template: 'news'
+      },
+    });
+    assert.equal(res.statusCode, 200);
+    const rep = res.json();
+    // console.log(rep);
+  });
+
+  await t.test('PUT /cms-builder', async () => {
+    // await pg.query('insert into site.content_types (content_type_id, uid) values ($1, $2)', [testContentTypeId, testUid]);
+    const res = await app.inject({
+      method: 'PUT',
+      url: `${prefix}/cms-builder/${testContentTypeId}`,
+      body: {
+            name: 'Edited value'
+      },
+    });
+    assert.equal(res.statusCode, 200);
+    const rep = res.json();
+    // console.log(rep);
+  });
+
+  await t.test('GET /cms-builder/:id', async () => {
+    // await pg.query('insert into site.contents (content_id, uid) values ($1, $2)', [testContentId, testUid]);
+    const res = await app.inject({
+      method: 'GET',
+      url: `${prefix}/cms-builder/${testContentTypeId}`,
+    });
+    assert.equal(res.statusCode, 200);
+    const rep = res.json();
+    // console.log(rep);
+  });
+
+  await t.test('GET /cms-builder', async () => {
+    // await pg.query('insert into site.contents (content_id, uid) values ($1, $2)', [testContentId, testUid]);
+    const res = await app.inject({
+      method: 'GET',
+      url: `${prefix}/cms-builder`,
+    });
+    assert.equal(res.statusCode, 200);
+    const rep = res.json();
+    // console.log(rep);
+  });
+
+  await t.test('GET /cms-builder?id', async () => {
+    // await pg.query('insert into site.contents (content_id, uid) values ($1, $2)', [testContentId, testUid]);
+    const res = await app.inject({
+      method: 'GET',
+      url: `${prefix}/cms-builder?content_type_id=${testContentTypeId}`,
+    });
+    assert.equal(res.statusCode, 200);
+    const rep = res.json();
+    // console.log(rep);
+  });
+
+  await t.test('DELETE /cms-builder/:id', async () => {
+    const res = await app.inject({
+      method: 'DELETE',
+      url: `${prefix}/cms-builder/${testContentTypeId}`,
+    });
+    assert.equal(res.statusCode, 200);
+    const rep = res.json();
+    // console.log(rep);
+  });
+
+  await t.test('clean up', async () => {
+    const { rowCount: contentTypesCount } = await pg.query('delete from site.content_types where content_type_id=$1', [testContentTypeId]);
+    console.log('clean up', contentTypesCount);
+  });
+});