cyberia 2.8.885

package/src/api/object-layer/object-layer.router.js

@@ -0,0 +1,29 @@
+import { loggerFactory } from '../../server/logger.js';
+import { ObjectLayerController } from './object-layer.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const ObjectLayerRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(
+    `/frame-image/:itemType/:itemId/:directionCode`,
+    async (req, res) => await ObjectLayerController.post(req, res, options),
+  );
+  router.post(`/metadata/:itemType/:itemId`, async (req, res) => await ObjectLayerController.post(req, res, options));
+
+  router.post(`/:id`, async (req, res) => await ObjectLayerController.post(req, res, options));
+  router.post(`/`, async (req, res) => await ObjectLayerController.post(req, res, options));
+  router.get(`/:id`, async (req, res) => await ObjectLayerController.get(req, res, options));
+  router.get(`/`, async (req, res) => await ObjectLayerController.get(req, res, options));
+  router.put(`/:id`, async (req, res) => await ObjectLayerController.put(req, res, options));
+  router.put(`/`, async (req, res) => await ObjectLayerController.put(req, res, options));
+  router.delete(`/:id`, async (req, res) => await ObjectLayerController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await ObjectLayerController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = ObjectLayerRouter;
+
+export { ApiRouter, ObjectLayerRouter };

package/src/api/object-layer/object-layer.service.js

@@ -0,0 +1,49 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { FileFactory } from '../file/file.service.js';
+import fs from 'fs-extra';
+const logger = loggerFactory(import.meta);
+
+const ObjectLayerService = {
+  post: async (req, res, options) => {
+    /** @type {import('./object-layer.model.js').ObjectLayerModel} */
+
+    if (req.path.startsWith('/frame-image')) {
+      const folder = `./src/client/public/cyberia/assets/${req.params.itemType}/${req.params.itemId}/${req.params.directionCode}`;
+      if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+      const files = FileFactory.filesExtract(req);
+      for (const file of files) {
+        fs.writeFileSync(`${folder}/${file.name}`, file.data);
+      }
+      return;
+    }
+
+    if (req.path.startsWith('/metadata')) {
+      const folder = `./src/client/public/cyberia/assets/${req.params.itemType}/${req.params.itemId}`;
+      if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+      fs.writeFileSync(`${folder}/metadata.json`, JSON.stringify(req.body));
+      return;
+    }
+
+    return await new ObjectLayer(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./object-layer.model.js').ObjectLayerModel} */
+    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
+    if (req.params.id) return await ObjectLayer.findById(req.params.id);
+    return await ObjectLayer.find();
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./object-layer.model.js').ObjectLayerModel} */
+    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
+    return await ObjectLayer.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./object-layer.model.js').ObjectLayerModel} */
+    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
+    if (req.params.id) return await ObjectLayer.findByIdAndDelete(req.params.id);
+    else return await ObjectLayer.deleteMany();
+  },
+};
+
+export { ObjectLayerService };

package/src/api/test/test.controller.js

@@ -0,0 +1,59 @@
+import { loggerFactory } from '../../server/logger.js';
+import { TestService } from './test.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const TestController = {
+  post: async (req, res, options) => {
+    try {
+      return res.status(200).json({
+        status: 'success',
+        data: await TestService.post(req, res, options),
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      const result = await TestService.get(req, res, options);
+      if (result)
+        return res.status(200).json({
+          status: 'success',
+          data: result,
+        });
+      else
+        return res.status(400).json({
+          status: 'error',
+        });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await TestService.delete(req, res, options);
+
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+};
+
+export { TestController };

package/src/api/test/test.model.js

@@ -0,0 +1,14 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const TestSchema = new Schema({
+  testId: { type: String, required: true, immutable: true },
+  value: { type: String, required: true, immutable: true },
+});
+
+const TestModel = model('Test', TestSchema);
+
+const ProviderSchema = TestSchema;
+
+export { TestSchema, TestModel, ProviderSchema };

package/src/api/test/test.router.js

@@ -0,0 +1,21 @@
+import { loggerFactory } from '../../server/logger.js';
+import { TestController } from './test.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const TestRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(`/:id`, async (req, res) => await TestController.post(req, res, options));
+  router.post(`/`, authMiddleware, async (req, res) => await TestController.post(req, res, options));
+  router.get(`/:id`, async (req, res) => await TestController.get(req, res, options));
+  router.get(`/`, async (req, res) => await TestController.get(req, res, options));
+  router.delete(`/:id`, async (req, res) => await TestController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await TestController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = TestRouter;
+
+export { ApiRouter, TestRouter };

package/src/api/test/test.service.js

@@ -0,0 +1,35 @@
+import validator from 'validator';
+import { loggerFactory } from '../../server/logger.js';
+import { TestModel } from './test.model.js';
+import { getYouTubeID, validatePassword } from '../../client/components/core/CommonJs.js';
+
+const logger = loggerFactory(import.meta);
+
+const TestService = {
+  post: async (req, res, options) => {
+    switch (req.params.id) {
+      default:
+        break;
+    }
+  },
+  get: async (req, res, options) => {
+    switch (req.params.id) {
+      case 'verify-email':
+        return validator.isEmail(req.query.email);
+      case 'youtube-id':
+        return getYouTubeID(req.query.url);
+      case 'is-strong-password':
+        return validatePassword(req.query.password);
+
+      default:
+    }
+  },
+  delete: async (req, res, options) => {
+    switch (req.params.id) {
+      default:
+        break;
+    }
+  },
+};
+
+export { TestService };

package/src/api/user/postman_collection.json

@@ -0,0 +1,216 @@
+{
+  "info": {
+    "_postman_id": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
+    "name": "User API",
+    "description": "A collection of requests for the User API.",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+  },
+  "item": [
+    {
+      "name": "user",
+      "item": [
+        {
+          "name": "Log in",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json",
+                "type": "text"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n    \"email\": \"user@example.com\",\n    \"password\": \"Password123\"\n}",
+              "options": {
+                "raw": {
+                  "language": "json"
+                }
+              }
+            },
+            "url": {
+              "raw": "{{baseUrl}}/user/auth",
+              "host": ["{{baseUrl}}"],
+              "path": ["user", "auth"]
+            },
+            "description": "This endpoint get a JWT for authenticated user"
+          },
+          "response": [
+            {
+              "name": "User logged in successfully",
+              "originalRequest": {
+                "method": "POST",
+                "header": [],
+                "body": {
+                  "mode": "raw",
+                  "raw": ""
+                },
+                "url": {
+                  "raw": "{{baseUrl}}/user/auth",
+                  "host": ["{{baseUrl}}"],
+                  "path": ["user", "auth"]
+                }
+              },
+              "status": "OK",
+              "code": 200,
+              "_postman_previewlanguage": "json",
+              "header": [
+                {
+                  "key": "Content-Type",
+                  "value": "application/json"
+                }
+              ],
+              "cookie": [],
+              "body": "{\n    \"status\": \"success\",\n    \"data\": {\n        \"token\": \"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjp7Il9pZCI6IjY2YzM3N2Y1N2Y5OWU1OTY5YjgxZG...\",\n        \"user\": {\n            \"_id\": \"66c377f57f99e5969b81de89\",\n            \"email\": \"user@example.com\",\n            \"emailConfirmed\": false,\n            \"username\": \"user123\",\n            \"role\": \"user\",\n            \"profileImageId\": \"66c377f57f99e5969b81de87\"\n        }\n    }\n}"
+            }
+          ]
+        },
+        {
+          "name": "Create user",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json",
+                "type": "text"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n    \"username\": \"user123\",\n    \"password\": \"Password123\",\n    \"email\": \"user@example.com\"\n}",
+              "options": {
+                "raw": {
+                  "language": "json"
+                }
+              }
+            },
+            "url": {
+              "raw": "{{baseUrl}}/user",
+              "host": ["{{baseUrl}}"],
+              "path": ["user"]
+            },
+            "description": "This endpoint will create a new user account"
+          },
+          "response": []
+        },
+        {
+          "name": "Get user data by ID",
+          "request": {
+            "auth": {
+              "type": "bearer",
+              "bearer": [
+                {
+                  "key": "token",
+                  "value": "{{authToken}}",
+                  "type": "string"
+                }
+              ]
+            },
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/user/:id",
+              "host": ["{{baseUrl}}"],
+              "path": ["user", ":id"],
+              "variable": [
+                {
+                  "key": "id",
+                  "value": "your_user_id"
+                }
+              ]
+            },
+            "description": "This endpoint get user data by ID"
+          },
+          "response": []
+        },
+        {
+          "name": "Update user data by ID",
+          "request": {
+            "auth": {
+              "type": "bearer",
+              "bearer": [
+                {
+                  "key": "token",
+                  "value": "{{authToken}}",
+                  "type": "string"
+                }
+              ]
+            },
+            "method": "PUT",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json",
+                "type": "text"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n    \"username\": \"newuser123\",\n    \"password\": \"NewPassword123\",\n    \"email\": \"newuser@example.com\"\n}",
+              "options": {
+                "raw": {
+                  "language": "json"
+                }
+              }
+            },
+            "url": {
+              "raw": "{{baseUrl}}/user/:id",
+              "host": ["{{baseUrl}}"],
+              "path": ["user", ":id"],
+              "variable": [
+                {
+                  "key": "id",
+                  "value": "your_user_id"
+                }
+              ]
+            },
+            "description": "This endpoint will update user data by ID"
+          },
+          "response": []
+        },
+        {
+          "name": "Delete user data by ID",
+          "request": {
+            "auth": {
+              "type": "bearer",
+              "bearer": [
+                {
+                  "key": "token",
+                  "value": "{{authToken}}",
+                  "type": "string"
+                }
+              ]
+            },
+            "method": "DELETE",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/user/:id",
+              "host": ["{{baseUrl}}"],
+              "path": ["user", ":id"],
+              "variable": [
+                {
+                  "key": "id",
+                  "value": "your_user_id"
+                }
+              ]
+            },
+            "description": "This endpoint deletes user data by ID, the path ID must match with the ID of the authenticated user"
+          },
+          "response": []
+        }
+      ]
+    }
+  ],
+  "variable": [
+    {
+      "key": "baseUrl",
+      "value": "http://localhost:3000/api"
+    },
+    {
+      "key": "authToken",
+      "value": ""
+    }
+  ]
+}

