cyberia 2.8.885

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

@@ -0,0 +1,72 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory } from '../core/core.service.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('Load service');
+
+const endpoint = 'file';
+
+const FileService = {
+  post: (options = { id: '', body: {}, headerId: 'file' }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'POST',
+        headers: headersFactory('file'),
+        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 = { id: '' }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        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 { FileService };

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

@@ -0,0 +1,78 @@
+import { DefaultManagement } from '../default/default.management.js';
+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;
+    const { role } = user;
+    let columnDefs = [
+      { field: 'deployId', headerName: 'deployId', editable: role === 'admin' },
+      { field: 'port', headerName: 'port', editable: role === 'admin' },
+      { field: 'host', headerName: 'host', editable: role === 'admin' },
+      { field: 'path', headerName: 'path', editable: role === 'admin' },
+      { field: 'runtime', headerName: 'runtime', editable: role === 'admin' },
+      { field: 'client', headerName: 'client', editable: role === 'admin' },
+      { field: 'apis', headerName: 'apis', editable: role === 'admin' },
+      { field: 'createdAt', headerName: 'createdAt', cellDataType: 'date', editable: false },
+      { field: 'updatedAt', headerName: 'updatedAt', cellDataType: 'date', editable: false },
+    ];
+    switch (role) {
+      case 'admin':
+        {
+          columnDefs = columnDefs.concat([
+            {
+              field: 'userId',
+              headerName: 'User',
+              children: [
+                {
+                  headerName: 'id',
+                  field: 'userId',
+                  editable: false,
+                },
+                {
+                  headerName: 'Email',
+                  field: 'userEmail',
+                  editable: role === 'admin',
+                },
+              ],
+            },
+          ]);
+        }
+        break;
+
+      default:
+        break;
+    }
+    return await DefaultManagement.RenderTable({
+      idModal: 'modal-instance-management',
+      serviceId: 'instance-management',
+      entity: 'instance',
+      permissions: {
+        add: role === 'admin',
+        remove: role === 'admin',
+      },
+      columnDefs,
+      customFormat: (obj) => {
+        return {
+          ...obj,
+          userId: obj.userId?._id ? obj.userId._id : undefined,
+          userEmail: obj.userId?.email ? obj.userId.email : undefined,
+        };
+      },
+      onRowValueChanged: async (...args) => {
+        const [event] = args;
+        const { data } = await UserService.get({ id: `email/${event.data.userEmail}` });
+        if (data) {
+          event.data.userId = data._id;
+          return { status: 'success', data: event.data };
+        }
+        return { status: 'error', message: 'user email not found' };
+      },
+      defaultColKeyFocus: 'host',
+      ServiceProvider: InstanceService,
+    });
+  },
+};
+
+export { InstanceManagement };

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

@@ -0,0 +1,97 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory } from '../core/core.service.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('Load service');
+
+const endpoint = 'instance';
+
+const InstanceService = {
+  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 = { id: '', body: {}, page: 1, limit: 10 }) => {
+    const url = new URL(getApiBaseUrl({ id: options.id, endpoint }));
+    if (options.page) url.searchParams.set('page', options.page);
+    if (options.limit) url.searchParams.set('limit', options.limit);
+    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 { InstanceService };

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

@@ -0,0 +1,73 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory } from '../core/core.service.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('Load service');
+
+const endpoint = 'ipfs';
+
+const IPFSService = {
+  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);
+        }),
+    ),
+  get: (options = { id: '' }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        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 { IPFSService };

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

@@ -0,0 +1,93 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory } from '../core/core.service.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('Load service');
+
+const endpoint = 'object-layer';
+
+const ObjectLayerService = {
+  post: (options = { id: '', body: {}, headerId: undefined }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'POST',
+        headers: headersFactory(options.headerId),
+        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 = { id: '', body: {} }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        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 { ObjectLayerService };

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

@@ -0,0 +1,73 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory } from '../core/core.service.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('Load service');
+
+const endpoint = 'test';
+
+const TestService = {
+  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);
+        }),
+    ),
+  get: (options = { id: '' }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        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 { TestService };

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

@@ -0,0 +1,56 @@
+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;
+    const { role } = user;
+    return await DefaultManagement.RenderTable({
+      idModal: 'modal-user-management',
+      serviceId: 'user-management',
+      entity: 'user',
+      permissions: {
+        add: role === 'admin',
+        remove: role === 'admin',
+      },
+      usePagination: true,
+      columnDefs: [
+        { field: 'username', headerName: 'username', editable: role === 'admin' },
+        { field: 'email', headerName: 'email', editable: role === 'admin' },
+        { field: 'password', headerName: 'password', editable: role === 'admin' },
+        {
+          field: 'role',
+          headerName: 'role',
+          editable: role === 'admin',
+        },
+        {
+          field: 'emailConfirmed',
+          headerName: 'emailConfirmed',
+          cellDataType: 'boolean',
+          cellRendererParams: { disabled: true },
+          editable: role === 'admin',
+        },
+        {
+          field: 'createdAt',
+          headerName: 'createdAt',
+          cellDataType: 'date',
+          editable: false,
+        },
+        {
+          field: 'updatedAt',
+          headerName: 'updatedAt',
+          cellDataType: 'date',
+          editable: false,
+        },
+      ],
+      defaultColKeyFocus: 'username',
+      ServiceProvider: UserService,
+      serviceOptions: {
+        get: {
+          id: 'all',
+        },
+      },
+    });
+  },
+};
+export { UserManagement };

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

@@ -0,0 +1,108 @@
+import { Auth } from '../../components/core/Auth.js';
+import { loggerFactory } from '../../components/core/Logger.js';
+import { getApiBaseUrl, headersFactory, payloadFactory } from '../core/core.service.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('Load service');
+
+const endpoint = 'user';
+
+const UserMock = {
+  default: {
+    username: 'guest',
+    email: `guest@${location.hostname}`,
+    role: 'guest',
+  },
+};
+
+const UserService = {
+  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);
+        }),
+    ),
+  get: (options = { id: '', page: 1, limit: 10 }) => {
+    const { id = '', page, limit } = options;
+    const query = new URLSearchParams();
+    if (page) query.set('page', page);
+    if (limit) query.set('limit', limit);
+    const queryString = query.toString();
+    const url = `${getApiBaseUrl({ id, endpoint })}${queryString ? (id.includes('?') ? '&' : '?') + queryString : ''}`;
+    return new Promise((resolve, reject) =>
+      fetch(url, {
+        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);
+        }),
+    ),
+  put: (options = { id: '', body: {}, headerId: '' }) =>
+    new Promise((resolve, reject) =>
+      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+        method: 'PUT',
+        headers: headersFactory(options.headerId),
+        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 { UserService, UserMock };