underpost 2.6.2

package/src/api/file/file.controller.js

@@ -0,0 +1,51 @@
+import { loggerFactory } from '../../server/logger.js';
+import { FileService } from './file.service.js';
+const logger = loggerFactory(import.meta);
+
+const FileController = {
+  post: async (req, res, options) => {
+    try {
+      return res.status(200).json({
+        status: 'success',
+        data: await FileService.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 {
+      return res.status(200).json({
+        status: 'success',
+        data: await FileService.get(req, res, options),
+      });
+    } 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 FileService.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 { FileController };

package/src/api/file/file.model.js

@@ -0,0 +1,19 @@
+import { Schema, model } from 'mongoose';
+
+const FileSchema = new Schema({
+  name: { type: String },
+  data: { type: Buffer },
+  size: { type: Number },
+  encoding: { type: String },
+  tempFilePath: { type: String },
+  truncated: { type: Boolean },
+  mimetype: { type: String },
+  md5: { type: String },
+  cid: { type: String },
+});
+
+const FileModel = model('File', FileSchema);
+
+const ProviderSchema = FileSchema;
+
+export { FileSchema, FileModel, ProviderSchema };

package/src/api/file/file.router.js

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

package/src/api/file/file.service.js

@@ -0,0 +1,70 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import crypto from 'crypto';
+
+const logger = loggerFactory(import.meta);
+
+const FileFactory = {
+  upload: async function (req, File) {
+    const results = [];
+    if (!req.files) throw { message: 'not file found' };
+    if (Array.isArray(req.files.file)) for (const file of req.files.file) results.push(await new File(file).save());
+    else if (Object.keys(req.files).length > 0)
+      for (const keyFile of Object.keys(req.files)) results.push(await new File(req.files[keyFile]).save());
+    let index = -1;
+    for (const file of results) {
+      index++;
+      const [result] = await File.find({
+        _id: file._id,
+      }).select({ _id: 1, name: 1, mimetype: 1 });
+      results[index] = result;
+    }
+    return results;
+  },
+  svg: (data = new Buffer(), name = '') => {
+    return {
+      name: name,
+      data: data,
+      size: data.length,
+      encoding: '7bit',
+      tempFilePath: '',
+      truncated: false,
+      mimetype: 'image/svg+xml',
+      md5: crypto.createHash('md5').update(data).digest('hex'),
+      cid: undefined,
+    };
+  },
+};
+
+const FileService = {
+  post: async (req, res, options) => {
+    /** @type {import('./file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.File;
+    return await FileFactory.upload(req, File);
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.File;
+
+    switch (req.params.id) {
+      case 'all':
+        return await File.find();
+
+      default:
+        return await File.find({
+          _id: req.params.id,
+        });
+    }
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.File;
+
+    switch (req.params.id) {
+      default:
+        return await File.findByIdAndDelete(req.params.id);
+    }
+  },
+};
+
+export { FileService, FileFactory };

package/src/api/instance/instance.controller.js

@@ -0,0 +1,69 @@
+import { loggerFactory } from '../../server/logger.js';
+import { InstanceService } from './instance.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const InstanceController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await InstanceService.post(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,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      const result = await InstanceService.get(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,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await InstanceService.put(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,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await InstanceService.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 { InstanceController };

package/src/api/instance/instance.model.js

@@ -0,0 +1,36 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const InstanceSchema = new Schema(
+  {
+    deployId: { type: String },
+    host: { type: String },
+    path: { type: String },
+    userId: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+const InstanceDto = {
+  populate: {
+    get: () => {
+      return {
+        path: 'userId',
+        model: 'User',
+        select: '_id email',
+      };
+    },
+  },
+};
+
+const InstanceModel = model('Instance', InstanceSchema);
+
+const ProviderSchema = InstanceSchema;
+
+export { InstanceSchema, InstanceModel, ProviderSchema, InstanceDto };

package/src/api/instance/instance.router.js

@@ -0,0 +1,33 @@
+import { adminGuard, authMiddleware } from '../../server/auth.js';
+import { loggerFactory } from '../../server/logger.js';
+import { InstanceController } from './instance.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const InstanceRouter = (options) => {
+  const router = express.Router();
+  router.post(`/:id`, authMiddleware, adminGuard, async (req, res) => await InstanceController.post(req, res, options));
+  router.post(`/`, authMiddleware, adminGuard, async (req, res) => await InstanceController.post(req, res, options));
+  router.get(`/:id`, authMiddleware, adminGuard, async (req, res) => await InstanceController.get(req, res, options));
+  router.get(`/`, authMiddleware, async (req, res) => await InstanceController.get(req, res, options));
+  router.put(`/:id`, authMiddleware, adminGuard, async (req, res) => await InstanceController.put(req, res, options));
+  router.put(`/`, authMiddleware, adminGuard, async (req, res) => await InstanceController.put(req, res, options));
+  router.delete(
+    `/:id`,
+    authMiddleware,
+    adminGuard,
+    async (req, res) => await InstanceController.delete(req, res, options),
+  );
+  router.delete(
+    `/`,
+    authMiddleware,
+    adminGuard,
+    async (req, res) => await InstanceController.delete(req, res, options),
+  );
+  return router;
+};
+
+const ApiRouter = InstanceRouter;
+
+export { ApiRouter, InstanceRouter };

package/src/api/instance/instance.service.js

@@ -0,0 +1,48 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { InstanceDto } from './instance.model.js';
+
+const logger = loggerFactory(import.meta);
+
+const InstanceService = {
+  post: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Instance;
+    return await new Instance(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Instance;
+
+    /** @type {import('../user/user.model.js').UserModel} */
+    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.User;
+
+    const user = await User.findOne({
+      _id: req.auth.user._id,
+    });
+    switch (req.params.id) {
+      default:
+        switch (user.role) {
+          case 'admin':
+            if (req.params.id) return await Instance.findById(req.params.id);
+            return await Instance.find().populate(InstanceDto.populate.get());
+
+          default:
+            return await Instance.find({ userId: req.auth.user._id }).populate(InstanceDto.populate.get());
+        }
+    }
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Instance;
+    return await Instance.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Instance;
+    if (req.params.id) return await Instance.findByIdAndDelete(req.params.id);
+    else return await await Instance.deleteMany();
+  },
+};
+
+export { InstanceService };

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 { authMiddleware } from '../../server/auth.js';
+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();
+  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/user.controller.js

@@ -0,0 +1,70 @@
+import { loggerFactory } from '../../server/logger.js';
+import { UserService } from './user.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const UserController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await UserService.post(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,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      const result = await UserService.get(req, res, options);
+      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,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await UserService.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,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await UserService.put(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 { UserController };

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

@@ -0,0 +1,65 @@
+import { Schema, model } from 'mongoose';
+import validator from 'validator';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const userRoleEnum = ['admin', 'moderator', 'user', 'guest'];
+
+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' },
+    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: [],
+    },
+  },
+  {
+    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, name: 1 };
+    },
+  },
+  auth: {
+    payload: (user) => ({ _id: user._id.toString(), role: user.role }),
+  },
+};
+
+export { UserSchema, UserModel, userRoleEnum, ProviderSchema, UserDto };