cyberia 3.1.3 → 3.2.5

package/src/client/services/cyberia-instance-conf/cyberia-instance-conf.service.js

@@ -0,0 +1,105 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory, buildQueryUrl } from '../core/core.service.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('Load service');
+
+const endpoint = 'cyberia-instance-conf';
+
+const CyberiaInstanceConfService = {
+  post: (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'POST',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    ),
+  put: (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'PUT',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    ),
+  get: (options = {}) => {
+    const { id, page, limit, filterModel, sortModel, sort, asc, order } = options;
+    const url = buildQueryUrl(getApiBaseUrl({ id, endpoint }), {
+      page,
+      limit,
+      filterModel,
+      sortModel,
+      sort,
+      asc,
+      order,
+    });
+
+    return new Promise((resolve, reject) =>
+      fetch(url.toString(), {
+        method: 'GET',
+        headers: headersFactory(),
+        credentials: 'include',
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  },
+  delete: (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'DELETE',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    ),
+};
+
+export { CyberiaInstanceConfService };

package/src/client/services/cyberia-map/cyberia-map.management.js

@@ -0,0 +1,193 @@
+import { BtnIcon } from '../../components/core/BtnIcon.js';
+import { getId, commonUserGuard, commonAdminGuard } from '../../components/core/CommonJs.js';
+import { EventsUI } from '../../components/core/EventsUI.js';
+import { NotificationManager } from '../../components/core/NotificationManager.js';
+import { s } from '../../components/core/VanillaJs.js';
+import { DefaultManagement } from '../default/default.management.js';
+import { CyberiaMapService } from './cyberia-map.service.js';
+import { getApiBaseUrl } from '../core/core.service.js';
+
+const CyberiaMapManagement = {
+  RenderTable: async (options = {}) => {
+    const { idModal: rawIdModal, customEvent, readyRowDataEvent, loadMapCallback, appStore } = options;
+    const idModal = rawIdModal || 'modal-cyberia-map-management';
+    const role = appStore?.Data?.user?.main?.model?.user?.role || 'guest';
+
+    class LoadMapActionGridRenderer {
+      eGui;
+      tokens;
+
+      async init(params) {
+        this.eGui = document.createElement('div');
+        this.tokens = {};
+
+        const cellRenderId = getId(this.tokens, 'load-map-');
+        this.tokens[cellRenderId] = {};
+
+        this.eGui.innerHTML = html`${await BtnIcon.Render({
+          label: html`<div class="abs center">
+            <i class="fa-solid fa-upload"></i>
+          </div>`,
+          class: `in fll section-mp management-table-btn-mini management-table-btn-load-map-${idModal}-${cellRenderId} ${
+            !params.data._id ? 'hide' : ''
+          }`,
+        })}`;
+
+        setTimeout(() => {
+          EventsUI.onClick(
+            `.management-table-btn-load-map-${idModal}-${cellRenderId}`,
+            async () => {
+              if (!params.data._id) return;
+              const result = await CyberiaMapService.get({ id: params.data._id });
+              if (result.status === 'success' && result.data) {
+                if (loadMapCallback) await loadMapCallback(result.data);
+                NotificationManager.Push({
+                  html: `Map "${result.data.name || result.data.code || params.data._id}" loaded`,
+                  status: 'success',
+                });
+              } else {
+                NotificationManager.Push({
+                  html: result.message || 'Failed to load map',
+                  status: 'error',
+                });
+              }
+            },
+            { context: 'modal' },
+          );
+        });
+      }
+
+      getGui() {
+        return this.eGui;
+      }
+
+      refresh(params) {
+        return true;
+      }
+    }
+
+    class ThumbnailPreviewGridRenderer {
+      eGui;
+
+      async init(params) {
+        this.eGui = document.createElement('div');
+        const { data } = params;
+
+        if (!data || !data.thumbnail) {
+          this.eGui.innerHTML = html`<span style="color: #666; font-style: italic;">—</span>`;
+          return;
+        }
+
+        const thumbnailId = typeof data.thumbnail === 'object' ? data.thumbnail._id : data.thumbnail;
+        if (!thumbnailId) {
+          this.eGui.innerHTML = html`<span style="color: #666; font-style: italic;">—</span>`;
+          return;
+        }
+
+        const imageSrc = getApiBaseUrl({ id: thumbnailId, endpoint: 'file/blob' });
+
+        this.eGui.innerHTML = html`
+          <div style="position: relative; width: 60px; height: 60px;">
+            <img
+              src="${imageSrc}"
+              style="width: 60px; height: 60px; object-fit: cover; display: block; border: 1px solid #555;"
+              onload="this.style.display='block'; this.nextElementSibling.style.display='none';"
+              onerror="this.style.display='none'; this.nextElementSibling.style.display='flex';"
+            />
+            <div
+              style="position: absolute; top: 0; left: 0; width: 60px; height: 60px; display: none; align-items: center; justify-content: center;"
+            >
+              <i class="fas fa-image" style="font-size: 24px; color: #999;"></i>
+            </div>
+          </div>
+        `;
+      }
+
+      getGui() {
+        return this.eGui;
+      }
+
+      refresh(params) {
+        return true;
+      }
+    }
+
+    const renderResult = await DefaultManagement.RenderTable({
+      idModal,
+      serviceId: 'cyberia-map-management',
+      entity: 'cyberia-map',
+      permissions: {
+        add: false,
+        remove: commonUserGuard(role),
+        reload: true,
+      },
+      usePagination: true,
+      columnDefs: [
+        { field: 'code', headerName: 'Code' },
+        { field: 'name', headerName: 'Name' },
+        { field: 'description', headerName: 'Description' },
+        { field: 'tags', headerName: 'Tags' },
+        { field: 'status', headerName: 'Status' },
+        {
+          field: 'creator',
+          headerName: 'Creator',
+          valueGetter: (params) => {
+            if (!params.data || !params.data.creator) return '—';
+            return typeof params.data.creator === 'object' ? params.data.creator.username || '—' : params.data.creator;
+          },
+          editable: false,
+        },
+        {
+          field: 'thumbnail',
+          headerName: 'Thumbnail',
+          width: 80,
+          cellRenderer: ThumbnailPreviewGridRenderer,
+          editable: false,
+          sortable: false,
+          filter: false,
+        },
+        {
+          field: 'createdAt',
+          headerName: 'createdAt',
+          cellDataType: 'date',
+          editable: false,
+        },
+        {
+          field: 'updatedAt',
+          headerName: 'updatedAt',
+          cellDataType: 'date',
+          editable: false,
+        },
+        {
+          field: 'load-action',
+          headerName: '',
+          width: 100,
+          cellRenderer: LoadMapActionGridRenderer,
+          editable: false,
+        },
+      ],
+      defaultColKeyFocus: 'code',
+      ServiceProvider: CyberiaMapService,
+      customEvent,
+    });
+
+    // Clear all button: admin only
+    if (!commonAdminGuard(role)) {
+      const cleanBtn = s(`.management-table-btn-clean-${idModal}`);
+      if (cleanBtn) cleanBtn.classList.add('hide');
+    }
+
+    if (readyRowDataEvent) {
+      if (!DefaultManagement.Tokens[idModal].readyRowDataEvent)
+        DefaultManagement.Tokens[idModal].readyRowDataEvent = {};
+
+      for (const key of Object.keys(readyRowDataEvent)) {
+        DefaultManagement.Tokens[idModal].readyRowDataEvent[key] = readyRowDataEvent[key];
+      }
+    }
+
+    return renderResult;
+  },
+};
+
+export { CyberiaMapManagement };

package/src/client/services/cyberia-map/cyberia-map.service.js

@@ -0,0 +1,126 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory, buildQueryUrl } from '../core/core.service.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('Load service');
+
+const endpoint = 'cyberia-map';
+
+const CyberiaMapService = {
+  post: (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'POST',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    ),
+  put: (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'PUT',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    ),
+  get: (options = {}) => {
+    const { id, page, limit, filterModel, sortModel, sort, asc, order } = options;
+    const url = buildQueryUrl(getApiBaseUrl({ id, endpoint }), {
+      page,
+      limit,
+      filterModel,
+      sortModel,
+      sort,
+      asc,
+      order,
+    });
+
+    return new Promise((resolve, reject) =>
+      fetch(url.toString(), {
+        method: 'GET',
+        headers: headersFactory(),
+        credentials: 'include',
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  },
+  delete: (options = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'DELETE',
+        headers: headersFactory(),
+        credentials: 'include',
+        body: payloadFactory(options.body),
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          logger.info(res);
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    ),
+  searchCodes: (options = { q: '' }) => {
+    const url = new URL(getApiBaseUrl({ id: 'search-codes', endpoint }));
+    if (options.q) url.searchParams.set('q', options.q);
+    return new Promise((resolve, reject) =>
+      fetch(url.toString(), {
+        method: 'GET',
+        headers: headersFactory(),
+        credentials: 'include',
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  },
+};
+
+export { CyberiaMapService };

package/src/client/services/instance/instance.management.js

@@ -3,8 +3,8 @@ import { UserService } from '../user/user.service.js';
 import { InstanceService } from './instance.service.js';
 
 const InstanceManagement = {
-  RenderTable: async ({ Elements }) => {
-    const user = Elements.Data.user.main.model.user;
+  RenderTable: async ({ appStore }) => {
+    const user = appStore.Data.user.main.model.user;
     const { role } = user;
     let columnDefs = [
       { field: 'deployId', headerName: 'deployId', editable: role === 'admin' },

package/src/client/services/ipfs/ipfs.service.js

@@ -100,30 +100,10 @@ const IpfsService = {
           return reject(error);
         }),
     ),
-  pin: (options = { body: {} }) =>
+  verify: () =>
     new Promise((resolve, reject) =>
-      fetch(`${getApiBaseUrl({ endpoint })}/pin`, {
-        method: 'POST',
-        headers: headersFactory(),
-        credentials: 'include',
-        body: payloadFactory(options.body),
-      })
-        .then(async (res) => {
-          return await res.json();
-        })
-        .then((res) => {
-          logger.info(res);
-          return resolve(res);
-        })
-        .catch((error) => {
-          logger.error(error);
-          return reject(error);
-        }),
-    ),
-  unpin: (options = { cid: '' }) =>
-    new Promise((resolve, reject) =>
-      fetch(`${getApiBaseUrl({ endpoint })}/pin/${options.cid}`, {
-        method: 'DELETE',
+      fetch(`${getApiBaseUrl({ endpoint })}/verify`, {
+        method: 'GET',
         headers: headersFactory(),
         credentials: 'include',
       })

package/src/client/services/object-layer/object-layer.management.js

@@ -11,11 +11,11 @@ import { NotificationManager } from '../../components/core/NotificationManager.j
 import { AgGrid } from '../../components/core/AgGrid.js';
 
 const ObjectLayerManagement = {
-  RenderTable: async ({ Elements, idModal: rawIdModal }) => {
+  RenderTable: async ({ appStore, idModal: rawIdModal }) => {
     const idModal = rawIdModal || 'modal-object-layer-engine-management';
     const serviceId = 'object-layer-engine-management';
     const gridId = `${serviceId}-grid-${idModal}`;
-    const user = Elements.Data.user.main.model.user;
+    const user = appStore.Data.user.main.model.user;
     const { role } = user;
 
     // Custom renderer for view button
@@ -48,7 +48,7 @@ const ObjectLayerManagement = {
                 // Then add query param without replacing history
                 setQueryParams({ id: data._id }, { replace: true });
                 if (s(`.modal-object-layer-engine-viewer`)) {
-                  await ObjectLayerEngineViewer.Reload({ Elements, force: true });
+                  await ObjectLayerEngineViewer.Reload({ appStore, force: true });
                 }
                 s(`.main-btn-object-layer-engine-viewer`).click();
               });

package/src/client/services/object-layer/object-layer.service.js

@@ -188,6 +188,27 @@ const ObjectLayerService = {
         }),
     );
   },
+  searchItemIds: (options = { q: '' }) => {
+    const url = new URL(getApiBaseUrl({ id: `search-item-ids`, endpoint }));
+    if (options.q) url.searchParams.set('q', options.q);
+    return new Promise((resolve, reject) =>
+      fetch(url.toString(), {
+        method: 'GET',
+        headers: headersFactory(),
+        credentials: 'include',
+      })
+        .then(async (res) => {
+          return await res.json();
+        })
+        .then((res) => {
+          return resolve(res);
+        })
+        .catch((error) => {
+          logger.error(error);
+          return reject(error);
+        }),
+    );
+  },
 };
 
 export { ObjectLayerService };

package/src/client/services/user/user.management.js

@@ -2,8 +2,8 @@ import { DefaultManagement } from '../default/default.management.js';
 import { UserService } from './user.service.js';
 
 const UserManagement = {
-  RenderTable: async ({ Elements }) => {
-    const user = Elements.Data.user.main.model.user;
+  RenderTable: async ({ appStore }) => {
+    const user = appStore.Data.user.main.model.user;
     const { role } = user;
     return await DefaultManagement.RenderTable({
       idModal: 'modal-user-management',

package/src/client/ssr/pages/CyberiaServerMetrics.js

@@ -93,7 +93,7 @@ const createEntityCard = (entityType) => {
 
 const fetchMetrics = async () => {
   try {
-    const response = await fetch('http://localhost:8080/api/v1/metrics');
+    const response = await fetch('/api/v1/metrics');
     if (!response.ok) throw new Error('Failed to fetch metrics');
     return await response.json();
   } catch (error) {