package/src/api/user/user.build.js

@@ -0,0 +1,16 @@
+import fs from 'fs-extra';
+import { faBase64Png, getBufferPngText } from '../../server/client-icons.js';
+
+process.exit(0);
+
+fs.writeFileSync(
+  './tmp/api-user-invalid-token.png',
+  await getBufferPngText({ text: 'Invalid token', textColor: '#ff0000' }),
+  'utf8',
+);
+fs.writeFileSync(
+  './tmp/api-user-recover.png',
+  Buffer.from(faBase64Png('rotate-left', 50, 50, '#ffffff'), 'base64'),
+  'utf8',
+);
+fs.writeFileSync('./tmp/api-user-check.png', Buffer.from(faBase64Png('check', 50, 50), 'base64'), 'utf8');

package/src/api/user/user.controller.js

@@ -0,0 +1,35 @@
+import { loggerFactory } from '../../server/logger.js';
+import { UserService } from './user.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const handleRequest = (serviceMethod) => async (req, res, options) => {
+  try {
+    const result = await serviceMethod(req, res, options);
+    if (res.headersSent) {
+      return;
+    }
+    if (result instanceof Buffer) {
+      return res.status(200).end(result);
+    }
+    return res.status(200).json({
+      status: 'success',
+      data: result,
+    });
+  } catch (error) {
+    logger.error(error, error.stack);
+    return res.status(400).json({
+      status: 'error',
+      message: error.message,
+    });
+  }
+};
+
+const UserController = {
+  post: handleRequest(UserService.post),
+  get: handleRequest(UserService.get),
+  delete: handleRequest(UserService.delete),
+  put: handleRequest(UserService.put),
+};
+
+export { UserController };

