cyberia 3.1.3 → 3.2.5

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

@@ -17,6 +17,19 @@ const endpoint = 'core';
 
 // https://developer.mozilla.org/en-US/docs/Web/API/AbortController
 
+/**
+ * Returns the normalized proxy path from renderPayload (always trailing `/`).
+ * Falls back to `null` when no apiBaseProxyPath is set.
+ * @memberof CoreServiceClient
+ * @return {string|null}
+ */
+const getApiBaseProxyPath = () =>
+  window.renderPayload?.apiBaseProxyPath
+    ? window.renderPayload.apiBaseProxyPath === '/'
+      ? window.renderPayload.apiBaseProxyPath
+      : `${window.renderPayload.apiBaseProxyPath}/`
+    : null;
+
 /**
  * Gets the base host for API requests.
  * Uses the apiBaseHost from renderPayload if available, otherwise falls back to location.host.
@@ -35,13 +48,7 @@ const getBaseHost = () => (window.renderPayload?.apiBaseHost ? window.renderPayl
  */
 const getApiBasePath = (options) =>
   `${
-    options?.proxyPath
-      ? `/${options.proxyPath}/`
-      : window.renderPayload?.apiBaseProxyPath
-        ? window.renderPayload.apiBaseProxyPath == '/'
-          ? window.renderPayload.apiBaseProxyPath
-          : `${window.renderPayload.apiBaseProxyPath}/`
-        : getProxyPath()
+    options?.proxyPath ? `/${options.proxyPath}/` : getApiBaseProxyPath() || getProxyPath()
   }${window.renderPayload?.apiBasePath ? window.renderPayload.apiBasePath : 'api'}/`;
 
 /**
@@ -65,7 +72,11 @@ const getApiBaseUrl = (options = { id: '', endpoint: '', proxyPath: '' }) =>
  * @memberof CoreServiceClient
  * @return {string} The WebSocket base path.
  */
-const getWsBasePath = () => (getProxyPath() !== '/' ? `${getProxyPath()}socket.io/` : '/socket.io/');
+const getWsBasePath = () => {
+  const proxyPath = getApiBaseProxyPath();
+  if (proxyPath) return proxyPath !== '/' ? `${proxyPath}socket.io/` : '/socket.io/';
+  return getProxyPath() !== '/' ? `${getProxyPath()}socket.io/` : '/socket.io/';
+};
 
 /**
  * Constructs the full WebSocket base URL for connections.
@@ -321,6 +332,7 @@ export {
   payloadFactory,
   buildQueryUrl,
   getBaseHost,
+  getApiBaseProxyPath,
   getApiBasePath,
   getApiBaseUrl,
   getWsBasePath,

package/src/client/services/cyberia-dialogue/cyberia-dialogue.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-dialogue';
+
+const CyberiaDialogueService = {
+  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 { CyberiaDialogueService };

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

@@ -0,0 +1,57 @@
+import { DefaultManagement } from '../default/default.management.js';
+import { CyberiaEntityService } from './cyberia-entity.service.js';
+
+const CyberiaEntityManagement = {
+  RenderTable: async (options = {}) => {
+    const { idModal: rawIdModal, customEvent, readyRowDataEvent } = options;
+    const idModal = rawIdModal || 'modal-cyberia-entity-management';
+
+    const renderResult = await DefaultManagement.RenderTable({
+      idModal,
+      serviceId: 'cyberia-entity-management',
+      entity: 'cyberia-entity',
+      permissions: {
+        add: false,
+        remove: true,
+        reload: true,
+      },
+      usePagination: true,
+      columnDefs: [
+        { field: 'entityType', headerName: 'Entity Type' },
+        { field: 'initCellX', headerName: 'initCellX' },
+        { field: 'initCellY', headerName: 'initCellY' },
+        { field: 'dimX', headerName: 'dimX' },
+        { field: 'dimY', headerName: 'dimY' },
+        { field: 'color', headerName: 'Color' },
+        {
+          field: 'createdAt',
+          headerName: 'createdAt',
+          cellDataType: 'date',
+          editable: false,
+        },
+        {
+          field: 'updatedAt',
+          headerName: 'updatedAt',
+          cellDataType: 'date',
+          editable: false,
+        },
+      ],
+      defaultColKeyFocus: 'entityType',
+      ServiceProvider: CyberiaEntityService,
+      customEvent,
+    });
+
+    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 { CyberiaEntityManagement };

package/src/client/services/cyberia-entity/cyberia-entity.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-entity';
+
+const CyberiaEntityService = {
+  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 { CyberiaEntityService };

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

@@ -0,0 +1,194 @@
+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 { CyberiaInstanceService } from './cyberia-instance.service.js';
+import { getApiBaseUrl } from '../core/core.service.js';
+
+const CyberiaInstanceManagement = {
+  RenderTable: async (options = {}) => {
+    const { idModal: rawIdModal, customEvent, readyRowDataEvent, loadInstanceCallback, appStore } = options;
+    const idModal = rawIdModal || 'modal-cyberia-instance-management';
+    const role = appStore?.Data?.user?.main?.model?.user?.role || 'guest';
+
+    class LoadInstanceActionGridRenderer {
+      eGui;
+      tokens;
+
+      async init(params) {
+        this.eGui = document.createElement('div');
+        this.tokens = {};
+
+        const cellRenderId = getId(this.tokens, 'load-instance-');
+        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-instance-${idModal}-${cellRenderId} ${
+            !params.data._id ? 'hide' : ''
+          }`,
+        })}`;
+
+        setTimeout(() => {
+          EventsUI.onClick(
+            `.management-table-btn-load-instance-${idModal}-${cellRenderId}`,
+            async () => {
+              if (!params.data._id) return;
+              const result = await CyberiaInstanceService.get({ id: params.data._id });
+              if (result.status === 'success' && result.data) {
+                if (loadInstanceCallback) await loadInstanceCallback(result.data);
+                NotificationManager.Push({
+                  html: `Instance "${result.data.name || result.data.code || params.data._id}" loaded`,
+                  status: 'success',
+                });
+              } else {
+                NotificationManager.Push({
+                  html: result.message || 'Failed to load instance',
+                  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-instance-management',
+      entity: 'cyberia-instance',
+      permissions: {
+        add: false,
+        remove: commonUserGuard(role),
+        reload: true,
+      },
+      usePagination: true,
+      columnDefs: [
+        { field: 'code', headerName: 'Code' },
+        { field: 'name', headerName: 'Name' },
+        { field: 'description', headerName: 'Description' },
+        { field: 'cyberiaMapCodes', headerName: 'Map Codes' },
+        { 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: LoadInstanceActionGridRenderer,
+          editable: false,
+        },
+      ],
+      defaultColKeyFocus: 'code',
+      ServiceProvider: CyberiaInstanceService,
+      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 { CyberiaInstanceManagement };

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

@@ -0,0 +1,122 @@
+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';
+
+const CyberiaInstanceService = {
+  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);
+        }),
+    );
+  },
+  portalConnect: (options = { id: '' }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: `${options.id}/portal-connect`, endpoint }), {
+        method: 'GET',
+        headers: headersFactory(),
+        credentials: 'include',
+      })
+        .then(async (res) => 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 { CyberiaInstanceService };