@underpostnet/cyberia 3.2.80

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

@@ -0,0 +1,193 @@
+import { BtnIcon } from '../../components/core/BtnIcon.js';
+import { getId, commonModeratorGuard, 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';
+
+class CyberiaMapManagement {
+  static instance = 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.instance({
+          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.instance({
+      idModal,
+      serviceId: 'cyberia-map-management',
+      entity: 'cyberia-map',
+      permissions: {
+        add: false,
+        remove: commonModeratorGuard(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,120 @@
+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';
+class CyberiaMapService {
+  static 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);
+        }),
+    );
+  static 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);
+        }),
+    );
+  static 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);
+        }),
+    );
+  };
+  static 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);
+        }),
+    );
+  static 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/cyberia-quest/cyberia-quest.service.js

@@ -0,0 +1,99 @@
+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-quest';
+class CyberiaQuestService {
+  static 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);
+        }),
+    );
+  static 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);
+        }),
+    );
+  static 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);
+        }),
+    );
+  };
+  static 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 { CyberiaQuestService };

package/src/client/services/cyberia-quest-progress/cyberia-quest-progress.service.js

@@ -0,0 +1,99 @@
+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-quest-progress';
+class CyberiaQuestProgressService {
+  static 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);
+        }),
+    );
+  static 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);
+        }),
+    );
+  static 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);
+        }),
+    );
+  };
+  static 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 { CyberiaQuestProgressService };

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

@@ -0,0 +1,99 @@
+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-saga';
+class CyberiaSagaService {
+  static 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);
+        }),
+    );
+  static 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);
+        }),
+    );
+  static 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);
+        }),
+    );
+  };
+  static 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 { CyberiaSagaService };