package/src/api/user/user.model.js

@@ -0,0 +1,100 @@
+import { Schema, model } from 'mongoose';
+import validator from 'validator';
+import { userRoleEnum } from '../../client/components/core/CommonJs.js';
+import crypto from 'crypto';
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const UserSchema = new Schema(
+  {
+    email: {
+      type: String,
+      trim: true,
+      lowercase: true,
+      unique: true,
+      required: 'Email address is required',
+      validate: [validator.isEmail, 'Please fill a valid email address'],
+      // match: [/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/, 'Please fill a valid email address'],
+    },
+    emailConfirmed: { type: Boolean, default: false },
+    recoverTimeOut: { type: Date },
+    lastLoginDate: { type: Date },
+    failedLoginAttempts: { type: Number, default: 0 },
+    password: { type: String, trim: true, required: 'Password is required' },
+    username: { type: String, trim: true, unique: true, required: 'Username is required' },
+    role: { type: String, enum: userRoleEnum, default: 'guest' },
+    activeSessions: {
+      type: [
+        {
+          tokenHash: { type: String, required: true },
+          ip: { type: String },
+          userAgent: { type: String },
+          expiresAt: { type: Date, required: true },
+          host: { type: String },
+          path: { type: String },
+        },
+      ],
+      default: [],
+    },
+    profileImageId: { type: Schema.Types.ObjectId, ref: 'File' },
+    phoneNumbers: [
+      {
+        type: {
+          type: String,
+          enum: ['office', 'home', 'private'],
+        },
+        number: { type: String },
+      },
+    ],
+    publicKey: {
+      type: [
+        {
+          type: Schema.Types.ObjectId,
+          ref: 'Crypto',
+        },
+      ],
+      default: [],
+    },
+    associatedCompanies: [
+      {
+        company: { type: Schema.Types.ObjectId, ref: 'Company', required: true },
+        context: [{ type: String, enum: ['client', 'supplier', 'employee', 'owner'] }],
+      },
+    ],
+  },
+  {
+    timestamps: true,
+  },
+);
+
+const UserModel = model('User', UserSchema);
+
+const ProviderSchema = UserSchema;
+
+const UserDto = {
+  select: {
+    get: () => {
+      return { _id: 1, username: 1, email: 1, role: 1, emailConfirmed: 1, profileImageId: 1 };
+    },
+    getAll: () => {
+      return { _id: 1 };
+    },
+  },
+  auth: {
+    payload: (user, jwtid, ip, userAgent, host, path) => {
+      const tokenPayload = {
+        _id: user._id.toString(),
+        role: user.role,
+        email: user.email,
+        ip,
+        userAgent,
+        host,
+        path,
+        jwtid: jwtid ?? crypto.randomBytes(8).toString('hex'),
+        refreshExpiresAt: Date.now() + parseInt(process.env.REFRESH_EXPIRE_MINUTES) * 60 * 1000,
+      };
+      return tokenPayload;
+    },
+  },
+};
+
+export { UserSchema, UserModel, userRoleEnum, ProviderSchema, UserDto };