Initial version

.dockerignore

@@ -0,0 +1,3 @@
+backend/node_modules
+frontend/node_modules
+frontend/build

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+*/node_modules/
+*/build/

Dockerfile

@@ -0,0 +1,17 @@
+FROM node:20.15.1-alpine AS builder
+RUN apk add --no-cache git
+WORKDIR /app
+COPY frontend/package.json frontend/yarn.lock ./
+RUN yarn install --pure-lockfile
+COPY frontend .
+RUN yarn build
+
+FROM node:20.15.1-alpine
+WORKDIR /app
+COPY backend/package.json backend/yarn.lock ./
+RUN yarn install --pure-lockfile
+COPY backend .
+
+COPY --from=builder /app/build /app/public
+CMD ["yarn", "start"]
+

Dockerfile.dev

@@ -0,0 +1,66 @@
+# Base image for Node.js dependencies
+FROM node:20.15.1-alpine AS frontend-deps
+RUN apk add --no-cache git
+WORKDIR /app/frontend
+COPY frontend/package.json frontend/yarn.lock ./
+RUN yarn install --pure-lockfile
+
+FROM node:20.15.1-alpine AS backend-deps
+RUN apk add --no-cache git
+WORKDIR /app/backend
+COPY backend/package.json backend/yarn.lock ./
+RUN yarn install --pure-lockfile
+
+FROM node:20.15.1-alpine AS app-shell-deps
+RUN apk add --no-cache git
+WORKDIR /app/app-shell
+COPY app-shell/package.json app-shell/yarn.lock ./
+RUN yarn install --pure-lockfile
+
+# Nginx setup and application build
+FROM node:20.15.1-alpine AS build
+RUN apk add --no-cache git nginx
+RUN apk add --no-cache lsof procps
+RUN yarn global add concurrently
+
+RUN mkdir -p /app/pids
+
+# Make sure to add yarn global bin to PATH
+ENV PATH /root/.yarn/bin:/root/.config/yarn/global/node_modules/.bin:$PATH
+
+# Copy dependencies
+WORKDIR /app
+COPY --from=frontend-deps /app/frontend /app/frontend
+COPY --from=backend-deps /app/backend /app/backend
+COPY --from=app-shell-deps /app/app-shell /app/app-shell
+
+COPY frontend /app/frontend
+COPY backend /app/backend
+COPY app-shell /app/app-shell
+COPY docker /app/docker
+
+# Copy Nginx configuration
+COPY nginx.conf /etc/nginx/nginx.conf
+
+# Copy all files from root to /app
+COPY . /app
+
+# Expose the port the app runs on
+EXPOSE 8080
+ENV NODE_ENV=dev_stage
+ENV FRONT_PORT=3001
+ENV APP_SHELL_PORT=4000
+
+# Start app_shell
+CMD ["sh", "-c", "\
+  yarn --cwd /app/frontend dev & echo $! > /app/pids/frontend.pid && \
+  yarn --cwd /app/backend start & echo $! > /app/pids/backend.pid && \
+  sleep 10 && nginx -g 'daemon off;' & \
+  NGINX_PID=$! && \
+  echo 'Waiting for frontend (port ${FRONT_PORT}) to be available...' && \
+  while ! nc -z localhost ${FRONT_PORT}; do \
+    sleep 2; \
+  done && \
+  echo 'Frontend is up. Starting app_shell for Git check...' && \
+  yarn --cwd /app/app-shell start && \
+  wait $NGINX_PID"]

LICENSE

@@ -0,0 +1 @@
+https://flatlogic.com/

README.md

@@ -0,0 +1,200 @@
+
+
+# reham
+
+## This project was generated by [Flatlogic Platform](https://flatlogic.com).
+
+  - Frontend: [React.js](https://flatlogic.com/templates?framework%5B%5D=react&sort=default)
+
+  - Backend: [NodeJS](https://flatlogic.com/templates?backend%5B%5D=nodejs&sort=default)
+
+    <details><summary>Backend Folder Structure</summary>   
+
+    The generated application has the following backend folder structure: 
+
+    `src` folder which contains your working files that will be used later to create the build. The src folder contains folders as:
+
+      - `auth` - config the library for authentication and authorization;
+
+      - `db` - contains such folders as:
+
+        - `api` - documentation that is automatically generated by jsdoc or other tools;
+
+        - `migrations` - is a skeleton of the database or all the actions that users do with the database;
+
+        - `models`- what will represent the database for the backend;
+
+        - `seeders` -  the entity that creates the data for the database.
+
+      - `routes` - this folder would contain all the routes that you have created using Express Router and what they do would be exported from a Controller file;
+
+      - `services` - contains such folders as `emails` and `notifications`.   
+    </details> 
+
+  - Database: PostgreSQL
+
+- app-shel: Core application framework that provides essential infrastructure services
+for the entire application.
+  -----------------------
+### We offer 2 ways how to start the project locally: by running Frontend and Backend or with Docker.
+-----------------------
+
+## To start the project:
+
+### Backend:
+
+> Please change current folder: `cd backend`
+
+#### Install local dependencies:
+`yarn install`
+
+  ------------
+
+#### Adjust local db:
+##### 1.  Install postgres:
+
+MacOS:
+
+`brew install postgres`
+
+    > if you don’t have ‘brew‘ please install it (https://brew.sh) and repeat step `brew install postgres`.
+
+Ubuntu:
+
+`sudo apt update`
+
+`sudo apt install postgresql postgresql-contrib`
+
+##### 2. Create db and admin user:
+Before run and test connection, make sure you have created a database as described in the above configuration. You can use the `psql` command to create a user and database.
+
+`psql postgres --u postgres`
+
+Next, type this command for creating a new user with password then give access for creating the database.
+
+`postgres-# CREATE ROLE admin WITH LOGIN PASSWORD 'admin_pass';`
+
+`postgres-# ALTER ROLE admin CREATEDB;`
+
+Quit `psql` then log in again using the new user that previously created.
+
+`postgres-# \q`
+
+`psql postgres -U admin`
+
+Type this command to creating a new database.
+
+`postgres=> CREATE DATABASE db_{your_project_name};`
+
+Then give that new user privileges to the new database then quit the `psql`.
+
+`postgres=> GRANT ALL PRIVILEGES ON DATABASE db_{your_project_name} TO admin;`
+
+`postgres=> \q`
+
+  ------------
+
+#### Create database:
+`yarn db:create`
+
+#### Start production build:
+`yarn start`
+
+### Frontend:
+
+> Please change current folder: `cd frontend`
+
+## To start the project with Docker:
+### Description:
+
+The project contains the **docker folder** and the `Dockerfile`.
+
+The `Dockerfile` is used to Deploy the project to Google Cloud.
+
+The **docker folder** contains a couple of helper scripts:
+
+- `docker-compose.yml` (all our services: web, backend, db are described here)
+- `start-backend.sh` (starts backend, but only after the database)
+- `wait-for-it.sh` (imported from https://github.com/vishnubob/wait-for-it)
+
+    > To avoid breaking the application, we recommend you don't edit the following files: everything that includes the **docker folder** and `Dokerfile`.
+
+## Run services:
+
+1. Install docker compose (https://docs.docker.com/compose/install/)
+
+2. Move to `docker` folder. All next steps should be done from this folder.
+
+   ``` cd docker ```
+
+3. Make executables from `wait-for-it.sh` and `start-backend.sh`:
+
+   ``` chmod +x start-backend.sh && chmod +x wait-for-it.sh ```
+
+4. Download dependend projects for services.
+
+5. Review the docker-compose.yml file. Make sure that all services have Dockerfiles. Only db service doesn't require a Dockerfile.
+
+6. Make sure you have needed ports (see them in `ports`) available on your local machine.
+
+7. Start services:
+
+   7.1. With an empty database `rm -rf data && docker-compose up`
+
+   7.2. With a stored (from previus runs) database data `docker-compose up`
+
+8. Check http://localhost:3000
+
+9. Stop services:
+
+   9.1. Just press `Ctr+C`
+
+## Most common errors:
+
+1. `connection refused`
+
+   There could be many reasons, but the most common are:
+
+  - The port is not open on the destination machine.
+
+  - The port is open on the destination machine, but its backlog of pending connections is full.
+
+  - A firewall between the client and server is blocking access (also check local firewalls).
+
+   After checking for firewalls and that the port is open, use telnet to connect to the IP/port to test connectivity. This removes any potential issues from your application.
+
+   ***MacOS:***
+
+   If you suspect that your SSH service might be down, you can run this command to find out:
+
+   `sudo service ssh status`
+
+   If the command line returns a status of down, then you’ve likely found the reason behind your connectivity error.
+
+   ***Ubuntu:***
+
+   Sometimes a connection refused error can also indicate that there is an IP address conflict on your network. You can search for possible IP conflicts by running:
+
+   `arp-scan -I eth0 -l | grep <ipaddress>`
+
+   `arp-scan -I eth0 -l | grep <ipaddress>`
+
+   and
+
+   `arping <ipaddress>`
+
+2. `yarn db:create` creates database with the assembled tables (on MacOS with Postgres database)
+
+   The workaround - put the next commands to your Postgres database terminal:
+
+   `DROP SCHEMA public CASCADE;`
+
+   `CREATE SCHEMA public;`
+
+   `GRANT ALL ON SCHEMA public TO postgres;`
+
+   `GRANT ALL ON SCHEMA public TO public;`
+
+   Afterwards, continue to start your project in the backend directory by running:
+
+   `yarn start`

app-shell/.eslintrc.cjs

@@ -0,0 +1,26 @@
+const globals = require('globals');
+
+module.exports = [
+  {
+    files: ['**/*.js', '**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      ecmaVersion: 2021,
+      sourceType: 'module',
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+      },
+      parser: '@typescript-eslint/parser',
+    },
+    plugins: ['@typescript-eslint'],
+    rules: {
+      'no-unused-vars': 'warn',
+      'no-console': 'off',
+      'indent': ['error', 2],
+      'quotes': ['error', 'single'],
+      'semi': ['error', 'always'],
+
+      '@typescript-eslint/no-unused-vars': 'warn',
+    },
+  },
+];

app-shell/.prettierrc

@@ -0,0 +1,11 @@
+{
+  "singleQuote": true,
+  "tabWidth": 2,
+  "printWidth": 80,
+  "trailingComma": "all",
+  "quoteProps": "as-needed",
+  "jsxSingleQuote": true,
+  "bracketSpacing": true,
+  "bracketSameLine": false,
+  "arrowParens": "always"
+}

app-shell/.sequelizerc

@@ -0,0 +1,7 @@
+const path = require('path');
+module.exports = {
+  "config": path.resolve("src", "db", "db.config.js"),
+  "models-path": path.resolve("src", "db", "models"),
+  "seeders-path": path.resolve("src", "db", "seeders"),
+  "migrations-path": path.resolve("src", "db", "migrations")
+};

app-shell/Dockerfile

@@ -0,0 +1,23 @@
+FROM node:20.15.1-alpine
+
+RUN apk update && apk add bash
+# Create app directory
+WORKDIR /usr/src/app
+
+# Install app dependencies
+# A wildcard is used to ensure both package.json AND package-lock.json are copied
+# where available (npm@5+)
+COPY package*.json ./
+
+RUN yarn install
+# If you are building your code for production
+# RUN npm ci --only=production
+
+
+# Bundle app source
+COPY . .
+
+
+EXPOSE 4000
+
+CMD [ "yarn", "start" ]

app-shell/README.md

@@ -0,0 +1,13 @@
+#test - template backend,
+
+#### Run App on local machine:
+
+##### Install local dependencies:
+
+- `yarn install`
+
+---
+
+##### Start build:
+
+- `yarn start`

app-shell/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "app-shell",
+  "description": "app-shell",
+  "scripts": {
+    "start": "nodemon ./src/index.js --delay 1000"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.26.7",
+    "adm-zip": "^0.5.16",
+    "axios": "^1.6.7",
+    "bcrypt": "5.1.1",
+    "cors": "2.8.5",
+    "eslint": "^9.13.0",
+    "express": "4.18.2",
+    "formidable": "1.2.2",
+    "helmet": "4.1.1",
+    "json2csv": "^5.0.7",
+    "jsonwebtoken": "8.5.1",
+    "lodash": "4.17.21",
+    "moment": "2.30.1",
+    "multer": "^1.4.4",
+    "passport": "^0.7.0",
+    "passport-google-oauth2": "^0.2.0",
+    "passport-jwt": "^4.0.1",
+    "passport-microsoft": "^0.1.0",
+    "postcss": "^8.5.1",
+    "sequelize-json-schema": "^2.1.1",
+    "pg": "^8.13.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "private": true,
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^8.12.2",
+    "@typescript-eslint/parser": "^8.12.2",
+    "cross-env": "7.0.3",
+    "mocha": "8.1.3",
+    "nodemon": "^3.1.7",
+    "sequelize-cli": "6.6.2"
+  }
+}

app-shell/src/config.js

@@ -0,0 +1,15 @@
+
+
+const config = {
+
+  project_uuid: '5c4f02b6-5fc8-4736-ba8b-e4c336a8d6a4',
+  flHost: process.env.NODE_ENV === 'production' ? 'https://flatlogic.com/projects' : 'http://localhost:3000/projects',
+
+    gitea_domain: process.env.GITEA_DOMAIN || 'gitea.flatlogic.app',
+    gitea_username: process.env.GITEA_USERNAME || 'admin',
+    gitea_api_token: process.env.GITEA_API_TOKEN || null,
+    github_repo_url: process.env.GITHUB_REPO_URL || null,
+    github_token: process.env.GITHUB_TOKEN || null,
+};
+
+module.exports = config;

app-shell/src/helpers.js

@@ -0,0 +1,23 @@
+const jwt = require('jsonwebtoken');
+const config = require('./config');
+
+module.exports = class Helpers {
+  static wrapAsync(fn) {
+    return function (req, res, next) {
+      fn(req, res, next).catch(next);
+    };
+  }
+
+  static commonErrorHandler(error, req, res, next) {
+    if ([400, 403, 404].includes(error.code)) {
+      return res.status(error.code).send(error.message);
+    }
+
+    console.error(error);
+    return res.status(500).send(error.message);
+  }
+
+  static jwtSign(data) {
+    return jwt.sign(data, config.secret_key, { expiresIn: '6h' });
+  }
+};

app-shell/src/index.js

@@ -0,0 +1,54 @@
+const express = require('express');
+const cors = require('cors');
+const app = express();
+const bodyParser = require('body-parser');
+const checkPermissions = require('./middlewares/check-permissions');
+const modifyPath = require('./middlewares/modify-path');
+const VCS = require('./services/vcs');
+
+const executorRoutes = require('./routes/executor');
+const vcsRoutes = require('./routes/vcs');
+
+// Function to initialize the Git repository
+function initRepo() {
+    const projectId = '30185';
+    return VCS.initRepo(projectId);
+}
+
+// Start the Express app on APP_SHELL_PORT (4000)
+function startServer() {
+    const PORT = 4000;
+    app.listen(PORT, () => {
+        console.log(`Listening on port ${PORT}`);
+    });
+}
+
+// Run Git check after the server is up
+function runGitCheck() {
+    initRepo()
+      .then(result => {
+          console.log(result.message);
+          // Here you can add additional logic if needed
+      })
+      .catch(err => {
+          console.error('Error during repo initialization:', err);
+          // Optionally exit the process if Git check is critical:
+          process.exit(1);
+      });
+}
+
+app.use(cors({ origin: true }));
+app.use(bodyParser.json());
+app.use(checkPermissions);
+app.use(modifyPath);
+
+app.use('/executor', executorRoutes);
+app.use('/vcs', vcsRoutes);
+
+// Start the app_shell server
+startServer();
+
+// Now perform Git check
+runGitCheck();
+
+module.exports = app;

app-shell/src/middlewares/check-permissions.js

@@ -0,0 +1,17 @@
+const config = require('../config');
+
+function checkPermissions(req, res, next) {
+  const project_uuid = config.project_uuid;
+  const requiredHeader = 'X-Project-UUID';
+  const headerValue = req.headers[requiredHeader.toLowerCase()];
+  // Logging whatever request we're getting
+  console.log('Request:', req.url, req.method, req.body, req.headers);
+
+  if (headerValue && headerValue === project_uuid) {
+    next();
+  } else {
+    res.status(403).send({ error: 'Stop right there, criminal scum! Your project UUID is invalid or missing.' });
+  }
+}
+
+module.exports = checkPermissions;

app-shell/src/middlewares/modify-path.js

@@ -0,0 +1,8 @@
+function modifyPath(req, res, next) {
+    if (req.body && req.body.path) {
+      req.body.path = '../../../' + req.body.path;
+    }
+    next();
+  }
+  
+module.exports = modifyPath;

app-shell/src/routes/executor.js

@@ -0,0 +1,288 @@
+const express = require('express');
+const multer = require('multer');
+const upload = multer({ dest: 'uploads/' });
+const fs = require('fs');
+
+const ExecutorService = require('../services/executor');
+
+const wrapAsync = require('../helpers').wrapAsync;
+
+const router = express.Router();
+
+router.post(
+    '/read_project_tree',
+    wrapAsync(async (req, res) => {
+        const { path } = req.body;
+        const tree = await ExecutorService.readProjectTree(path);
+        res.status(200).send(tree);
+    }),
+);
+
+router.post(
+    '/read_file',
+    wrapAsync(async (req, res) => {
+        const { path, showLines } = req.body;
+        const content = await ExecutorService.readFileContents(path, showLines);
+        res.status(200).send(content);
+    }),
+);
+
+router.post(
+    '/count_file_lines',
+    wrapAsync(async (req, res) => {
+        const { path } = req.body;
+        const content = await ExecutorService.countFileLines(path);
+        res.status(200).send(content);
+    }),
+);
+
+// router.post(
+//     '/read_file_header',
+//     wrapAsync(async (req, res) => {
+//         const { path, N } = req.body;
+//         try {
+//             const header = await ExecutorService.readFileHeader(path, N);
+//             res.status(200).send(header);
+//         } catch (error) {
+//             res.status(500).send({
+//                 error: true,
+//                 message: error.message,
+//                 details: error.details || error.stack,
+//                 validation: error.validation
+//             });
+//         }
+//     }),
+// );
+
+router.post(
+    '/read_file_line_context',
+    wrapAsync(async (req, res) => {
+        const { path, lineNumber, windowSize, showLines } = req.body;
+        try {
+            const context = await ExecutorService.readFileLineContext(path, lineNumber, windowSize, showLines);
+            res.status(200).send(context);
+        } catch (error) {
+            res.status(500).send({
+                error: true,
+                message: error.message,
+                details: error.details || error.stack,
+                validation: error.validation
+            });
+        }
+    }),
+);
+
+router.post(
+    '/write_file',
+    wrapAsync(async (req, res) => {
+        const { path, fileContents, comment } = req.body;
+        try {
+            await ExecutorService.writeFile(path, fileContents, comment);
+            res.status(200).send({ message: 'File written successfully' });
+        } catch (error) {
+            res.status(500).send({
+                error: true,
+                message: error.message,
+                details: error.details || error.stack,
+                validation: error.validation
+            });
+        }
+    }),
+);
+
+router.post(
+    '/insert_file_content',
+    wrapAsync(async (req, res) => {
+        const { path, lineNumber, newContent, message } = req.body;
+        try {
+            await ExecutorService.insertFileContent(path, lineNumber, newContent, message);
+            res.status(200).send({ message: 'File written successfully' });
+        } catch (error) {
+            res.status(500).send({
+                error: true,
+                message: error.message,
+                details: error.details || error.stack,
+                validation: error.validation
+            });
+        }
+    }),
+);
+
+router.post(
+    '/replace_file_line',
+    wrapAsync(async (req, res) => {
+        const { path, lineNumber, newText } = req.body;
+        try {
+            const result = await ExecutorService.replaceFileLine(path, lineNumber, newText);
+            res.status(200).send(result);
+        } catch (error) {
+            res.status(500).send({
+                error: true,
+                message: error.message,
+                details: error.details || error.stack,
+                validation: error.validation
+            });
+        }
+    }),
+);
+router.post(
+    '/replace_file_chunk',
+    wrapAsync(async (req, res) => {
+        const { path, startLine, endLine, newCode } = req.body;
+        try {
+            const result = await ExecutorService.replaceFileChunk(path, startLine, endLine, newCode);
+            res.status(200).send(result);
+        } catch (error) {
+            res.status(500).send({
+                error: true,
+                message: error.message,
+                details: error.details || error.stack,
+                validation: error.validation
+            });
+        }
+    }),
+);
+
+router.post(
+    '/delete_file_lines',
+    wrapAsync(async (req, res) => {
+        const { path, startLine, endLine, message } = req.body;
+        try {
+            const result = await ExecutorService.deleteFileLines(path, startLine, endLine, message);
+            res.status(200).send(result);
+        } catch (error) {
+            res.status(500).send({
+                error: true,
+                message: error.message,
+                details: error.details || error.stack,
+                validation: error.validation
+            });
+        }
+    }),
+);
+
+router.post(
+    '/validate_file',
+    wrapAsync(async (req, res) => {
+        const { path } = req.body;
+        try {
+            const validationResult = await ExecutorService.validateFile(path);
+            res.status(200).send({ validationResult });
+        } catch (error) {
+            res.status(500).send({
+                error: true,
+                message: error.message,
+                details: error.details || error.stack,
+                validation: error.validation
+            });
+        }
+    }),
+);
+
+
+router.post(
+  '/check_frontend_runtime_error',
+  wrapAsync(async (req, res) => {
+    try {
+      const result =  await ExecutorService.checkFrontendRuntimeLogs();
+      res.status(200).send(result);
+    } catch (error) {
+      res.status(500).send({ error: error });
+    }
+  }),
+);
+
+
+router.post(
+    '/replace_code_block',
+    wrapAsync(async (req, res) => {
+        const {path, oldCode, newCode, message} = req.body;
+        try {
+            const response = await ExecutorService.replaceCodeBlock(path, oldCode, newCode, message);
+            res.status(200).send(response);
+        } catch (error) {
+            res.status(500).send({
+                error: true,
+                message: error.message,
+                details: error.details || error.stack,
+                validation: error.validation
+            })
+        }
+    })
+)
+
+router.post('/update_project_files_from_scheme',
+    upload.single('file'), // 'file' - name of the field in the form
+    async (req, res) => {
+        console.log('Request received');
+        console.log('Headers:', req.headers);
+        if (!req.file) {
+            return res.status(400).json({ error: 'No file uploaded' });
+        }
+
+        console.log('File info:', {
+            originalname: req.file.originalname,
+            path: req.file.path,
+            size: req.file.size,
+            mimetype: req.file.mimetype
+        });
+
+        try {
+            console.log('Starting update process...');
+            const result = await ExecutorService.updateProjectFilesFromScheme(req.file.path);
+            console.log('Update completed, result:', result);
+
+            console.log('Removing temp file...');
+            fs.unlinkSync(req.file.path);
+            console.log('Temp file removed');
+
+            console.log('Sending response...');
+            return res.json(result);
+        } catch (error) {
+            console.error('Error in route handler:', error);
+            if (req.file) {
+                try {
+                    fs.unlinkSync(req.file.path);
+                    console.log('Temp file removed after error');
+                } catch (unlinkError) {
+                    console.error('Error removing temp file:', unlinkError);
+                }
+            }
+            console.error('Update project files error:', error);
+            return res.status(500).json({
+                error: error.message,
+                stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+            });
+        }
+    }
+);
+
+router.post(
+    '/get_db_schema',
+    wrapAsync(async (req, res) => {
+        try {
+
+            const jsonSchema = await ExecutorService.getDBSchema();
+            res.status(200).send({ jsonSchema });
+        } catch (error) {
+            res.status(500).send({ error: error });
+        }
+    }),
+);
+
+router.post(
+    '/execute_sql',
+    wrapAsync(async (req, res) => {
+        try {
+            const { query } = req.body;
+            const result =  await ExecutorService.executeSQL(query);
+            res.status(200).send(result);
+        } catch (error) {
+            res.status(500).send({ error: error });
+        }
+    }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

app-shell/src/routes/vcs.js

@@ -0,0 +1,40 @@
+const express = require('express');
+const wrapAsync = require('../helpers').wrapAsync; // Ваша обёртка для обработки асинхронных маршрутов
+const VSC = require('../services/vcs');
+const router = express.Router();
+
+router.post('/init', wrapAsync(async (req, res) => {
+    const result = await VSC.initRepo();
+    res.status(200).send(result);
+}));
+
+router.post('/commit', wrapAsync(async (req, res) => {
+    const { message, files } = req.body;
+    const result = await VSC.commitChanges(message, files);
+    res.status(200).send(result);
+}));
+
+router.post('/log', wrapAsync(async (req, res) => {
+    const result = await VSC.getLog();
+    res.status(200).send(result);
+}));
+
+router.post('/rollback', wrapAsync(async (req, res) => {
+    const { ref } = req.body;
+    // const result = await VSC.checkout(ref);
+    const result = await VSC.revert(ref);
+    res.status(200).send(result);
+}));
+
+router.post('/sync-to-stable', wrapAsync(async (req, res) => {
+    const result = await VSC.mergeDevIntoMaster();
+    res.status(200).send(result);
+}));
+
+router.post('/reset-dev', wrapAsync(async (req, res) => {
+    const result = await VSC.resetDevBranch();
+    res.status(200).send(result);
+}));
+
+router.use('/', require('../helpers').commonErrorHandler);
+module.exports = router;

app-shell/src/services/database.js

@@ -0,0 +1,88 @@
+// Database.js
+const { Client } = require('pg');
+const config = require('../../../backend/src/db/db.config');
+
+const env = process.env.NODE_ENV || 'development';
+const dbConfig = config[env];
+
+class Database {
+    constructor() {
+        this.client = new Client({
+            user: dbConfig.username,
+            password: dbConfig.password,
+            database: dbConfig.database,
+            host: dbConfig.host,
+            port: dbConfig.port
+        });
+
+        // Connect once, reuse the client
+        this.client.connect().catch(err => {
+            console.error('Error connecting to the database:', err);
+            throw err;
+        });
+    }
+
+    async executeSQL(query) {
+        try {
+            const result = await this.client.query(query);
+            return {
+                success: true,
+                rows: result.rows
+            };
+        } catch (error) {
+            console.error('Error executing query:', error);
+            throw error;
+        }
+    }
+
+    // Method to fetch simple table/column info from 'information_schema'
+    // (You can expand this to handle constraints, indexes, etc.)
+    async getDBSchema(schemaName = 'public') {
+        try {
+            const tableQuery = `
+                SELECT table_name
+                FROM information_schema.tables
+                WHERE table_schema = $1
+                  AND table_type = 'BASE TABLE'
+                ORDER BY table_name
+              `;
+
+            const columnQuery = `
+                SELECT table_name, column_name, data_type, is_nullable
+                FROM information_schema.columns
+                WHERE table_schema = $1
+                ORDER BY table_name, ordinal_position
+              `;
+
+            const [tablesResult, columnsResult] = await Promise.all([
+                this.client.query(tableQuery, [schemaName]),
+                this.client.query(columnQuery, [schemaName]),
+            ]);
+
+            // Build a simple schema object:
+            const tables = tablesResult.rows.map(row => row.table_name);
+            const columnsByTable = {};
+
+            columnsResult.rows.forEach(row => {
+                const { table_name, column_name, data_type, is_nullable } = row;
+                if (!columnsByTable[table_name]) columnsByTable[table_name] = [];
+                columnsByTable[table_name].push({ column_name, data_type, is_nullable });
+            });
+
+            // Combine tables with their columns
+            return tables.map(table => ({
+                table,
+                columns: columnsByTable[table] || [],
+            }));
+        } catch (error) {
+            console.error('Error fetching schema:', error);
+            throw error;
+        }
+    }
+
+    async close() {
+        await this.client.end();
+    }
+}
+
+module.exports = new Database();

app-shell/src/services/notifications/errors/forbidden.js

@@ -0,0 +1,16 @@
+const { getNotification, isNotification } = require('../helpers');
+
+module.exports = class ForbiddenError extends Error {
+  constructor(messageCode) {
+    let message;
+
+    if (messageCode && isNotification(messageCode)) {
+      message = getNotification(messageCode);
+    }
+
+    message = message || getNotification('errors.forbidden.message');
+
+    super(message);
+    this.code = 403;
+  }
+};

app-shell/src/services/notifications/errors/validation.js

@@ -0,0 +1,16 @@
+const { getNotification, isNotification } = require('../helpers');
+
+module.exports = class ValidationError extends Error {
+  constructor(messageCode) {
+    let message;
+
+    if (messageCode && isNotification(messageCode)) {
+      message = getNotification(messageCode);
+    }
+
+    message = message || getNotification('errors.validation.message');
+
+    super(message);
+    this.code = 400;
+  }
+};

app-shell/src/services/notifications/helpers.js

@@ -0,0 +1,30 @@
+const _get = require('lodash/get');
+const errors = require('./list');
+
+function format(message, args) {
+  if (!message) {
+    return null;
+  }
+
+  return message.replace(/{(\d+)}/g, function (match, number) {
+    return typeof args[number] != 'undefined' ? args[number] : match;
+  });
+}
+
+const isNotification = (key) => {
+  const message = _get(errors, key);
+  return !!message;
+};
+
+const getNotification = (key, ...args) => {
+  const message = _get(errors, key);
+
+  if (!message) {
+    return key;
+  }
+
+  return format(message, args);
+};
+
+exports.getNotification = getNotification;
+exports.isNotification = isNotification;

app-shell/src/services/notifications/list.js

@@ -0,0 +1,100 @@
+const errors = {
+  app: {
+    title: 'test',
+  },
+
+  auth: {
+    userDisabled: 'Your account is disabled',
+    forbidden: 'Forbidden',
+    unauthorized: 'Unauthorized',
+    userNotFound: `Sorry, we don't recognize your credentials`,
+    wrongPassword: `Sorry, we don't recognize your credentials`,
+    weakPassword: 'This password is too weak',
+    emailAlreadyInUse: 'Email is already in use',
+    invalidEmail: 'Please provide a valid email',
+    passwordReset: {
+      invalidToken: 'Password reset link is invalid or has expired',
+      error: `Email not recognized`,
+    },
+    passwordUpdate: {
+      samePassword: `You can't use the same password. Please create new password`,
+    },
+    userNotVerified: `Sorry, your email has not been verified yet`,
+    emailAddressVerificationEmail: {
+      invalidToken: 'Email verification link is invalid or has expired',
+      error: `Email not recognized`,
+    },
+  },
+
+  iam: {
+    errors: {
+      userAlreadyExists: 'User with this email already exists',
+      userNotFound: 'User not found',
+      disablingHimself: `You can't disable yourself`,
+      revokingOwnPermission: `You can't revoke your own owner permission`,
+      deletingHimself: `You can't delete yourself`,
+      emailRequired: 'Email is required',
+    },
+  },
+
+  importer: {
+    errors: {
+      invalidFileEmpty: 'The file is empty',
+      invalidFileExcel: 'Only excel (.xlsx) files are allowed',
+      invalidFileUpload:
+        'Invalid file. Make sure you are using the last version of the template.',
+      importHashRequired: 'Import hash is required',
+      importHashExistent: 'Data has already been imported',
+      userEmailMissing: 'Some items in the CSV do not have an email',
+    },
+  },
+
+  errors: {
+    forbidden: {
+      message: 'Forbidden',
+    },
+    validation: {
+      message: 'An error occurred',
+    },
+    searchQueryRequired: {
+      message: 'Search query is required',
+    },
+  },
+
+  emails: {
+    invitation: {
+      subject: `You've been invited to {0}`,
+      body: `    
+        <p>Hello,</p>
+        <p>You've been invited to {0} set password for your {1} account.</p>
+        <p><a href='{2}'>{2}</a></p>
+        <p>Thanks,</p>
+        <p>Your {0} team</p>
+      `,
+    },
+    emailAddressVerification: {
+      subject: `Verify your email for {0}`,
+      body: `
+        <p>Hello,</p>
+        <p>Follow this link to verify your email address.</p>
+        <p><a href='{0}'>{0}</a></p>
+        <p>If you didn't ask to verify this address, you can ignore this email.</p>
+        <p>Thanks,</p>
+        <p>Your {1} team</p>
+      `,
+    },
+    passwordReset: {
+      subject: `Reset your password for {0}`,
+      body: `
+        <p>Hello,</p>
+        <p>Follow this link to reset your {0} password for your {1} account.</p>
+        <p><a href='{2}'>{2}</a></p>
+        <p>If you didn't ask to reset your password, you can ignore this email.</p>
+        <p>Thanks,</p>
+        <p>Your {0} team</p>
+      `,
+    },
+  },
+};
+
+module.exports = errors;

backend/.prettierrc

@@ -0,0 +1,11 @@
+{
+  "singleQuote": true,
+  "tabWidth": 2,
+  "printWidth": 80,
+  "trailingComma": "all",
+  "quoteProps": "as-needed",
+  "jsxSingleQuote": true,
+  "bracketSpacing": true,
+  "bracketSameLine": false,
+  "arrowParens": "always"
+}

backend/.sequelizerc

@@ -0,0 +1,7 @@
+const path = require('path');
+module.exports = {
+  "config": path.resolve("src", "db", "db.config.js"),
+  "models-path": path.resolve("src", "db", "models"),
+  "seeders-path": path.resolve("src", "db", "seeders"),
+  "migrations-path": path.resolve("src", "db", "migrations")
+};

backend/Dockerfile

@@ -0,0 +1,23 @@
+FROM node:20.15.1-alpine
+
+RUN apk update && apk add bash
+# Create app directory
+WORKDIR /usr/src/app
+
+# Install app dependencies
+# A wildcard is used to ensure both package.json AND package-lock.json are copied
+# where available (npm@5+)
+COPY package*.json ./
+
+RUN yarn install
+# If you are building your code for production
+# RUN npm ci --only=production
+
+
+# Bundle app source
+COPY . .
+
+
+EXPOSE 8080
+
+CMD [ "yarn", "start" ]

backend/README.md

@@ -0,0 +1,67 @@
+#reham - template backend,
+
+#### Run App on local machine:
+
+##### Install local dependencies:
+
+- `yarn install`
+
+---
+
+##### Adjust local db:
+
+###### 1. Install postgres:
+
+- MacOS:
+
+  - `brew install postgres`
+
+- Ubuntu:
+  - `sudo apt update`
+  - `sudo apt install postgresql postgresql-contrib`
+
+###### 2. Create db and admin user:
+
+- Before run and test connection, make sure you have created a database as described in the above configuration. You can use the `psql` command to create a user and database.
+
+  - `psql postgres --u postgres`
+
+- Next, type this command for creating a new user with password then give access for creating the database.
+
+  - `postgres-# CREATE ROLE admin WITH LOGIN PASSWORD 'admin_pass';`
+  - `postgres-# ALTER ROLE admin CREATEDB;`
+
+- Quit `psql` then log in again using the new user that previously created.
+
+  - `postgres-# \q`
+  - `psql postgres -U admin`
+
+- Type this command to creating a new database.
+
+  - `postgres=> CREATE DATABASE db_reham;`
+
+- Then give that new user privileges to the new database then quit the `psql`.
+  - `postgres=> GRANT ALL PRIVILEGES ON DATABASE db_reham TO admin;`
+  - `postgres=> \q`
+
+---
+
+#### Api Documentation (Swagger)
+
+http://localhost:8080/api-docs (local host)
+
+http://host_name/api-docs
+
+---
+
+##### Setup database tables or update after schema change
+
+- `yarn db:migrate`
+
+##### Seed the initial data (admin accounts, relevant for the first setup):
+
+- `yarn db:seed`
+
+##### Start build:
+
+- `yarn start`

backend/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "reham",
+  "description": "reham - template backend",
+  "scripts": {
+    "start": "npm run db:migrate && npm run db:seed && nodemon ./src/index.js --delay 1000",
+    "db:migrate": "sequelize-cli db:migrate",
+    "db:seed": "sequelize-cli db:seed:all",
+    "db:drop": "sequelize-cli db:drop",
+    "db:create": "sequelize-cli db:create"
+  },
+  "dependencies": {
+    "@google-cloud/storage": "^5.18.2",
+    "axios": "^1.6.7",
+    "bcrypt": "5.1.1",
+    "cors": "2.8.5",
+    "csv-parser": "^3.0.0",
+    "express": "4.18.2",
+    "formidable": "1.2.2",
+    "helmet": "4.1.1",
+    "json2csv": "^5.0.7",
+    "jsonwebtoken": "8.5.1",
+    "lodash": "4.17.21",
+    "moment": "2.30.1",
+    "multer": "^1.4.4",
+    "mysql2": "2.2.5",
+    "nodemailer": "6.9.9",
+    "passport": "^0.7.0",
+    "passport-google-oauth2": "^0.2.0",
+    "passport-jwt": "^4.0.1",
+    "passport-microsoft": "^0.1.0",
+    "pg": "8.4.1",
+    "pg-hstore": "2.3.4",
+    "sequelize": "6.35.2",
+    "sequelize-json-schema": "^2.1.1",
+    "sqlite": "4.0.15",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.0",
+    "tedious": "^18.2.4"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "private": true,
+  "devDependencies": {
+    "cross-env": "7.0.3",
+    "mocha": "8.1.3",
+    "node-mocks-http": "1.9.0",
+    "nodemon": "2.0.5",
+    "sequelize-cli": "6.6.2"
+  }
+}

backend/src/auth/auth.js

@@ -0,0 +1,79 @@
+const config = require('../config');
+const providers = config.providers;
+const helpers = require('../helpers');
+const db = require('../db/models');
+
+const passport = require('passport');
+const JWTstrategy = require('passport-jwt').Strategy;
+const ExtractJWT = require('passport-jwt').ExtractJwt;
+const GoogleStrategy = require('passport-google-oauth2').Strategy;
+const MicrosoftStrategy = require('passport-microsoft').Strategy;
+const UsersDBApi = require('../db/api/users');
+
+passport.use(
+  new JWTstrategy(
+    {
+      passReqToCallback: true,
+      secretOrKey: config.secret_key,
+      jwtFromRequest: ExtractJWT.fromAuthHeaderAsBearerToken(),
+    },
+    async (req, token, done) => {
+      try {
+        const user = await UsersDBApi.findBy({ email: token.user.email });
+
+        if (user && user.disabled) {
+          return done(new Error(`User '${user.email}' is disabled`));
+        }
+
+        req.currentUser = user;
+
+        return done(null, user);
+      } catch (error) {
+        done(error);
+      }
+    },
+  ),
+);
+
+passport.use(
+  new GoogleStrategy(
+    {
+      clientID: config.google.clientId,
+      clientSecret: config.google.clientSecret,
+      callbackURL: config.apiUrl + '/auth/signin/google/callback',
+      passReqToCallback: true,
+    },
+    function (request, accessToken, refreshToken, profile, done) {
+      socialStrategy(profile.email, profile, providers.GOOGLE, done);
+    },
+  ),
+);
+
+passport.use(
+  new MicrosoftStrategy(
+    {
+      clientID: config.microsoft.clientId,
+      clientSecret: config.microsoft.clientSecret,
+      callbackURL: config.apiUrl + '/auth/signin/microsoft/callback',
+      passReqToCallback: true,
+    },
+    function (request, accessToken, refreshToken, profile, done) {
+      const email = profile._json.mail || profile._json.userPrincipalName;
+      socialStrategy(email, profile, providers.MICROSOFT, done);
+    },
+  ),
+);
+
+function socialStrategy(email, profile, provider, done) {
+  db.users
+    .findOrCreate({ where: { email, provider } })
+    .then(([user, created]) => {
+      const body = {
+        id: user.id,
+        email: user.email,
+        name: profile.displayName,
+      };
+      const token = helpers.jwtSign({ user: body });
+      return done(null, { token });
+    });
+}

backend/src/config.js

@@ -0,0 +1,73 @@
+const os = require('os');
+
+const config = {
+  gcloud: {
+    bucket: 'fldemo-files',
+    hash: 'ddecd3bd7650b5ccdfa03a267eaf0c0b',
+  },
+  bcrypt: {
+    saltRounds: 12,
+  },
+  admin_pass: 'password',
+  admin_email: 'admin@flatlogic.com',
+  providers: {
+    LOCAL: 'local',
+    GOOGLE: 'google',
+    MICROSOFT: 'microsoft',
+  },
+  secret_key: process.env.SECRET_KEY || '',
+  remote: '',
+  port: process.env.NODE_ENV === 'production' ? '' : '8080',
+  hostUI: process.env.NODE_ENV === 'production' ? '' : 'http://localhost',
+  portUI: process.env.NODE_ENV === 'production' ? '' : '3000',
+
+  portUIProd: process.env.NODE_ENV === 'production' ? '' : ':3000',
+
+  swaggerUI: process.env.NODE_ENV === 'production' ? '' : 'http://localhost',
+  swaggerPort: process.env.NODE_ENV === 'production' ? '' : ':8080',
+  google: {
+    clientId: process.env.GOOGLE_CLIENT_ID || '',
+    clientSecret: process.env.GOOGLE_CLIENT_SECRET || '',
+  },
+  microsoft: {
+    clientId: process.env.MS_CLIENT_ID || '',
+    clientSecret: process.env.MS_CLIENT_SECRET || '',
+  },
+  uploadDir: os.tmpdir(),
+  email: {
+    from: 'reham <app@flatlogic.app>',
+    host: 'email-smtp.us-east-1.amazonaws.com',
+    port: 587,
+    auth: {
+      user: process.env.EMAIL_USER || '',
+      pass: process.env.EMAIL_PASS,
+    },
+    tls: {
+      rejectUnauthorized: false,
+    },
+  },
+  roles: {
+    super_admin: 'Super Administrator',
+
+    admin: 'Administrator',
+    user: 'User',
+  },
+
+  project_uuid: '5c4f02b6-5fc8-4736-ba8b-e4c336a8d6a4',
+  flHost:
+    process.env.NODE_ENV === 'production' ||
+    process.env.NODE_ENV === 'dev_stage'
+      ? 'https://flatlogic.com/projects'
+      : 'http://localhost:3000/projects',
+};
+
+config.pexelsKey = process.env.PEXELS_KEY || '';
+config.pexelsQuery = 'nature';
+config.host =
+  process.env.NODE_ENV === 'production' ? config.remote : 'http://localhost';
+config.apiUrl = `${config.host}${config.port ? `:${config.port}` : ``}/api`;
+config.swaggerUrl = `${config.swaggerUI}${config.swaggerPort}`;
+config.uiUrl = `${config.hostUI}${config.portUI ? `:${config.portUI}` : ``}/#`;
+config.backUrl = `${config.hostUI}${config.portUI ? `:${config.portUI}` : ``}`;
+
+module.exports = config;

backend/src/db/api/file.js

@@ -0,0 +1,73 @@
+const db = require('../models');
+const assert = require('assert');
+const services = require('../../services/file');
+
+module.exports = class FileDBApi {
+  static async replaceRelationFiles(relation, rawFiles, options) {
+    assert(relation.belongsTo, 'belongsTo is required');
+    assert(relation.belongsToColumn, 'belongsToColumn is required');
+    assert(relation.belongsToId, 'belongsToId is required');
+
+    let files = [];
+
+    if (Array.isArray(rawFiles)) {
+      files = rawFiles;
+    } else {
+      files = rawFiles ? [rawFiles] : [];
+    }
+
+    await this._removeLegacyFiles(relation, files, options);
+    await this._addFiles(relation, files, options);
+  }
+
+  static async _addFiles(relation, files, options) {
+    const transaction = (options && options.transaction) || undefined;
+    const currentUser = (options && options.currentUser) || { id: null };
+
+    const inexistentFiles = files.filter((file) => !!file.new);
+
+    for (const file of inexistentFiles) {
+      await db.file.create(
+        {
+          belongsTo: relation.belongsTo,
+          belongsToColumn: relation.belongsToColumn,
+          belongsToId: relation.belongsToId,
+          name: file.name,
+          sizeInBytes: file.sizeInBytes,
+          privateUrl: file.privateUrl,
+          publicUrl: file.publicUrl,
+          createdById: currentUser.id,
+          updatedById: currentUser.id,
+        },
+        {
+          transaction,
+        },
+      );
+    }
+  }
+
+  static async _removeLegacyFiles(relation, files, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const filesToDelete = await db.file.findAll({
+      where: {
+        belongsTo: relation.belongsTo,
+        belongsToId: relation.belongsToId,
+        belongsToColumn: relation.belongsToColumn,
+        id: {
+          [db.Sequelize.Op.notIn]: files
+            .filter((file) => !file.new)
+            .map((file) => file.id),
+        },
+      },
+      transaction,
+    });
+
+    for (let file of filesToDelete) {
+      await services.deleteGCloud(file.privateUrl);
+      await file.destroy({
+        transaction,
+      });
+    }
+  }
+};

backend/src/db/api/organizations.js

@@ -0,0 +1,299 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class OrganizationsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const organizations = await db.organizations.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    return organizations;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const organizationsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const organizations = await db.organizations.bulkCreate(organizationsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return organizations;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const organizations = await db.organizations.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await organizations.update(updatePayload, { transaction });
+
+    return organizations;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const organizations = await db.organizations.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of organizations) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of organizations) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return organizations;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const organizations = await db.organizations.findByPk(id, options);
+
+    await organizations.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await organizations.destroy({
+      transaction,
+    });
+
+    return organizations;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const organizations = await db.organizations.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!organizations) {
+      return organizations;
+    }
+
+    const output = organizations.get({ plain: true });
+
+    output.users_organizations = await organizations.getUsers_organizations({
+      transaction,
+    });
+
+    output.subscriptions_organizations =
+      await organizations.getSubscriptions_organizations({
+        transaction,
+      });
+
+    output.token_profiles_organizations =
+      await organizations.getToken_profiles_organizations({
+        transaction,
+      });
+
+    output.tokens_organizations = await organizations.getTokens_organizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('organizations', 'name', filter.name),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.organizations.findAndCountAll(
+        queryOptions,
+      );
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('organizations', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.organizations.findAll({
+      attributes: ['id', 'name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.name,
+    }));
+  }
+};

backend/src/db/api/permissions.js

@@ -0,0 +1,257 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class PermissionsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const permissions = await db.permissions.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    return permissions;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const permissionsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const permissions = await db.permissions.bulkCreate(permissionsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return permissions;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const permissions = await db.permissions.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await permissions.update(updatePayload, { transaction });
+
+    return permissions;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const permissions = await db.permissions.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of permissions) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of permissions) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return permissions;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const permissions = await db.permissions.findByPk(id, options);
+
+    await permissions.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await permissions.destroy({
+      transaction,
+    });
+
+    return permissions;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const permissions = await db.permissions.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!permissions) {
+      return permissions;
+    }
+
+    const output = permissions.get({ plain: true });
+
+    return output;
+  }
+
+  static async findAll(filter, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('permissions', 'name', filter.name),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.permissions.findAndCountAll(
+        queryOptions,
+      );
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(query, limit, offset) {
+    let where = {};
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('permissions', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.permissions.findAll({
+      attributes: ['id', 'name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.name,
+    }));
+  }
+};

backend/src/db/api/roles.js

@@ -0,0 +1,343 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const config = require('../../config');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class RolesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const roles = await db.roles.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        role_customization: data.role_customization || null,
+        globalAccess: data.globalAccess || false,
+
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await roles.setPermissions(data.permissions || [], {
+      transaction,
+    });
+
+    return roles;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const rolesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      role_customization: item.role_customization || null,
+      globalAccess: item.globalAccess || false,
+
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const roles = await db.roles.bulkCreate(rolesData, { transaction });
+
+    // For each item created, replace relation files
+
+    return roles;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const roles = await db.roles.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    if (data.role_customization !== undefined)
+      updatePayload.role_customization = data.role_customization;
+
+    if (data.globalAccess !== undefined)
+      updatePayload.globalAccess = data.globalAccess;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await roles.update(updatePayload, { transaction });
+
+    if (data.permissions !== undefined) {
+      await roles.setPermissions(data.permissions, { transaction });
+    }
+
+    return roles;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const roles = await db.roles.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of roles) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of roles) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return roles;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const roles = await db.roles.findByPk(id, options);
+
+    await roles.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await roles.destroy({
+      transaction,
+    });
+
+    return roles;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const roles = await db.roles.findOne({ where }, { transaction });
+
+    if (!roles) {
+      return roles;
+    }
+
+    const output = roles.get({ plain: true });
+
+    output.users_app_role = await roles.getUsers_app_role({
+      transaction,
+    });
+
+    output.permissions = await roles.getPermissions({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.permissions,
+        as: 'permissions',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('roles', 'name', filter.name),
+        };
+      }
+
+      if (filter.role_customization) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'roles',
+            'role_customization',
+            filter.role_customization,
+          ),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.globalAccess) {
+        where = {
+          ...where,
+          globalAccess: filter.globalAccess,
+        };
+      }
+
+      if (filter.permissions) {
+        const searchTerms = filter.permissions.split('|');
+
+        include = [
+          {
+            model: db.permissions,
+            as: 'permissions_filter',
+            required: searchTerms.length > 0,
+            where:
+              searchTerms.length > 0
+                ? {
+                    [Op.or]: [
+                      {
+                        id: {
+                          [Op.in]: searchTerms.map((term) => Utils.uuid(term)),
+                        },
+                      },
+                      {
+                        name: {
+                          [Op.or]: searchTerms.map((term) => ({
+                            [Op.iLike]: `%${term}%`,
+                          })),
+                        },
+                      },
+                    ],
+                  }
+                : undefined,
+          },
+          ...include,
+        ];
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (!globalAccess) {
+      where = { name: { [Op.ne]: config.roles.super_admin } };
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.roles.findAndCountAll(queryOptions);
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(query, limit, offset, globalAccess) {
+    let where = {};
+
+    if (!globalAccess) {
+      where = { name: { [Op.ne]: config.roles.super_admin } };
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('roles', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.roles.findAll({
+      attributes: ['id', 'name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.name,
+    }));
+  }
+};

backend/src/db/api/subscriptions.js

@@ -0,0 +1,489 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class SubscriptionsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const subscriptions = await db.subscriptions.create(
+      {
+        id: data.id || undefined,
+
+        start_date: data.start_date || null,
+        end_date: data.end_date || null,
+        price: data.price || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await subscriptions.setUser(data.user || null, {
+      transaction,
+    });
+
+    await subscriptions.setToken(data.token || null, {
+      transaction,
+    });
+
+    await subscriptions.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return subscriptions;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const subscriptionsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      start_date: item.start_date || null,
+      end_date: item.end_date || null,
+      price: item.price || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const subscriptions = await db.subscriptions.bulkCreate(subscriptionsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return subscriptions;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const subscriptions = await db.subscriptions.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.start_date !== undefined)
+      updatePayload.start_date = data.start_date;
+
+    if (data.end_date !== undefined) updatePayload.end_date = data.end_date;
+
+    if (data.price !== undefined) updatePayload.price = data.price;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await subscriptions.update(updatePayload, { transaction });
+
+    if (data.user !== undefined) {
+      await subscriptions.setUser(
+        data.user,
+
+        { transaction },
+      );
+    }
+
+    if (data.token !== undefined) {
+      await subscriptions.setToken(
+        data.token,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await subscriptions.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return subscriptions;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const subscriptions = await db.subscriptions.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of subscriptions) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of subscriptions) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return subscriptions;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const subscriptions = await db.subscriptions.findByPk(id, options);
+
+    await subscriptions.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await subscriptions.destroy({
+      transaction,
+    });
+
+    return subscriptions;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const subscriptions = await db.subscriptions.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!subscriptions) {
+      return subscriptions;
+    }
+
+    const output = subscriptions.get({ plain: true });
+
+    output.user = await subscriptions.getUser({
+      transaction,
+    });
+
+    output.token = await subscriptions.getToken({
+      transaction,
+    });
+
+    output.organizations = await subscriptions.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.users,
+        as: 'user',
+
+        where: filter.user
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.user
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  firstName: {
+                    [Op.or]: filter.user
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.tokens,
+        as: 'token',
+
+        where: filter.token
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.token
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.token
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              start_date: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              end_date: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.start_dateRange) {
+        const [start, end] = filter.start_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            start_date: {
+              ...where.start_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            start_date: {
+              ...where.start_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.end_dateRange) {
+        const [start, end] = filter.end_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            end_date: {
+              ...where.end_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            end_date: {
+              ...where.end_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.priceRange) {
+        const [start, end] = filter.priceRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            price: {
+              ...where.price,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            price: {
+              ...where.price,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.subscriptions.findAndCountAll(
+        queryOptions,
+      );
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('subscriptions', 'user', query),
+        ],
+      };
+    }
+
+    const records = await db.subscriptions.findAll({
+      attributes: ['id', 'user'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['user', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.user,
+    }));
+  }
+};

backend/src/db/api/token_profiles.js

@@ -0,0 +1,443 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class Token_profilesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const token_profiles = await db.token_profiles.create(
+      {
+        id: data.id || undefined,
+
+        description: data.description || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await token_profiles.setToken(data.token || null, {
+      transaction,
+    });
+
+    await token_profiles.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.token_profiles.getTableName(),
+        belongsToColumn: 'images',
+        belongsToId: token_profiles.id,
+      },
+      data.images,
+      options,
+    );
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.token_profiles.getTableName(),
+        belongsToColumn: 'documents',
+        belongsToId: token_profiles.id,
+      },
+      data.documents,
+      options,
+    );
+
+    return token_profiles;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const token_profilesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      description: item.description || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const token_profiles = await db.token_profiles.bulkCreate(
+      token_profilesData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    for (let i = 0; i < token_profiles.length; i++) {
+      await FileDBApi.replaceRelationFiles(
+        {
+          belongsTo: db.token_profiles.getTableName(),
+          belongsToColumn: 'images',
+          belongsToId: token_profiles[i].id,
+        },
+        data[i].images,
+        options,
+      );
+    }
+
+    for (let i = 0; i < token_profiles.length; i++) {
+      await FileDBApi.replaceRelationFiles(
+        {
+          belongsTo: db.token_profiles.getTableName(),
+          belongsToColumn: 'documents',
+          belongsToId: token_profiles[i].id,
+        },
+        data[i].documents,
+        options,
+      );
+    }
+
+    return token_profiles;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const token_profiles = await db.token_profiles.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.description !== undefined)
+      updatePayload.description = data.description;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await token_profiles.update(updatePayload, { transaction });
+
+    if (data.token !== undefined) {
+      await token_profiles.setToken(
+        data.token,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await token_profiles.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.token_profiles.getTableName(),
+        belongsToColumn: 'images',
+        belongsToId: token_profiles.id,
+      },
+      data.images,
+      options,
+    );
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.token_profiles.getTableName(),
+        belongsToColumn: 'documents',
+        belongsToId: token_profiles.id,
+      },
+      data.documents,
+      options,
+    );
+
+    return token_profiles;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const token_profiles = await db.token_profiles.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of token_profiles) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of token_profiles) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return token_profiles;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const token_profiles = await db.token_profiles.findByPk(id, options);
+
+    await token_profiles.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await token_profiles.destroy({
+      transaction,
+    });
+
+    return token_profiles;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const token_profiles = await db.token_profiles.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!token_profiles) {
+      return token_profiles;
+    }
+
+    const output = token_profiles.get({ plain: true });
+
+    output.token = await token_profiles.getToken({
+      transaction,
+    });
+
+    output.images = await token_profiles.getImages({
+      transaction,
+    });
+
+    output.documents = await token_profiles.getDocuments({
+      transaction,
+    });
+
+    output.organizations = await token_profiles.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tokens,
+        as: 'token',
+
+        where: filter.token
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.token
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.token
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+
+      {
+        model: db.file,
+        as: 'images',
+      },
+
+      {
+        model: db.file,
+        as: 'documents',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.description) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'token_profiles',
+            'description',
+            filter.description,
+          ),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.token_profiles.findAndCountAll(
+        queryOptions,
+      );
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('token_profiles', 'token', query),
+        ],
+      };
+    }
+
+    const records = await db.token_profiles.findAll({
+      attributes: ['id', 'token'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['token', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.token,
+    }));
+  }
+};

backend/src/db/api/tokens.js

@@ -0,0 +1,475 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class TokensDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const tokens = await db.tokens.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        symbol: data.symbol || null,
+        market_cap: data.market_cap || null,
+        price: data.price || null,
+        launch_date: data.launch_date || null,
+        blockchain_type: data.blockchain_type || null,
+        premium_listing: data.premium_listing || false,
+
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await tokens.setSubmitted_by(data.submitted_by || null, {
+      transaction,
+    });
+
+    await tokens.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return tokens;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const tokensData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      symbol: item.symbol || null,
+      market_cap: item.market_cap || null,
+      price: item.price || null,
+      launch_date: item.launch_date || null,
+      blockchain_type: item.blockchain_type || null,
+      premium_listing: item.premium_listing || false,
+
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const tokens = await db.tokens.bulkCreate(tokensData, { transaction });
+
+    // For each item created, replace relation files
+
+    return tokens;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const tokens = await db.tokens.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    if (data.symbol !== undefined) updatePayload.symbol = data.symbol;
+
+    if (data.market_cap !== undefined)
+      updatePayload.market_cap = data.market_cap;
+
+    if (data.price !== undefined) updatePayload.price = data.price;
+
+    if (data.launch_date !== undefined)
+      updatePayload.launch_date = data.launch_date;
+
+    if (data.blockchain_type !== undefined)
+      updatePayload.blockchain_type = data.blockchain_type;
+
+    if (data.premium_listing !== undefined)
+      updatePayload.premium_listing = data.premium_listing;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await tokens.update(updatePayload, { transaction });
+
+    if (data.submitted_by !== undefined) {
+      await tokens.setSubmitted_by(
+        data.submitted_by,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await tokens.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return tokens;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const tokens = await db.tokens.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of tokens) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of tokens) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return tokens;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const tokens = await db.tokens.findByPk(id, options);
+
+    await tokens.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await tokens.destroy({
+      transaction,
+    });
+
+    return tokens;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const tokens = await db.tokens.findOne({ where }, { transaction });
+
+    if (!tokens) {
+      return tokens;
+    }
+
+    const output = tokens.get({ plain: true });
+
+    output.subscriptions_token = await tokens.getSubscriptions_token({
+      transaction,
+    });
+
+    output.token_profiles_token = await tokens.getToken_profiles_token({
+      transaction,
+    });
+
+    output.submitted_by = await tokens.getSubmitted_by({
+      transaction,
+    });
+
+    output.organizations = await tokens.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.users,
+        as: 'submitted_by',
+
+        where: filter.submitted_by
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.submitted_by
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  firstName: {
+                    [Op.or]: filter.submitted_by
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('tokens', 'name', filter.name),
+        };
+      }
+
+      if (filter.symbol) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('tokens', 'symbol', filter.symbol),
+        };
+      }
+
+      if (filter.market_capRange) {
+        const [start, end] = filter.market_capRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            market_cap: {
+              ...where.market_cap,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            market_cap: {
+              ...where.market_cap,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.priceRange) {
+        const [start, end] = filter.priceRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            price: {
+              ...where.price,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            price: {
+              ...where.price,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.launch_dateRange) {
+        const [start, end] = filter.launch_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            launch_date: {
+              ...where.launch_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            launch_date: {
+              ...where.launch_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.blockchain_type) {
+        where = {
+          ...where,
+          blockchain_type: filter.blockchain_type,
+        };
+      }
+
+      if (filter.premium_listing) {
+        where = {
+          ...where,
+          premium_listing: filter.premium_listing,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.tokens.findAndCountAll(queryOptions);
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('tokens', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.tokens.findAll({
+      attributes: ['id', 'name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.name,
+    }));
+  }
+};

backend/src/db/api/users.js

@@ -0,0 +1,807 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const bcrypt = require('bcrypt');
+const config = require('../../config');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class UsersDBApi {
+  static async create(data, globalAccess, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.create(
+      {
+        id: data.data.id || undefined,
+
+        firstName: data.data.firstName || null,
+        lastName: data.data.lastName || null,
+        phoneNumber: data.data.phoneNumber || null,
+        email: data.data.email || null,
+        disabled: data.data.disabled || false,
+
+        password: data.data.password || null,
+        emailVerified: data.data.emailVerified || true,
+
+        emailVerificationToken: data.data.emailVerificationToken || null,
+        emailVerificationTokenExpiresAt:
+          data.data.emailVerificationTokenExpiresAt || null,
+        passwordResetToken: data.data.passwordResetToken || null,
+        passwordResetTokenExpiresAt:
+          data.data.passwordResetTokenExpiresAt || null,
+        provider: data.data.provider || null,
+        importHash: data.data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    if (!data.data.app_role) {
+      const role = await db.roles.findOne({
+        where: { name: 'User' },
+      });
+      if (role) {
+        await users.setApp_role(role, {
+          transaction,
+        });
+      }
+    } else {
+      await users.setApp_role(data.data.app_role || null, {
+        transaction,
+      });
+    }
+
+    await users.setOrganizations(data.data.organizations || null, {
+      transaction,
+    });
+
+    await users.setCustom_permissions(data.data.custom_permissions || [], {
+      transaction,
+    });
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.users.getTableName(),
+        belongsToColumn: 'avatar',
+        belongsToId: users.id,
+      },
+      data.data.avatar,
+      options,
+    );
+
+    return users;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const usersData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      firstName: item.firstName || null,
+      lastName: item.lastName || null,
+      phoneNumber: item.phoneNumber || null,
+      email: item.email || null,
+      disabled: item.disabled || false,
+
+      password: item.password || null,
+      emailVerified: item.emailVerified || false,
+
+      emailVerificationToken: item.emailVerificationToken || null,
+      emailVerificationTokenExpiresAt:
+        item.emailVerificationTokenExpiresAt || null,
+      passwordResetToken: item.passwordResetToken || null,
+      passwordResetTokenExpiresAt: item.passwordResetTokenExpiresAt || null,
+      provider: item.provider || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const users = await db.users.bulkCreate(usersData, { transaction });
+
+    // For each item created, replace relation files
+
+    for (let i = 0; i < users.length; i++) {
+      await FileDBApi.replaceRelationFiles(
+        {
+          belongsTo: db.users.getTableName(),
+          belongsToColumn: 'avatar',
+          belongsToId: users[i].id,
+        },
+        data[i].avatar,
+        options,
+      );
+    }
+
+    return users;
+  }
+
+  static async update(id, data, globalAccess, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findByPk(id, {}, { transaction });
+
+    if (!data?.app_role) {
+      data.app_role = users?.app_role?.id;
+    }
+    if (!data?.custom_permissions) {
+      data.custom_permissions = users?.custom_permissions?.map(
+        (item) => item.id,
+      );
+    }
+
+    if (data.password) {
+      data.password = bcrypt.hashSync(data.password, config.bcrypt.saltRounds);
+    } else {
+      data.password = users.password;
+    }
+
+    const updatePayload = {};
+
+    if (data.firstName !== undefined) updatePayload.firstName = data.firstName;
+
+    if (data.lastName !== undefined) updatePayload.lastName = data.lastName;
+
+    if (data.phoneNumber !== undefined)
+      updatePayload.phoneNumber = data.phoneNumber;
+
+    if (data.email !== undefined) updatePayload.email = data.email;
+
+    if (data.disabled !== undefined) updatePayload.disabled = data.disabled;
+
+    if (data.password !== undefined) updatePayload.password = data.password;
+
+    if (data.emailVerified !== undefined)
+      updatePayload.emailVerified = data.emailVerified;
+    else updatePayload.emailVerified = true;
+
+    if (data.emailVerificationToken !== undefined)
+      updatePayload.emailVerificationToken = data.emailVerificationToken;
+
+    if (data.emailVerificationTokenExpiresAt !== undefined)
+      updatePayload.emailVerificationTokenExpiresAt =
+        data.emailVerificationTokenExpiresAt;
+
+    if (data.passwordResetToken !== undefined)
+      updatePayload.passwordResetToken = data.passwordResetToken;
+
+    if (data.passwordResetTokenExpiresAt !== undefined)
+      updatePayload.passwordResetTokenExpiresAt =
+        data.passwordResetTokenExpiresAt;
+
+    if (data.provider !== undefined) updatePayload.provider = data.provider;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await users.update(updatePayload, { transaction });
+
+    if (data.app_role !== undefined) {
+      await users.setApp_role(
+        data.app_role,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await users.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    if (data.custom_permissions !== undefined) {
+      await users.setCustom_permissions(data.custom_permissions, {
+        transaction,
+      });
+    }
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.users.getTableName(),
+        belongsToColumn: 'avatar',
+        belongsToId: users.id,
+      },
+      data.avatar,
+      options,
+    );
+
+    return users;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of users) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of users) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return users;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findByPk(id, options);
+
+    await users.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await users.destroy({
+      transaction,
+    });
+
+    return users;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findOne({ where }, { transaction });
+
+    if (!users) {
+      return users;
+    }
+
+    const output = users.get({ plain: true });
+
+    output.subscriptions_user = await users.getSubscriptions_user({
+      transaction,
+    });
+
+    output.tokens_submitted_by = await users.getTokens_submitted_by({
+      transaction,
+    });
+
+    output.avatar = await users.getAvatar({
+      transaction,
+    });
+
+    output.app_role = await users.getApp_role({
+      transaction,
+    });
+
+    if (output.app_role) {
+      output.app_role_permissions = await output.app_role.getPermissions({
+        transaction,
+      });
+    }
+
+    output.custom_permissions = await users.getCustom_permissions({
+      transaction,
+    });
+
+    output.organizations = await users.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.roles,
+        as: 'app_role',
+
+        where: filter.app_role
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.app_role
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.app_role
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+
+      {
+        model: db.permissions,
+        as: 'custom_permissions',
+      },
+
+      {
+        model: db.file,
+        as: 'avatar',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.firstName) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('users', 'firstName', filter.firstName),
+        };
+      }
+
+      if (filter.lastName) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('users', 'lastName', filter.lastName),
+        };
+      }
+
+      if (filter.phoneNumber) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('users', 'phoneNumber', filter.phoneNumber),
+        };
+      }
+
+      if (filter.email) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('users', 'email', filter.email),
+        };
+      }
+
+      if (filter.password) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('users', 'password', filter.password),
+        };
+      }
+
+      if (filter.emailVerificationToken) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'users',
+            'emailVerificationToken',
+            filter.emailVerificationToken,
+          ),
+        };
+      }
+
+      if (filter.passwordResetToken) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'users',
+            'passwordResetToken',
+            filter.passwordResetToken,
+          ),
+        };
+      }
+
+      if (filter.provider) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('users', 'provider', filter.provider),
+        };
+      }
+
+      if (filter.emailVerificationTokenExpiresAtRange) {
+        const [start, end] = filter.emailVerificationTokenExpiresAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            emailVerificationTokenExpiresAt: {
+              ...where.emailVerificationTokenExpiresAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            emailVerificationTokenExpiresAt: {
+              ...where.emailVerificationTokenExpiresAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.passwordResetTokenExpiresAtRange) {
+        const [start, end] = filter.passwordResetTokenExpiresAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            passwordResetTokenExpiresAt: {
+              ...where.passwordResetTokenExpiresAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            passwordResetTokenExpiresAt: {
+              ...where.passwordResetTokenExpiresAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.disabled) {
+        where = {
+          ...where,
+          disabled: filter.disabled,
+        };
+      }
+
+      if (filter.emailVerified) {
+        where = {
+          ...where,
+          emailVerified: filter.emailVerified,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.custom_permissions) {
+        const searchTerms = filter.custom_permissions.split('|');
+
+        include = [
+          {
+            model: db.permissions,
+            as: 'custom_permissions_filter',
+            required: searchTerms.length > 0,
+            where:
+              searchTerms.length > 0
+                ? {
+                    [Op.or]: [
+                      {
+                        id: {
+                          [Op.in]: searchTerms.map((term) => Utils.uuid(term)),
+                        },
+                      },
+                      {
+                        name: {
+                          [Op.or]: searchTerms.map((term) => ({
+                            [Op.iLike]: `%${term}%`,
+                          })),
+                        },
+                      },
+                    ],
+                  }
+                : undefined,
+          },
+          ...include,
+        ];
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.users.findAndCountAll(queryOptions);
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('users', 'firstName', query),
+        ],
+      };
+    }
+
+    const records = await db.users.findAll({
+      attributes: ['id', 'firstName'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['firstName', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.firstName,
+    }));
+  }
+
+  static async createFromAuth(data, options) {
+    const transaction = (options && options.transaction) || undefined;
+    const users = await db.users.create(
+      {
+        email: data.email,
+        firstName: data.firstName,
+        authenticationUid: data.authenticationUid,
+        password: data.password,
+
+        organizationId: data.organizationId,
+      },
+      { transaction },
+    );
+
+    const app_role = await db.roles.findOne({
+      where: { name: 'User' },
+    });
+    if (app_role?.id) {
+      await users.setApp_role(app_role?.id || null, {
+        transaction,
+      });
+    }
+
+    await users.update(
+      {
+        authenticationUid: users.id,
+      },
+      { transaction },
+    );
+
+    delete users.password;
+    return users;
+  }
+
+  static async updatePassword(id, password, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findByPk(id, {
+      transaction,
+    });
+
+    await users.update(
+      {
+        password,
+        authenticationUid: id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    return users;
+  }
+
+  static async generateEmailVerificationToken(email, options) {
+    return this._generateToken(
+      ['emailVerificationToken', 'emailVerificationTokenExpiresAt'],
+      email,
+      options,
+    );
+  }
+
+  static async generatePasswordResetToken(email, options) {
+    return this._generateToken(
+      ['passwordResetToken', 'passwordResetTokenExpiresAt'],
+      email,
+      options,
+    );
+  }
+
+  static async findByPasswordResetToken(token, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    return db.users.findOne(
+      {
+        where: {
+          passwordResetToken: token,
+          passwordResetTokenExpiresAt: {
+            [db.Sequelize.Op.gt]: Date.now(),
+          },
+        },
+      },
+      { transaction },
+    );
+  }
+
+  static async findByEmailVerificationToken(token, options) {
+    const transaction = (options && options.transaction) || undefined;
+    return db.users.findOne(
+      {
+        where: {
+          emailVerificationToken: token,
+          emailVerificationTokenExpiresAt: {
+            [db.Sequelize.Op.gt]: Date.now(),
+          },
+        },
+      },
+      { transaction },
+    );
+  }
+
+  static async markEmailVerified(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findByPk(id, {
+      transaction,
+    });
+
+    await users.update(
+      {
+        emailVerified: true,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    return true;
+  }
+
+  static async _generateToken(keyNames, email, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const users = await db.users.findOne(
+      {
+        where: { email: email.toLowerCase() },
+      },
+      {
+        transaction,
+      },
+    );
+
+    const token = crypto.randomBytes(20).toString('hex');
+    const tokenExpiresAt = Date.now() + 360000;
+
+    if (users) {
+      await users.update(
+        {
+          [keyNames[0]]: token,
+          [keyNames[1]]: tokenExpiresAt,
+          updatedById: currentUser.id,
+        },
+        { transaction },
+      );
+    }
+
+    return token;
+  }
+};

backend/src/db/db.config.js

@@ -0,0 +1,31 @@
+module.exports = {
+  production: {
+    dialect: 'postgres',
+    username: process.env.DB_USER,
+    password: process.env.DB_PASS,
+    database: process.env.DB_NAME,
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    logging: console.log,
+    seederStorage: 'sequelize',
+  },
+  development: {
+    username: 'postgres',
+    dialect: 'postgres',
+    password: '',
+    database: 'db_reham',
+    host: process.env.DB_HOST || 'localhost',
+    logging: console.log,
+    seederStorage: 'sequelize',
+  },
+  dev_stage: {
+    dialect: 'postgres',
+    username: process.env.DB_USER,
+    password: process.env.DB_PASS,
+    database: process.env.DB_NAME,
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    logging: console.log,
+    seederStorage: 'sequelize',
+  },
+};

backend/src/db/migrations/1742941381645.js

@@ -0,0 +1,808 @@
+module.exports = {
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async up(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.createTable(
+        'users',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.createTable(
+        'subscriptions',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.createTable(
+        'token_profiles',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.createTable(
+        'tokens',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.createTable(
+        'roles',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.createTable(
+        'permissions',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.createTable(
+        'organizations',
+        {
+          id: {
+            type: Sequelize.DataTypes.UUID,
+            defaultValue: Sequelize.DataTypes.UUIDV4,
+            primaryKey: true,
+          },
+          createdById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          updatedById: {
+            type: Sequelize.DataTypes.UUID,
+            references: {
+              key: 'id',
+              model: 'users',
+            },
+          },
+          createdAt: { type: Sequelize.DataTypes.DATE },
+          updatedAt: { type: Sequelize.DataTypes.DATE },
+          deletedAt: { type: Sequelize.DataTypes.DATE },
+          importHash: {
+            type: Sequelize.DataTypes.STRING(255),
+            allowNull: true,
+            unique: true,
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'firstName',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'lastName',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'phoneNumber',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'email',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'disabled',
+        {
+          type: Sequelize.DataTypes.BOOLEAN,
+
+          defaultValue: false,
+          allowNull: false,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'password',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'emailVerified',
+        {
+          type: Sequelize.DataTypes.BOOLEAN,
+
+          defaultValue: false,
+          allowNull: false,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'emailVerificationToken',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'emailVerificationTokenExpiresAt',
+        {
+          type: Sequelize.DataTypes.DATE,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'passwordResetToken',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'passwordResetTokenExpiresAt',
+        {
+          type: Sequelize.DataTypes.DATE,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'provider',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'subscriptions',
+        'userId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'users',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'subscriptions',
+        'tokenId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'tokens',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'subscriptions',
+        'start_date',
+        {
+          type: Sequelize.DataTypes.DATE,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'subscriptions',
+        'end_date',
+        {
+          type: Sequelize.DataTypes.DATE,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'subscriptions',
+        'price',
+        {
+          type: Sequelize.DataTypes.DECIMAL,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'token_profiles',
+        'tokenId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'tokens',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'token_profiles',
+        'description',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'tokens',
+        'name',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'tokens',
+        'symbol',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'tokens',
+        'market_cap',
+        {
+          type: Sequelize.DataTypes.DECIMAL,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'tokens',
+        'price',
+        {
+          type: Sequelize.DataTypes.DECIMAL,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'tokens',
+        'launch_date',
+        {
+          type: Sequelize.DataTypes.DATE,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'tokens',
+        'submitted_byId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'users',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'tokens',
+        'blockchain_type',
+        {
+          type: Sequelize.DataTypes.ENUM,
+
+          values: ['Ethereum', 'BinanceSmartChain', 'Solana', 'Polygon'],
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'tokens',
+        'premium_listing',
+        {
+          type: Sequelize.DataTypes.BOOLEAN,
+
+          defaultValue: false,
+          allowNull: false,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'permissions',
+        'name',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'roles',
+        'name',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'roles',
+        'role_customization',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'app_roleId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'roles',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'organizations',
+        'name',
+        {
+          type: Sequelize.DataTypes.TEXT,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'roles',
+        'globalAccess',
+        {
+          type: Sequelize.DataTypes.BOOLEAN,
+
+          defaultValue: false,
+          allowNull: false,
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'users',
+        'organizationsId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'organizations',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'subscriptions',
+        'organizationsId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'organizations',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'token_profiles',
+        'organizationsId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'organizations',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await queryInterface.addColumn(
+        'tokens',
+        'organizationsId',
+        {
+          type: Sequelize.DataTypes.UUID,
+
+          references: {
+            model: 'organizations',
+            key: 'id',
+          },
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+  /**
+   * @param {QueryInterface} queryInterface
+   * @param {Sequelize} Sequelize
+   * @returns {Promise<void>}
+   */
+  async down(queryInterface, Sequelize) {
+    /**
+     * @type {Transaction}
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('tokens', 'organizationsId', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('token_profiles', 'organizationsId', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('subscriptions', 'organizationsId', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('users', 'organizationsId', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('roles', 'globalAccess', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('organizations', 'name', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('users', 'app_roleId', { transaction });
+
+      await queryInterface.removeColumn('roles', 'role_customization', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('roles', 'name', { transaction });
+
+      await queryInterface.removeColumn('permissions', 'name', { transaction });
+
+      await queryInterface.removeColumn('tokens', 'premium_listing', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('tokens', 'blockchain_type', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('tokens', 'submitted_byId', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('tokens', 'launch_date', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('tokens', 'price', { transaction });
+
+      await queryInterface.removeColumn('tokens', 'market_cap', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('tokens', 'symbol', { transaction });
+
+      await queryInterface.removeColumn('tokens', 'name', { transaction });
+
+      await queryInterface.removeColumn('token_profiles', 'description', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('token_profiles', 'tokenId', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('subscriptions', 'price', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('subscriptions', 'end_date', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('subscriptions', 'start_date', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('subscriptions', 'tokenId', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('subscriptions', 'userId', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('users', 'provider', { transaction });
+
+      await queryInterface.removeColumn(
+        'users',
+        'passwordResetTokenExpiresAt',
+        { transaction },
+      );
+
+      await queryInterface.removeColumn('users', 'passwordResetToken', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn(
+        'users',
+        'emailVerificationTokenExpiresAt',
+        { transaction },
+      );
+
+      await queryInterface.removeColumn('users', 'emailVerificationToken', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('users', 'emailVerified', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('users', 'password', { transaction });
+
+      await queryInterface.removeColumn('users', 'disabled', { transaction });
+
+      await queryInterface.removeColumn('users', 'email', { transaction });
+
+      await queryInterface.removeColumn('users', 'phoneNumber', {
+        transaction,
+      });
+
+      await queryInterface.removeColumn('users', 'lastName', { transaction });
+
+      await queryInterface.removeColumn('users', 'firstName', { transaction });
+
+      await queryInterface.dropTable('organizations', { transaction });
+
+      await queryInterface.dropTable('permissions', { transaction });
+
+      await queryInterface.dropTable('roles', { transaction });
+
+      await queryInterface.dropTable('tokens', { transaction });
+
+      await queryInterface.dropTable('token_profiles', { transaction });
+
+      await queryInterface.dropTable('subscriptions', { transaction });
+
+      await queryInterface.dropTable('users', { transaction });
+
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+};

backend/src/db/models/file.js

@@ -0,0 +1,53 @@
+module.exports = function (sequelize, DataTypes) {
+  const file = sequelize.define(
+    'file',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      belongsTo: DataTypes.STRING(255),
+      belongsToId: DataTypes.UUID,
+      belongsToColumn: DataTypes.STRING(255),
+      name: {
+        type: DataTypes.STRING(2083),
+        allowNull: false,
+        validate: {
+          notEmpty: true,
+        },
+      },
+      sizeInBytes: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+      },
+      privateUrl: {
+        type: DataTypes.STRING(2083),
+        allowNull: true,
+      },
+      publicUrl: {
+        type: DataTypes.STRING(2083),
+        allowNull: false,
+        validate: {
+          notEmpty: true,
+        },
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+    },
+  );
+
+  file.associate = (db) => {
+    db.file.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.file.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return file;
+};

backend/src/db/models/index.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const Sequelize = require('sequelize');
+const basename = path.basename(__filename);
+const env = process.env.NODE_ENV || 'development';
+const config = require('../db.config')[env];
+const db = {};
+
+let sequelize;
+console.log(env);
+if (config.use_env_variable) {
+  sequelize = new Sequelize(process.env[config.use_env_variable], config);
+} else {
+  sequelize = new Sequelize(
+    config.database,
+    config.username,
+    config.password,
+    config,
+  );
+}
+
+fs.readdirSync(__dirname)
+  .filter((file) => {
+    return (
+      file.indexOf('.') !== 0 && file !== basename && file.slice(-3) === '.js'
+    );
+  })
+  .forEach((file) => {
+    const model = require(path.join(__dirname, file))(
+      sequelize,
+      Sequelize.DataTypes,
+    );
+    db[model.name] = model;
+  });
+
+Object.keys(db).forEach((modelName) => {
+  if (db[modelName].associate) {
+    db[modelName].associate(db);
+  }
+});
+
+db.sequelize = sequelize;
+db.Sequelize = Sequelize;
+
+module.exports = db;

backend/src/db/models/organizations.js

@@ -0,0 +1,81 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const organizations = sequelize.define(
+    'organizations',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  organizations.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.organizations.hasMany(db.users, {
+      as: 'users_organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.organizations.hasMany(db.subscriptions, {
+      as: 'subscriptions_organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.organizations.hasMany(db.token_profiles, {
+      as: 'token_profiles_organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.organizations.hasMany(db.tokens, {
+      as: 'tokens_organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.organizations.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.organizations.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return organizations;
+};

backend/src/db/models/permissions.js

@@ -0,0 +1,49 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const permissions = sequelize.define(
+    'permissions',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  permissions.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    //end loop
+
+    db.permissions.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.permissions.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return permissions;
+};

backend/src/db/models/roles.js

@@ -0,0 +1,86 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const roles = sequelize.define(
+    'roles',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      role_customization: {
+        type: DataTypes.TEXT,
+      },
+
+      globalAccess: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  roles.associate = (db) => {
+    db.roles.belongsToMany(db.permissions, {
+      as: 'permissions',
+      foreignKey: {
+        name: 'roles_permissionsId',
+      },
+      constraints: false,
+      through: 'rolesPermissionsPermissions',
+    });
+
+    db.roles.belongsToMany(db.permissions, {
+      as: 'permissions_filter',
+      foreignKey: {
+        name: 'roles_permissionsId',
+      },
+      constraints: false,
+      through: 'rolesPermissionsPermissions',
+    });
+
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.roles.hasMany(db.users, {
+      as: 'users_app_role',
+      foreignKey: {
+        name: 'app_roleId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.roles.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.roles.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return roles;
+};

backend/src/db/models/subscriptions.js

@@ -0,0 +1,81 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const subscriptions = sequelize.define(
+    'subscriptions',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      start_date: {
+        type: DataTypes.DATE,
+      },
+
+      end_date: {
+        type: DataTypes.DATE,
+      },
+
+      price: {
+        type: DataTypes.DECIMAL,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  subscriptions.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    //end loop
+
+    db.subscriptions.belongsTo(db.users, {
+      as: 'user',
+      foreignKey: {
+        name: 'userId',
+      },
+      constraints: false,
+    });
+
+    db.subscriptions.belongsTo(db.tokens, {
+      as: 'token',
+      foreignKey: {
+        name: 'tokenId',
+      },
+      constraints: false,
+    });
+
+    db.subscriptions.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.subscriptions.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.subscriptions.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return subscriptions;
+};

backend/src/db/models/token_profiles.js

@@ -0,0 +1,85 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const token_profiles = sequelize.define(
+    'token_profiles',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      description: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  token_profiles.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    //end loop
+
+    db.token_profiles.belongsTo(db.tokens, {
+      as: 'token',
+      foreignKey: {
+        name: 'tokenId',
+      },
+      constraints: false,
+    });
+
+    db.token_profiles.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.token_profiles.hasMany(db.file, {
+      as: 'images',
+      foreignKey: 'belongsToId',
+      constraints: false,
+      scope: {
+        belongsTo: db.token_profiles.getTableName(),
+        belongsToColumn: 'images',
+      },
+    });
+
+    db.token_profiles.hasMany(db.file, {
+      as: 'documents',
+      foreignKey: 'belongsToId',
+      constraints: false,
+      scope: {
+        belongsTo: db.token_profiles.getTableName(),
+        belongsToColumn: 'documents',
+      },
+    });
+
+    db.token_profiles.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.token_profiles.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return token_profiles;
+};

backend/src/db/models/tokens.js

@@ -0,0 +1,110 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const tokens = sequelize.define(
+    'tokens',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      symbol: {
+        type: DataTypes.TEXT,
+      },
+
+      market_cap: {
+        type: DataTypes.DECIMAL,
+      },
+
+      price: {
+        type: DataTypes.DECIMAL,
+      },
+
+      launch_date: {
+        type: DataTypes.DATE,
+      },
+
+      blockchain_type: {
+        type: DataTypes.ENUM,
+
+        values: ['Ethereum', 'BinanceSmartChain', 'Solana', 'Polygon'],
+      },
+
+      premium_listing: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  tokens.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.tokens.hasMany(db.subscriptions, {
+      as: 'subscriptions_token',
+      foreignKey: {
+        name: 'tokenId',
+      },
+      constraints: false,
+    });
+
+    db.tokens.hasMany(db.token_profiles, {
+      as: 'token_profiles_token',
+      foreignKey: {
+        name: 'tokenId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.tokens.belongsTo(db.users, {
+      as: 'submitted_by',
+      foreignKey: {
+        name: 'submitted_byId',
+      },
+      constraints: false,
+    });
+
+    db.tokens.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.tokens.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.tokens.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return tokens;
+};

backend/src/db/models/users.js

@@ -0,0 +1,195 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const users = sequelize.define(
+    'users',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      firstName: {
+        type: DataTypes.TEXT,
+      },
+
+      lastName: {
+        type: DataTypes.TEXT,
+      },
+
+      phoneNumber: {
+        type: DataTypes.TEXT,
+      },
+
+      email: {
+        type: DataTypes.TEXT,
+      },
+
+      disabled: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      password: {
+        type: DataTypes.TEXT,
+      },
+
+      emailVerified: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      emailVerificationToken: {
+        type: DataTypes.TEXT,
+      },
+
+      emailVerificationTokenExpiresAt: {
+        type: DataTypes.DATE,
+      },
+
+      passwordResetToken: {
+        type: DataTypes.TEXT,
+      },
+
+      passwordResetTokenExpiresAt: {
+        type: DataTypes.DATE,
+      },
+
+      provider: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  users.associate = (db) => {
+    db.users.belongsToMany(db.permissions, {
+      as: 'custom_permissions',
+      foreignKey: {
+        name: 'users_custom_permissionsId',
+      },
+      constraints: false,
+      through: 'usersCustom_permissionsPermissions',
+    });
+
+    db.users.belongsToMany(db.permissions, {
+      as: 'custom_permissions_filter',
+      foreignKey: {
+        name: 'users_custom_permissionsId',
+      },
+      constraints: false,
+      through: 'usersCustom_permissionsPermissions',
+    });
+
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.users.hasMany(db.subscriptions, {
+      as: 'subscriptions_user',
+      foreignKey: {
+        name: 'userId',
+      },
+      constraints: false,
+    });
+
+    db.users.hasMany(db.tokens, {
+      as: 'tokens_submitted_by',
+      foreignKey: {
+        name: 'submitted_byId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.users.belongsTo(db.roles, {
+      as: 'app_role',
+      foreignKey: {
+        name: 'app_roleId',
+      },
+      constraints: false,
+    });
+
+    db.users.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.users.hasMany(db.file, {
+      as: 'avatar',
+      foreignKey: 'belongsToId',
+      constraints: false,
+      scope: {
+        belongsTo: db.users.getTableName(),
+        belongsToColumn: 'avatar',
+      },
+    });
+
+    db.users.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.users.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  users.beforeCreate((users, options) => {
+    users = trimStringFields(users);
+
+    if (
+      users.provider !== providers.LOCAL &&
+      Object.values(providers).indexOf(users.provider) > -1
+    ) {
+      users.emailVerified = true;
+
+      if (!users.password) {
+        const password = crypto.randomBytes(20).toString('hex');
+
+        const hashedPassword = bcrypt.hashSync(
+          password,
+          config.bcrypt.saltRounds,
+        );
+
+        users.password = hashedPassword;
+      }
+    }
+  });
+
+  users.beforeUpdate((users, options) => {
+    users = trimStringFields(users);
+  });
+
+  return users;
+};
+
+function trimStringFields(users) {
+  users.email = users.email.trim();
+
+  users.firstName = users.firstName ? users.firstName.trim() : null;
+
+  users.lastName = users.lastName ? users.lastName.trim() : null;
+
+  return users;
+}

backend/src/db/reset.js

@@ -0,0 +1,16 @@
+const db = require('./models');
+const { execSync } = require('child_process');
+
+console.log('Resetting Database');
+
+db.sequelize
+  .sync({ force: true })
+  .then(() => {
+    execSync('sequelize db:seed:all');
+    console.log('OK');
+    process.exit();
+  })
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

backend/src/db/seeders/20200430130759-admin-user.js

@@ -0,0 +1,80 @@
+'use strict';
+const bcrypt = require('bcrypt');
+const config = require('../../config');
+
+const ids = [
+  '193bf4b5-9f07-4bd5-9a43-e7e41f3e96af',
+  'af5a87be-8f9c-4630-902a-37a60b7005ba',
+  '5bc531ab-611f-41f3-9373-b7cc5d09c93d',
+  'ab4cf9bf-4eef-4107-b73d-9d0274cf69bc',
+];
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    let hash = bcrypt.hashSync(config.admin_pass, config.bcrypt.saltRounds);
+
+    try {
+      await queryInterface.bulkInsert('users', [
+        {
+          id: ids[0],
+          firstName: 'Admin',
+          email: config.admin_email,
+          emailVerified: true,
+          provider: config.providers.LOCAL,
+          password: hash,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        {
+          id: ids[1],
+          firstName: 'John',
+          email: 'john@doe.com',
+          emailVerified: true,
+          provider: config.providers.LOCAL,
+          password: hash,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        {
+          id: ids[2],
+          firstName: 'Client',
+          email: 'client@hello.com',
+          emailVerified: true,
+          provider: config.providers.LOCAL,
+          password: hash,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        {
+          id: ids[3],
+          firstName: 'Super Admin',
+          email: 'super_admin@flatlogic.com',
+          emailVerified: true,
+          provider: config.providers.LOCAL,
+          password: hash,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ]);
+    } catch (error) {
+      console.error('Error during bulkInsert:', error);
+      throw error;
+    }
+  },
+  down: async (queryInterface, Sequelize) => {
+    try {
+      await queryInterface.bulkDelete(
+        'users',
+        {
+          id: {
+            [Sequelize.Op.in]: ids,
+          },
+        },
+        {},
+      );
+    } catch (error) {
+      console.error('Error during bulkDelete:', error);
+      throw error;
+    }
+  },
+};

backend/src/db/seeders/20200430130760-user-roles.js

@@ -0,0 +1,557 @@
+const { v4: uuid } = require('uuid');
+
+module.exports = {
+  /**
+   * @param{import("sequelize").QueryInterface} queryInterface
+   * @return {Promise<void>}
+   */
+  async up(queryInterface) {
+    const createdAt = new Date();
+    const updatedAt = new Date();
+
+    /** @type {Map<string, string>} */
+    const idMap = new Map();
+
+    /**
+     * @param {string} key
+     * @return {string}
+     */
+    function getId(key) {
+      if (idMap.has(key)) {
+        return idMap.get(key);
+      }
+      const id = uuid();
+      idMap.set(key, id);
+      return id;
+    }
+
+    await queryInterface.bulkInsert('roles', [
+      {
+        id: getId('SuperAdmin'),
+        name: 'Super Administrator',
+        createdAt,
+        updatedAt,
+      },
+
+      {
+        id: getId('Administrator'),
+        name: 'Administrator',
+        createdAt,
+        updatedAt,
+      },
+
+      { id: getId('User'), name: 'User', createdAt, updatedAt },
+    ]);
+
+    /**
+     * @param {string} name
+     */
+    function createPermissions(name) {
+      return [
+        {
+          id: getId(`CREATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `CREATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`READ_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `READ_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`UPDATE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `UPDATE_${name.toUpperCase()}`,
+        },
+        {
+          id: getId(`DELETE_${name.toUpperCase()}`),
+          createdAt,
+          updatedAt,
+          name: `DELETE_${name.toUpperCase()}`,
+        },
+      ];
+    }
+
+    const entities = [
+      'users',
+      'subscriptions',
+      'token_profiles',
+      'tokens',
+      'roles',
+      'permissions',
+      'organizations',
+      ,
+    ];
+    await queryInterface.bulkInsert(
+      'permissions',
+      entities.flatMap(createPermissions),
+    );
+    await queryInterface.bulkInsert('permissions', [
+      {
+        id: getId(`READ_API_DOCS`),
+        createdAt,
+        updatedAt,
+        name: `READ_API_DOCS`,
+      },
+    ]);
+    await queryInterface.bulkInsert('permissions', [
+      {
+        id: getId(`CREATE_SEARCH`),
+        createdAt,
+        updatedAt,
+        name: `CREATE_SEARCH`,
+      },
+    ]);
+
+    await queryInterface.bulkUpdate(
+      'roles',
+      { globalAccess: true },
+      { id: getId('SuperAdmin') },
+    );
+
+    await queryInterface.sequelize
+      .query(`create table "rolesPermissionsPermissions"
+(
+"createdAt"           timestamp with time zone not null,
+"updatedAt"           timestamp with time zone not null,
+"roles_permissionsId" uuid                     not null,
+"permissionId"        uuid                     not null,
+primary key ("roles_permissionsId", "permissionId")
+);`);
+
+    await queryInterface.bulkInsert('rolesPermissionsPermissions', [
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('CREATE_USERS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('READ_USERS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('UPDATE_USERS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('DELETE_USERS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('CREATE_SUBSCRIPTIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('READ_SUBSCRIPTIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('UPDATE_SUBSCRIPTIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('DELETE_SUBSCRIPTIONS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('CREATE_TOKEN_PROFILES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('READ_TOKEN_PROFILES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('UPDATE_TOKEN_PROFILES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('DELETE_TOKEN_PROFILES'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('CREATE_TOKENS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('READ_TOKENS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('UPDATE_TOKENS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('DELETE_TOKENS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('User'),
+        permissionId: getId('CREATE_SEARCH'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('CREATE_USERS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('READ_USERS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('UPDATE_USERS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('DELETE_USERS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('CREATE_SUBSCRIPTIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('READ_SUBSCRIPTIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('UPDATE_SUBSCRIPTIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('DELETE_SUBSCRIPTIONS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('CREATE_TOKEN_PROFILES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('READ_TOKEN_PROFILES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('UPDATE_TOKEN_PROFILES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('DELETE_TOKEN_PROFILES'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('CREATE_TOKENS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('READ_TOKENS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('UPDATE_TOKENS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('DELETE_TOKENS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_USERS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_USERS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_USERS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_USERS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_SUBSCRIPTIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_SUBSCRIPTIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_SUBSCRIPTIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_SUBSCRIPTIONS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_TOKEN_PROFILES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_TOKEN_PROFILES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_TOKEN_PROFILES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_TOKEN_PROFILES'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_TOKENS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_TOKENS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_TOKENS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_TOKENS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_ROLES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_ROLES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_ROLES'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_ROLES'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_PERMISSIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_PERMISSIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_PERMISSIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_PERMISSIONS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_ORGANIZATIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_ORGANIZATIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('UPDATE_ORGANIZATIONS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('DELETE_ORGANIZATIONS'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('READ_API_DOCS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('SuperAdmin'),
+        permissionId: getId('CREATE_SEARCH'),
+      },
+
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('READ_API_DOCS'),
+      },
+      {
+        createdAt,
+        updatedAt,
+        roles_permissionsId: getId('Administrator'),
+        permissionId: getId('CREATE_SEARCH'),
+      },
+    ]);
+
+    await queryInterface.sequelize.query(
+      `UPDATE "users" SET "app_roleId"='${getId(
+        'SuperAdmin',
+      )}' WHERE "email"='super_admin@flatlogic.com'`,
+    );
+    await queryInterface.sequelize.query(
+      `UPDATE "users" SET "app_roleId"='${getId(
+        'Administrator',
+      )}' WHERE "email"='admin@flatlogic.com'`,
+    );
+
+    await queryInterface.sequelize.query(
+      `UPDATE "users" SET "app_roleId"='${getId(
+        'User',
+      )}' WHERE "email"='client@hello.com'`,
+    );
+    await queryInterface.sequelize.query(
+      `UPDATE "users" SET "app_roleId"='${getId(
+        'User',
+      )}' WHERE "email"='john@doe.com'`,
+    );
+  },
+};

backend/src/db/seeders/20231127130745-sample-data.js

@@ -0,0 +1,494 @@
+const db = require('../models');
+const Users = db.users;
+
+const Subscriptions = db.subscriptions;
+
+const TokenProfiles = db.token_profiles;
+
+const Tokens = db.tokens;
+
+const Organizations = db.organizations;
+
+const SubscriptionsData = [
+  {
+    // type code here for "relation_one" field
+
+    // type code here for "relation_one" field
+
+    start_date: new Date('2025-01-29'),
+
+    end_date: new Date('2025-02-25'),
+
+    price: 72.16,
+
+    // type code here for "relation_one" field
+  },
+
+  {
+    // type code here for "relation_one" field
+
+    // type code here for "relation_one" field
+
+    start_date: new Date('2024-04-15'),
+
+    end_date: new Date('2024-04-24'),
+
+    price: 59.09,
+
+    // type code here for "relation_one" field
+  },
+
+  {
+    // type code here for "relation_one" field
+
+    // type code here for "relation_one" field
+
+    start_date: new Date('2024-11-06'),
+
+    end_date: new Date('2024-12-25'),
+
+    price: 76.87,
+
+    // type code here for "relation_one" field
+  },
+];
+
+const TokenProfilesData = [
+  {
+    // type code here for "relation_one" field
+
+    description: 'Do. Or do not. There is no try.',
+
+    // type code here for "images" field
+
+    // type code here for "files" field
+
+    // type code here for "relation_one" field
+  },
+
+  {
+    // type code here for "relation_one" field
+
+    description:
+      'Through the Force, things you will see. Other places. The future - the past. Old friends long gone.',
+
+    // type code here for "images" field
+
+    // type code here for "files" field
+
+    // type code here for "relation_one" field
+  },
+
+  {
+    // type code here for "relation_one" field
+
+    description:
+      'Strong is Vader. Mind what you have learned. Save you it can.',
+
+    // type code here for "images" field
+
+    // type code here for "files" field
+
+    // type code here for "relation_one" field
+  },
+];
+
+const TokensData = [
+  {
+    name: 'Euclid',
+
+    symbol: "That Barbala couldn't fly his way out of a wet paper bag",
+
+    market_cap: 30.56,
+
+    price: 40.55,
+
+    launch_date: new Date('2024-08-14'),
+
+    // type code here for "relation_one" field
+
+    blockchain_type: 'Solana',
+
+    premium_listing: true,
+
+    // type code here for "relation_one" field
+  },
+
+  {
+    name: 'Gregor Mendel',
+
+    symbol: 'Yup',
+
+    market_cap: 43.02,
+
+    price: 95.61,
+
+    launch_date: new Date('2024-06-19'),
+
+    // type code here for "relation_one" field
+
+    blockchain_type: 'BinanceSmartChain',
+
+    premium_listing: false,
+
+    // type code here for "relation_one" field
+  },
+
+  {
+    name: 'Claude Bernard',
+
+    symbol: "That's messed up",
+
+    market_cap: 37.87,
+
+    price: 80.42,
+
+    launch_date: new Date('2024-04-23'),
+
+    // type code here for "relation_one" field
+
+    blockchain_type: 'Polygon',
+
+    premium_listing: false,
+
+    // type code here for "relation_one" field
+  },
+];
+
+const OrganizationsData = [
+  {
+    name: 'Max Planck',
+  },
+
+  {
+    name: 'Francis Galton',
+  },
+
+  {
+    name: 'Dmitri Mendeleev',
+  },
+];
+
+// Similar logic for "relation_many"
+
+async function associateUserWithOrganization() {
+  const relatedOrganization0 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const User0 = await Users.findOne({
+    order: [['id', 'ASC']],
+    offset: 0,
+  });
+  if (User0?.setOrganization) {
+    await User0.setOrganization(relatedOrganization0);
+  }
+
+  const relatedOrganization1 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const User1 = await Users.findOne({
+    order: [['id', 'ASC']],
+    offset: 1,
+  });
+  if (User1?.setOrganization) {
+    await User1.setOrganization(relatedOrganization1);
+  }
+
+  const relatedOrganization2 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const User2 = await Users.findOne({
+    order: [['id', 'ASC']],
+    offset: 2,
+  });
+  if (User2?.setOrganization) {
+    await User2.setOrganization(relatedOrganization2);
+  }
+}
+
+async function associateSubscriptionWithUser() {
+  const relatedUser0 = await Users.findOne({
+    offset: Math.floor(Math.random() * (await Users.count())),
+  });
+  const Subscription0 = await Subscriptions.findOne({
+    order: [['id', 'ASC']],
+    offset: 0,
+  });
+  if (Subscription0?.setUser) {
+    await Subscription0.setUser(relatedUser0);
+  }
+
+  const relatedUser1 = await Users.findOne({
+    offset: Math.floor(Math.random() * (await Users.count())),
+  });
+  const Subscription1 = await Subscriptions.findOne({
+    order: [['id', 'ASC']],
+    offset: 1,
+  });
+  if (Subscription1?.setUser) {
+    await Subscription1.setUser(relatedUser1);
+  }
+
+  const relatedUser2 = await Users.findOne({
+    offset: Math.floor(Math.random() * (await Users.count())),
+  });
+  const Subscription2 = await Subscriptions.findOne({
+    order: [['id', 'ASC']],
+    offset: 2,
+  });
+  if (Subscription2?.setUser) {
+    await Subscription2.setUser(relatedUser2);
+  }
+}
+
+async function associateSubscriptionWithToken() {
+  const relatedToken0 = await Tokens.findOne({
+    offset: Math.floor(Math.random() * (await Tokens.count())),
+  });
+  const Subscription0 = await Subscriptions.findOne({
+    order: [['id', 'ASC']],
+    offset: 0,
+  });
+  if (Subscription0?.setToken) {
+    await Subscription0.setToken(relatedToken0);
+  }
+
+  const relatedToken1 = await Tokens.findOne({
+    offset: Math.floor(Math.random() * (await Tokens.count())),
+  });
+  const Subscription1 = await Subscriptions.findOne({
+    order: [['id', 'ASC']],
+    offset: 1,
+  });
+  if (Subscription1?.setToken) {
+    await Subscription1.setToken(relatedToken1);
+  }
+
+  const relatedToken2 = await Tokens.findOne({
+    offset: Math.floor(Math.random() * (await Tokens.count())),
+  });
+  const Subscription2 = await Subscriptions.findOne({
+    order: [['id', 'ASC']],
+    offset: 2,
+  });
+  if (Subscription2?.setToken) {
+    await Subscription2.setToken(relatedToken2);
+  }
+}
+
+async function associateSubscriptionWithOrganization() {
+  const relatedOrganization0 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const Subscription0 = await Subscriptions.findOne({
+    order: [['id', 'ASC']],
+    offset: 0,
+  });
+  if (Subscription0?.setOrganization) {
+    await Subscription0.setOrganization(relatedOrganization0);
+  }
+
+  const relatedOrganization1 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const Subscription1 = await Subscriptions.findOne({
+    order: [['id', 'ASC']],
+    offset: 1,
+  });
+  if (Subscription1?.setOrganization) {
+    await Subscription1.setOrganization(relatedOrganization1);
+  }
+
+  const relatedOrganization2 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const Subscription2 = await Subscriptions.findOne({
+    order: [['id', 'ASC']],
+    offset: 2,
+  });
+  if (Subscription2?.setOrganization) {
+    await Subscription2.setOrganization(relatedOrganization2);
+  }
+}
+
+async function associateTokenProfileWithToken() {
+  const relatedToken0 = await Tokens.findOne({
+    offset: Math.floor(Math.random() * (await Tokens.count())),
+  });
+  const TokenProfile0 = await TokenProfiles.findOne({
+    order: [['id', 'ASC']],
+    offset: 0,
+  });
+  if (TokenProfile0?.setToken) {
+    await TokenProfile0.setToken(relatedToken0);
+  }
+
+  const relatedToken1 = await Tokens.findOne({
+    offset: Math.floor(Math.random() * (await Tokens.count())),
+  });
+  const TokenProfile1 = await TokenProfiles.findOne({
+    order: [['id', 'ASC']],
+    offset: 1,
+  });
+  if (TokenProfile1?.setToken) {
+    await TokenProfile1.setToken(relatedToken1);
+  }
+
+  const relatedToken2 = await Tokens.findOne({
+    offset: Math.floor(Math.random() * (await Tokens.count())),
+  });
+  const TokenProfile2 = await TokenProfiles.findOne({
+    order: [['id', 'ASC']],
+    offset: 2,
+  });
+  if (TokenProfile2?.setToken) {
+    await TokenProfile2.setToken(relatedToken2);
+  }
+}
+
+async function associateTokenProfileWithOrganization() {
+  const relatedOrganization0 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const TokenProfile0 = await TokenProfiles.findOne({
+    order: [['id', 'ASC']],
+    offset: 0,
+  });
+  if (TokenProfile0?.setOrganization) {
+    await TokenProfile0.setOrganization(relatedOrganization0);
+  }
+
+  const relatedOrganization1 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const TokenProfile1 = await TokenProfiles.findOne({
+    order: [['id', 'ASC']],
+    offset: 1,
+  });
+  if (TokenProfile1?.setOrganization) {
+    await TokenProfile1.setOrganization(relatedOrganization1);
+  }
+
+  const relatedOrganization2 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const TokenProfile2 = await TokenProfiles.findOne({
+    order: [['id', 'ASC']],
+    offset: 2,
+  });
+  if (TokenProfile2?.setOrganization) {
+    await TokenProfile2.setOrganization(relatedOrganization2);
+  }
+}
+
+async function associateTokenWithSubmitted_by() {
+  const relatedSubmitted_by0 = await Users.findOne({
+    offset: Math.floor(Math.random() * (await Users.count())),
+  });
+  const Token0 = await Tokens.findOne({
+    order: [['id', 'ASC']],
+    offset: 0,
+  });
+  if (Token0?.setSubmitted_by) {
+    await Token0.setSubmitted_by(relatedSubmitted_by0);
+  }
+
+  const relatedSubmitted_by1 = await Users.findOne({
+    offset: Math.floor(Math.random() * (await Users.count())),
+  });
+  const Token1 = await Tokens.findOne({
+    order: [['id', 'ASC']],
+    offset: 1,
+  });
+  if (Token1?.setSubmitted_by) {
+    await Token1.setSubmitted_by(relatedSubmitted_by1);
+  }
+
+  const relatedSubmitted_by2 = await Users.findOne({
+    offset: Math.floor(Math.random() * (await Users.count())),
+  });
+  const Token2 = await Tokens.findOne({
+    order: [['id', 'ASC']],
+    offset: 2,
+  });
+  if (Token2?.setSubmitted_by) {
+    await Token2.setSubmitted_by(relatedSubmitted_by2);
+  }
+}
+
+async function associateTokenWithOrganization() {
+  const relatedOrganization0 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const Token0 = await Tokens.findOne({
+    order: [['id', 'ASC']],
+    offset: 0,
+  });
+  if (Token0?.setOrganization) {
+    await Token0.setOrganization(relatedOrganization0);
+  }
+
+  const relatedOrganization1 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const Token1 = await Tokens.findOne({
+    order: [['id', 'ASC']],
+    offset: 1,
+  });
+  if (Token1?.setOrganization) {
+    await Token1.setOrganization(relatedOrganization1);
+  }
+
+  const relatedOrganization2 = await Organizations.findOne({
+    offset: Math.floor(Math.random() * (await Organizations.count())),
+  });
+  const Token2 = await Tokens.findOne({
+    order: [['id', 'ASC']],
+    offset: 2,
+  });
+  if (Token2?.setOrganization) {
+    await Token2.setOrganization(relatedOrganization2);
+  }
+}
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await Subscriptions.bulkCreate(SubscriptionsData);
+
+    await TokenProfiles.bulkCreate(TokenProfilesData);
+
+    await Tokens.bulkCreate(TokensData);
+
+    await Organizations.bulkCreate(OrganizationsData);
+
+    await Promise.all([
+      // Similar logic for "relation_many"
+
+      await associateUserWithOrganization(),
+
+      await associateSubscriptionWithUser(),
+
+      await associateSubscriptionWithToken(),
+
+      await associateSubscriptionWithOrganization(),
+
+      await associateTokenProfileWithToken(),
+
+      await associateTokenProfileWithOrganization(),
+
+      await associateTokenWithSubmitted_by(),
+
+      await associateTokenWithOrganization(),
+    ]);
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.bulkDelete('subscriptions', null, {});
+
+    await queryInterface.bulkDelete('token_profiles', null, {});
+
+    await queryInterface.bulkDelete('tokens', null, {});
+
+    await queryInterface.bulkDelete('organizations', null, {});
+  },
+};

backend/src/db/utils.js

@@ -0,0 +1,24 @@
+const validator = require('validator');
+const { v4: uuid } = require('uuid');
+const Sequelize = require('./models').Sequelize;
+
+module.exports = class Utils {
+  static uuid(value) {
+    let id = value;
+
+    if (!validator.isUUID(id)) {
+      id = uuid();
+    }
+
+    return id;
+  }
+
+  static ilike(model, column, value) {
+    return Sequelize.where(
+      Sequelize.fn('lower', Sequelize.col(`${model}.${column}`)),
+      {
+        [Sequelize.Op.like]: `%${value}%`.toLowerCase(),
+      },
+    );
+  }
+};

backend/src/helpers.js

@@ -0,0 +1,23 @@
+const jwt = require('jsonwebtoken');
+const config = require('./config');
+
+module.exports = class Helpers {
+  static wrapAsync(fn) {
+    return function (req, res, next) {
+      fn(req, res, next).catch(next);
+    };
+  }
+
+  static commonErrorHandler(error, req, res, next) {
+    if ([400, 403, 404].includes(error.code)) {
+      return res.status(error.code).send(error.message);
+    }
+
+    console.error(error);
+    return res.status(500).send(error.message);
+  }
+
+  static jwtSign(data) {
+    return jwt.sign(data, config.secret_key, { expiresIn: '6h' });
+  }
+};

backend/src/index.js

@@ -0,0 +1,175 @@
+const express = require('express');
+const cors = require('cors');
+const app = express();
+const passport = require('passport');
+const path = require('path');
+const fs = require('fs');
+const bodyParser = require('body-parser');
+const db = require('./db/models');
+const config = require('./config');
+const swaggerUI = require('swagger-ui-express');
+const swaggerJsDoc = require('swagger-jsdoc');
+
+const authRoutes = require('./routes/auth');
+const fileRoutes = require('./routes/file');
+const searchRoutes = require('./routes/search');
+const pexelsRoutes = require('./routes/pexels');
+
+const organizationForAuthRoutes = require('./routes/organizationLogin');
+
+const openaiRoutes = require('./routes/openai');
+
+const usersRoutes = require('./routes/users');
+
+const subscriptionsRoutes = require('./routes/subscriptions');
+
+const token_profilesRoutes = require('./routes/token_profiles');
+
+const tokensRoutes = require('./routes/tokens');
+
+const rolesRoutes = require('./routes/roles');
+
+const permissionsRoutes = require('./routes/permissions');
+
+const organizationsRoutes = require('./routes/organizations');
+
+const getBaseUrl = (url) => {
+  if (!url) return '';
+  return url.endsWith('/api') ? url.slice(0, -4) : url;
+};
+
+const options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      version: '1.0.0',
+      title: 'reham',
+      description:
+        'reham Online REST API for Testing and Prototyping application. You can perform all major operations with your entities - create, delete and etc.',
+    },
+    servers: [
+      {
+        url: getBaseUrl(process.env.NEXT_PUBLIC_BACK_API) || config.swaggerUrl,
+        description: 'Development server',
+      },
+    ],
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: 'http',
+          scheme: 'bearer',
+          bearerFormat: 'JWT',
+        },
+      },
+      responses: {
+        UnauthorizedError: {
+          description: 'Access token is missing or invalid',
+        },
+      },
+    },
+    security: [
+      {
+        bearerAuth: [],
+      },
+    ],
+  },
+  apis: ['./src/routes/*.js'],
+};
+
+const specs = swaggerJsDoc(options);
+app.use(
+  '/api-docs',
+  function (req, res, next) {
+    swaggerUI.host =
+      getBaseUrl(process.env.NEXT_PUBLIC_BACK_API) || req.get('host');
+    next();
+  },
+  swaggerUI.serve,
+  swaggerUI.setup(specs),
+);
+
+app.use(cors({ origin: true }));
+require('./auth/auth');
+
+app.use(bodyParser.json());
+
+app.use('/api/auth', authRoutes);
+app.use('/api/file', fileRoutes);
+app.use('/api/pexels', pexelsRoutes);
+app.enable('trust proxy');
+
+app.use(
+  '/api/users',
+  passport.authenticate('jwt', { session: false }),
+  usersRoutes,
+);
+
+app.use(
+  '/api/subscriptions',
+  passport.authenticate('jwt', { session: false }),
+  subscriptionsRoutes,
+);
+
+app.use(
+  '/api/token_profiles',
+  passport.authenticate('jwt', { session: false }),
+  token_profilesRoutes,
+);
+
+app.use(
+  '/api/tokens',
+  passport.authenticate('jwt', { session: false }),
+  tokensRoutes,
+);
+
+app.use(
+  '/api/roles',
+  passport.authenticate('jwt', { session: false }),
+  rolesRoutes,
+);
+
+app.use(
+  '/api/permissions',
+  passport.authenticate('jwt', { session: false }),
+  permissionsRoutes,
+);
+
+app.use(
+  '/api/organizations',
+  passport.authenticate('jwt', { session: false }),
+  organizationsRoutes,
+);
+
+app.use(
+  '/api/openai',
+  passport.authenticate('jwt', { session: false }),
+  openaiRoutes,
+);
+
+app.use(
+  '/api/search',
+  passport.authenticate('jwt', { session: false }),
+  searchRoutes,
+);
+
+app.use('/api/org-for-auth', organizationForAuthRoutes);
+
+const publicDir = path.join(__dirname, '../public');
+
+if (fs.existsSync(publicDir)) {
+  app.use('/', express.static(publicDir));
+
+  app.get('*', function (request, response) {
+    response.sendFile(path.resolve(publicDir, 'index.html'));
+  });
+}
+
+const PORT = process.env.NODE_ENV === 'dev_stage' ? 3000 : 8080;
+
+db.sequelize.sync().then(function () {
+  app.listen(PORT, () => {
+    console.log(`Listening on port ${PORT}`);
+  });
+});
+
+module.exports = app;

backend/src/middlewares/check-permissions.js

@@ -0,0 +1,64 @@
+const ValidationError = require('../services/notifications/errors/validation');
+
+/**
+ * @param {string} permission
+ * @return {import("express").RequestHandler}
+ */
+function checkPermissions(permission) {
+  return (req, res, next) => {
+    const { currentUser } = req;
+    if (currentUser) {
+      if (currentUser.id === req.params.id || currentUser.id === req.body.id) {
+        next();
+        return;
+      }
+      const userPermission = currentUser.custom_permissions.find(
+        (cp) => cp.name === permission,
+      );
+
+      if (userPermission) {
+        next();
+      } else {
+        if (!currentUser.app_role) {
+          return next(new ValidationError('auth.forbidden'));
+        }
+        currentUser.app_role
+          .getPermissions()
+          .then((permissions) => {
+            if (permissions.find((p) => p.name === permission)) {
+              next();
+            } else {
+              next(new ValidationError('auth.forbidden'));
+            }
+          })
+          .catch((e) => next(e));
+      }
+    } else {
+      next(new ValidationError('auth.unauthorized'));
+    }
+  };
+}
+
+const METHOD_MAP = {
+  POST: 'CREATE',
+  GET: 'READ',
+  PUT: 'UPDATE',
+  PATCH: 'UPDATE',
+  DELETE: 'DELETE',
+};
+
+/**
+ * @param {string} name
+ * @return {import("express").RequestHandler}
+ */
+function checkCrudPermissions(name) {
+  return (req, res, next) => {
+    const permissionName = `${METHOD_MAP[req.method]}_${name.toUpperCase()}`;
+    checkPermissions(permissionName)(req, res, next);
+  };
+}
+
+module.exports = {
+  checkPermissions,
+  checkCrudPermissions,
+};

backend/src/middlewares/upload.js

@@ -0,0 +1,11 @@
+const util = require('util');
+const Multer = require('multer');
+const maxSize = 10 * 1024 * 1024;
+
+let processFile = Multer({
+  storage: Multer.memoryStorage(),
+  limits: { fileSize: maxSize },
+}).single('file');
+
+let processFileMiddleware = util.promisify(processFile);
+module.exports = processFileMiddleware;

backend/src/routes/auth.js

@@ -0,0 +1,270 @@
+const express = require('express');
+const passport = require('passport');
+
+const config = require('../config');
+const AuthService = require('../services/auth');
+const ForbiddenError = require('../services/notifications/errors/forbidden');
+const EmailSender = require('../services/email');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const router = express.Router();
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Auth:
+ *        type: object
+ *        required:
+ *          - email
+ *          - password
+ *        properties:
+ *          email:
+ *            type: string
+ *            default: admin@flatlogic.com
+ *            description: User email
+ *          password:
+ *            type: string
+ *            default: password
+ *            description: User password
+ */
+
+/**
+ * @swagger
+ * tags:
+ *   name: Auth
+ *   description: Authorization operations
+ */
+
+/**
+ * @swagger
+ *  /api/auth/signin/local:
+ *    post:
+ *      tags: [Auth]
+ *      summary: Logs user into the system
+ *      description: Logs user into the system
+ *      requestBody:
+ *        description: Set valid user email and password
+ *        content:
+ *          application/json:
+ *            schema:
+ *              $ref: "#/components/schemas/Auth"
+ *      responses:
+ *        200:
+ *          description: Successful login
+ *        400:
+ *          description: Invalid username/password supplied
+ *      x-codegen-request-body-name: body
+ */
+
+router.post(
+  '/signin/local',
+  wrapAsync(async (req, res) => {
+    const payload = await AuthService.signin(
+      req.body.email,
+      req.body.password,
+      req,
+    );
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/auth/me:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Auth]
+ *      summary: Get current authorized user info
+ *      description: Get current authorized user info
+ *      responses:
+ *        200:
+ *          description: Successful retrieval of current authorized user data
+ *        400:
+ *          description: Invalid username/password supplied
+ *      x-codegen-request-body-name: body
+ */
+
+router.get(
+  '/me',
+  passport.authenticate('jwt', { session: false }),
+  (req, res) => {
+    if (!req.currentUser || !req.currentUser.id) {
+      throw new ForbiddenError();
+    }
+
+    const payload = req.currentUser;
+    delete payload.password;
+    res.status(200).send(payload);
+  },
+);
+
+router.put(
+  '/password-reset',
+  wrapAsync(async (req, res) => {
+    const payload = await AuthService.passwordReset(
+      req.body.token,
+      req.body.password,
+      req,
+    );
+    res.status(200).send(payload);
+  }),
+);
+
+router.put(
+  '/password-update',
+  passport.authenticate('jwt', { session: false }),
+  wrapAsync(async (req, res) => {
+    const payload = await AuthService.passwordUpdate(
+      req.body.currentPassword,
+      req.body.newPassword,
+      req,
+    );
+    res.status(200).send(payload);
+  }),
+);
+
+router.post(
+  '/send-email-address-verification-email',
+  passport.authenticate('jwt', { session: false }),
+  wrapAsync(async (req, res) => {
+    if (!req.currentUser) {
+      throw new ForbiddenError();
+    }
+
+    await AuthService.sendEmailAddressVerificationEmail(req.currentUser.email);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+router.post(
+  '/send-password-reset-email',
+  wrapAsync(async (req, res) => {
+    const link = new URL(req.headers.referer);
+    await AuthService.sendPasswordResetEmail(
+      req.body.email,
+      'register',
+      link.host,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/auth/signup:
+ *    post:
+ *      tags: [Auth]
+ *      summary: Register new user into the system
+ *      description: Register new user into the system
+ *      requestBody:
+ *        description: Set valid user email and password
+ *        content:
+ *          application/json:
+ *            schema:
+ *              $ref: "#/components/schemas/Auth"
+ *      responses:
+ *        200:
+ *          description: New user successfully signed up
+ *        400:
+ *          description: Invalid username/password supplied
+ *        500:
+ *          description: Some server error
+ *      x-codegen-request-body-name: body
+ */
+
+router.post(
+  '/signup',
+  wrapAsync(async (req, res) => {
+    const link = new URL(req.headers.referer);
+    const payload = await AuthService.signup(
+      req.body.email,
+      req.body.password,
+
+      req.body.organizationId,
+
+      req,
+      link.host,
+    );
+    res.status(200).send(payload);
+  }),
+);
+
+router.put(
+  '/profile',
+  passport.authenticate('jwt', { session: false }),
+  wrapAsync(async (req, res) => {
+    if (!req.currentUser || !req.currentUser.id) {
+      throw new ForbiddenError();
+    }
+
+    await AuthService.updateProfile(req.body.profile, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+router.put(
+  '/verify-email',
+  wrapAsync(async (req, res) => {
+    const payload = await AuthService.verifyEmail(
+      req.body.token,
+      req,
+      req.headers.referer,
+    );
+    res.status(200).send(payload);
+  }),
+);
+
+router.get('/email-configured', (req, res) => {
+  const payload = EmailSender.isConfigured;
+  res.status(200).send(payload);
+});
+
+router.get('/signin/google', (req, res, next) => {
+  passport.authenticate('google', {
+    scope: ['profile', 'email'],
+    state: req.query.app,
+  })(req, res, next);
+});
+
+router.get(
+  '/signin/google/callback',
+  passport.authenticate('google', {
+    failureRedirect: '/login',
+    session: false,
+  }),
+
+  function (req, res) {
+    socialRedirect(res, req.query.state, req.user.token, config);
+  },
+);
+
+router.get('/signin/microsoft', (req, res, next) => {
+  passport.authenticate('microsoft', {
+    scope: ['https://graph.microsoft.com/user.read openid'],
+    state: req.query.app,
+  })(req, res, next);
+});
+
+router.get(
+  '/signin/microsoft/callback',
+  passport.authenticate('microsoft', {
+    failureRedirect: '/login',
+    session: false,
+  }),
+  function (req, res) {
+    socialRedirect(res, req.query.state, req.user.token, config);
+  },
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+function socialRedirect(res, state, token, config) {
+  res.redirect(config.uiUrl + '/login?token=' + token);
+}
+
+module.exports = router;

backend/src/routes/file.js

@@ -0,0 +1,40 @@
+const express = require('express');
+const config = require('../config');
+const path = require('path');
+const passport = require('passport');
+const services = require('../services/file');
+const router = express.Router();
+
+router.get('/download', (req, res) => {
+  if (
+    process.env.NODE_ENV == 'production' ||
+    process.env.NEXT_PUBLIC_BACK_API
+  ) {
+    services.downloadGCloud(req, res);
+  } else {
+    services.downloadLocal(req, res);
+  }
+});
+
+router.post(
+  '/upload/:table/:field',
+  passport.authenticate('jwt', { session: false }),
+  (req, res) => {
+    const fileName = `${req.params.table}/${req.params.field}`;
+
+    if (
+      process.env.NODE_ENV == 'production' ||
+      process.env.NEXT_PUBLIC_BACK_API
+    ) {
+      services.uploadGCloud(fileName, req, res);
+    } else {
+      services.uploadLocal(fileName, {
+        entity: null,
+        maxFileSize: 10 * 1024 * 1024,
+        folderIncludesAuthenticationUid: false,
+      })(req, res);
+    }
+  },
+);
+
+module.exports = router;

backend/src/routes/openai.js

@@ -0,0 +1,180 @@
+const express = require('express');
+const db = require('../db/models');
+const wrapAsync = require('../helpers').wrapAsync;
+const router = express.Router();
+const sjs = require('sequelize-json-schema');
+const { getWidget } = require('../services/openai');
+const RolesService = require('../services/roles');
+const RolesDBApi = require('../db/api/roles');
+
+/**
+ * @swagger
+ * /api/roles/roles-info/{infoId}:
+ *   delete:
+ *     security:
+ *       - bearerAuth: []
+ *     tags: [Roles]
+ *     summary: Remove role information by ID
+ *     description: Remove specific role information by ID
+ *     parameters:
+ *       - in: path
+ *         name: infoId
+ *         description: ID of role information to remove
+ *         required: true
+ *         schema:
+ *           type: string
+ *       - in: query
+ *         name: userId
+ *         description: ID of the user
+ *         required: true
+ *         schema:
+ *           type: string
+ *       - in: query
+ *         name: key
+ *         description: Key of the role information to remove
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: Role information successfully removed
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 user:
+ *                   type: string
+ *                   description: The user information
+ *       400:
+ *         description: Invalid ID or key supplied
+ *       401:
+ *         $ref: "#/components/responses/UnauthorizedError"
+ *       404:
+ *         description: Role not found
+ *       500:
+ *         description: Some server error
+ */
+
+router.delete(
+  '/roles-info/:infoId',
+  wrapAsync(async (req, res) => {
+    const role = await RolesService.removeRoleInfoById(
+      req.query.infoId,
+      req.query.roleId,
+      req.query.key,
+      req.currentUser,
+    );
+
+    res.status(200).send(role);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/roles/role-info/{roleId}:
+ *   get:
+ *     security:
+ *       - bearerAuth: []
+ *     tags: [Roles]
+ *     summary: Get role information by key
+ *     description: Get specific role information by key
+ *     parameters:
+ *       - in: path
+ *         name: roleId
+ *         description: ID of role to get information for
+ *         required: true
+ *         schema:
+ *           type: string
+ *       - in: query
+ *         name: key
+ *         description: Key of the role information to retrieve
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: Role information successfully received
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 info:
+ *                   type: string
+ *                   description: The role information
+ *       400:
+ *         description: Invalid ID or key supplied
+ *       401:
+ *         $ref: "#/components/responses/UnauthorizedError"
+ *       404:
+ *         description: Role not found
+ *       500:
+ *         description: Some server error
+ */
+
+router.get(
+  '/info-by-key',
+  wrapAsync(async (req, res) => {
+    const roleId = req.query.roleId;
+    const key = req.query.key;
+    const currentUser = req.currentUser;
+    let info = await RolesService.getRoleInfoByKey(key, roleId, currentUser);
+    const role = await RolesDBApi.findBy({ id: roleId });
+    if (!role?.role_customization) {
+      await Promise.all(
+        ['pie', 'bar'].map(async (e) => {
+          const schema = await sjs.getSequelizeSchema(db.sequelize, {});
+          const payload = {
+            description: `Create some cool ${e} chart`,
+            modelDefinition: schema.definitions,
+          };
+          const widgetId = await getWidget(payload, currentUser?.id, roleId);
+          if (widgetId) {
+            await RolesService.addRoleInfo(
+              roleId,
+              currentUser?.id,
+              'widgets',
+              widgetId,
+              req.currentUser,
+            );
+          }
+        }),
+      );
+      info = await RolesService.getRoleInfoByKey(key, roleId, currentUser);
+    }
+    res.status(200).send(info);
+  }),
+);
+
+router.post(
+  '/create_widget',
+  wrapAsync(async (req, res) => {
+    const { description, userId, roleId } = req.body;
+
+    const currentUser = req.currentUser;
+    const schema = await sjs.getSequelizeSchema(db.sequelize, {});
+    const payload = {
+      description,
+      modelDefinition: schema.definitions,
+    };
+
+    const widgetId = await getWidget(payload, userId, roleId);
+
+    if (widgetId) {
+      await RolesService.addRoleInfo(
+        roleId,
+        userId,
+        'widgets',
+        widgetId,
+        currentUser,
+      );
+
+      return res.status(200).send(widgetId);
+    } else {
+      return res.status(400).send(widgetId);
+    }
+  }),
+);
+
+module.exports = router;

backend/src/routes/organizationLogin.js

@@ -0,0 +1,46 @@
+const express = require('express');
+
+const OrganizationsDBApi = require('../db/api/organizations');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const router = express.Router();
+
+/**
+ *  @swagger
+ *  /api/organizations:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Organizations]
+ *      summary: Get all organizations
+ *      description: Get all organizations
+ *      responses:
+ *        200:
+ *          description: Organizations list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Organizations"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const payload = await OrganizationsDBApi.findAll(req.query);
+    const simplifiedPayload = payload.rows.map((org) => ({
+      id: org.id,
+      name: org.name,
+    }));
+    res.status(200).send(simplifiedPayload);
+  }),
+);
+
+module.exports = router;

backend/src/routes/organizations.js

@@ -0,0 +1,456 @@
+const express = require('express');
+
+const OrganizationsService = require('../services/organizations');
+const OrganizationsDBApi = require('../db/api/organizations');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('organizations'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Organizations:
+ *        type: object
+ *        properties:
+
+ *          name:
+ *            type: string
+ *            default: name
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Organizations
+ *   description: The Organizations managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/organizations:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Organizations]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Organizations"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Organizations"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await OrganizationsService.create(
+      req.body.data,
+      req.currentUser,
+      true,
+      link.host,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Organizations]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Organizations"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Organizations"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await OrganizationsService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/organizations/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Organizations]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Organizations"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Organizations"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await OrganizationsService.update(
+      req.body.data,
+      req.body.id,
+      req.currentUser,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/organizations/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Organizations]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Organizations"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await OrganizationsService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/organizations/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Organizations]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Organizations"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await OrganizationsService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/organizations:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Organizations]
+ *      summary: Get all organizations
+ *      description: Get all organizations
+ *      responses:
+ *        200:
+ *          description: Organizations list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Organizations"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await OrganizationsDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = ['id', 'name'];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/organizations/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Organizations]
+ *      summary: Count all organizations
+ *      description: Count all organizations
+ *      responses:
+ *        200:
+ *          description: Organizations count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Organizations"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await OrganizationsDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/organizations/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Organizations]
+ *      summary: Find all organizations that match search criteria
+ *      description: Find all organizations that match search criteria
+ *      responses:
+ *        200:
+ *          description: Organizations list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Organizations"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const organizationId = req.currentUser.organization?.id;
+
+  const payload = await OrganizationsDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/organizations/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Organizations]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Organizations"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await OrganizationsDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/routes/permissions.js

@@ -0,0 +1,442 @@
+const express = require('express');
+
+const PermissionsService = require('../services/permissions');
+const PermissionsDBApi = require('../db/api/permissions');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('permissions'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Permissions:
+ *        type: object
+ *        properties:
+
+ *          name:
+ *            type: string
+ *            default: name
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Permissions
+ *   description: The Permissions managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/permissions:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Permissions]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Permissions"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Permissions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await PermissionsService.create(
+      req.body.data,
+      req.currentUser,
+      true,
+      link.host,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Permissions]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Permissions"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Permissions"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await PermissionsService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/permissions/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Permissions]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Permissions"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Permissions"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await PermissionsService.update(
+      req.body.data,
+      req.body.id,
+      req.currentUser,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/permissions/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Permissions]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Permissions"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await PermissionsService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/permissions/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Permissions]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Permissions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await PermissionsService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/permissions:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Permissions]
+ *      summary: Get all permissions
+ *      description: Get all permissions
+ *      responses:
+ *        200:
+ *          description: Permissions list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Permissions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const currentUser = req.currentUser;
+    const payload = await PermissionsDBApi.findAll(req.query, { currentUser });
+    if (filetype && filetype === 'csv') {
+      const fields = ['id', 'name'];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/permissions/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Permissions]
+ *      summary: Count all permissions
+ *      description: Count all permissions
+ *      responses:
+ *        200:
+ *          description: Permissions count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Permissions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const currentUser = req.currentUser;
+    const payload = await PermissionsDBApi.findAll(req.query, null, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/permissions/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Permissions]
+ *      summary: Find all permissions that match search criteria
+ *      description: Find all permissions that match search criteria
+ *      responses:
+ *        200:
+ *          description: Permissions list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Permissions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const payload = await PermissionsDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/permissions/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Permissions]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Permissions"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await PermissionsDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/routes/pexels.js

@@ -0,0 +1,106 @@
+const express = require('express');
+const router = express.Router();
+const { pexelsKey, pexelsQuery } = require('../config');
+const fetch = require('node-fetch');
+
+const KEY = pexelsKey;
+
+router.get('/image', async (req, res) => {
+  const headers = {
+    Authorization: `${KEY}`,
+  };
+  const query = pexelsQuery || 'nature';
+  const orientation = 'portrait';
+  const perPage = 1;
+  const url = `https://api.pexels.com/v1/search?query=${query}&orientation=${orientation}&per_page=${perPage}&page=1`;
+
+  try {
+    const response = await fetch(url, { headers });
+    const data = await response.json();
+    res.status(200).json(data.photos[0]);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch image' });
+  }
+});
+
+router.get('/video', async (req, res) => {
+  const headers = {
+    Authorization: `${KEY}`,
+  };
+  const query = pexelsQuery || 'nature';
+  const orientation = 'portrait';
+  const perPage = 1;
+  const url = `https://api.pexels.com/videos/search?query=${query}&orientation=${orientation}&per_page=${perPage}&page=1`;
+
+  try {
+    const response = await fetch(url, { headers });
+    const data = await response.json();
+    res.status(200).json(data.videos[0]);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch video' });
+  }
+});
+
+router.get('/multiple-images', async (req, res) => {
+  const headers = {
+    Authorization: `${KEY}`,
+  };
+
+  const queries = req.query.queries
+    ? req.query.queries.split(',')
+    : ['home', 'apple', 'pizza', 'mountains', 'cat'];
+  const orientation = 'square';
+  const perPage = 1;
+
+  const fallbackImage = {
+    src: 'https://images.pexels.com/photos/8199252/pexels-photo-8199252.jpeg',
+    photographer: 'Yan Krukau',
+    photographer_url: 'https://www.pexels.com/@yankrukov',
+  };
+  const fetchFallbackImage = async () => {
+    try {
+      const response = await fetch('https://picsum.photos/600');
+      return {
+        src: response.url,
+        photographer: 'Random Picsum',
+        photographer_url: 'https://picsum.photos/',
+      };
+    } catch (error) {
+      return fallbackImage;
+    }
+  };
+  const fetchImage = async (query) => {
+    const url = `https://api.pexels.com/v1/search?query=${query}&orientation=${orientation}&per_page=${perPage}&page=1`;
+    const response = await fetch(url, { headers });
+    const data = await response.json();
+    return data.photos[0] || null;
+  };
+
+  const imagePromises = queries.map((query) => fetchImage(query));
+  const imagesResults = await Promise.allSettled(imagePromises);
+
+  const formattedImages = await Promise.all(
+    imagesResults.map(async (result) => {
+      if (result.status === 'fulfilled' && result.value) {
+        const image = result.value;
+        return {
+          src: image.src?.original || fallbackImage.src,
+          photographer: image.photographer || fallbackImage.photographer,
+          photographer_url:
+            image.photographer_url || fallbackImage.photographer_url,
+        };
+      } else {
+        const fallback = await fetchFallbackImage();
+        return {
+          src: fallback.src || '',
+          photographer: fallback.photographer || 'Unknown',
+          photographer_url: fallback.photographer_url || '',
+        };
+      }
+    }),
+  );
+
+  res.json(formattedImages);
+});
+
+module.exports = router;

backend/src/routes/roles.js

@@ -0,0 +1,444 @@
+const express = require('express');
+
+const RolesService = require('../services/roles');
+const RolesDBApi = require('../db/api/roles');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('roles'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Roles:
+ *        type: object
+ *        properties:
+
+ *          name:
+ *            type: string
+ *            default: name
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Roles
+ *   description: The Roles managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/roles:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Roles]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Roles"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Roles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await RolesService.create(req.body.data, req.currentUser, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Roles]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Roles"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Roles"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await RolesService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/roles/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Roles]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Roles"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Roles"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await RolesService.update(req.body.data, req.body.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/roles/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Roles]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Roles"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await RolesService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/roles/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Roles]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Roles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await RolesService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/roles:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Roles]
+ *      summary: Get all roles
+ *      description: Get all roles
+ *      responses:
+ *        200:
+ *          description: Roles list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Roles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await RolesDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = ['id', 'name'];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/roles/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Roles]
+ *      summary: Count all roles
+ *      description: Count all roles
+ *      responses:
+ *        200:
+ *          description: Roles count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Roles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await RolesDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/roles/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Roles]
+ *      summary: Find all roles that match search criteria
+ *      description: Find all roles that match search criteria
+ *      responses:
+ *        200:
+ *          description: Roles list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Roles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const payload = await RolesDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/roles/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Roles]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Roles"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await RolesDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/routes/search.js

@@ -0,0 +1,60 @@
+const express = require('express');
+const SearchService = require('../services/search');
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+router.use(checkCrudPermissions('search'));
+
+/**
+ * @swagger
+ * path:
+ *  /api/search:
+ *    post:
+ *      summary: Search
+ *      description: Search results across multiple tables
+ *      requestBody:
+ *        content:
+ *          application/json:
+ *            schema:
+ *              type: object
+ *              properties:
+ *                searchQuery:
+ *                  type: string
+ *              required:
+ *                - searchQuery
+ *      responses:
+ *        200:
+ *          description: Successful request
+ *        400:
+ *          description: Invalid request
+ *        500:
+ *          description: Internal server error
+ */
+
+router.post('/', async (req, res) => {
+  const { searchQuery, organizationId } = req.body;
+
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  if (!searchQuery) {
+    return res.status(400).json({ error: 'Please enter a search query' });
+  }
+
+  try {
+    const foundMatches = await SearchService.search(
+      searchQuery,
+      req.currentUser,
+      organizationId,
+      globalAccess,
+    );
+    res.json(foundMatches);
+  } catch (error) {
+    console.error('Internal Server Error', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+});
+
+module.exports = router;

backend/src/routes/subscriptions.js

@@ -0,0 +1,456 @@
+const express = require('express');
+
+const SubscriptionsService = require('../services/subscriptions');
+const SubscriptionsDBApi = require('../db/api/subscriptions');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('subscriptions'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Subscriptions:
+ *        type: object
+ *        properties:
+
+ *          price:
+ *            type: integer
+ *            format: int64
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Subscriptions
+ *   description: The Subscriptions managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/subscriptions:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Subscriptions]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Subscriptions"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Subscriptions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await SubscriptionsService.create(
+      req.body.data,
+      req.currentUser,
+      true,
+      link.host,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Subscriptions]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Subscriptions"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Subscriptions"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await SubscriptionsService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/subscriptions/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Subscriptions]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Subscriptions"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Subscriptions"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await SubscriptionsService.update(
+      req.body.data,
+      req.body.id,
+      req.currentUser,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/subscriptions/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Subscriptions]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Subscriptions"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await SubscriptionsService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/subscriptions/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Subscriptions]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Subscriptions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await SubscriptionsService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/subscriptions:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Subscriptions]
+ *      summary: Get all subscriptions
+ *      description: Get all subscriptions
+ *      responses:
+ *        200:
+ *          description: Subscriptions list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Subscriptions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await SubscriptionsDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = ['id', 'price', 'start_date', 'end_date'];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/subscriptions/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Subscriptions]
+ *      summary: Count all subscriptions
+ *      description: Count all subscriptions
+ *      responses:
+ *        200:
+ *          description: Subscriptions count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Subscriptions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await SubscriptionsDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/subscriptions/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Subscriptions]
+ *      summary: Find all subscriptions that match search criteria
+ *      description: Find all subscriptions that match search criteria
+ *      responses:
+ *        200:
+ *          description: Subscriptions list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Subscriptions"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const organizationId = req.currentUser.organization?.id;
+
+  const payload = await SubscriptionsDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/subscriptions/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Subscriptions]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Subscriptions"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await SubscriptionsDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/routes/token_profiles.js

@@ -0,0 +1,456 @@
+const express = require('express');
+
+const Token_profilesService = require('../services/token_profiles');
+const Token_profilesDBApi = require('../db/api/token_profiles');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('token_profiles'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Token_profiles:
+ *        type: object
+ *        properties:
+
+ *          description:
+ *            type: string
+ *            default: description
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Token_profiles
+ *   description: The Token_profiles managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/token_profiles:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Token_profiles]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Token_profiles"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Token_profiles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await Token_profilesService.create(
+      req.body.data,
+      req.currentUser,
+      true,
+      link.host,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Token_profiles]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Token_profiles"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Token_profiles"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await Token_profilesService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/token_profiles/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Token_profiles]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Token_profiles"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Token_profiles"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await Token_profilesService.update(
+      req.body.data,
+      req.body.id,
+      req.currentUser,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/token_profiles/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Token_profiles]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Token_profiles"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await Token_profilesService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/token_profiles/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Token_profiles]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Token_profiles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await Token_profilesService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/token_profiles:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Token_profiles]
+ *      summary: Get all token_profiles
+ *      description: Get all token_profiles
+ *      responses:
+ *        200:
+ *          description: Token_profiles list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Token_profiles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await Token_profilesDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = ['id', 'description'];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/token_profiles/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Token_profiles]
+ *      summary: Count all token_profiles
+ *      description: Count all token_profiles
+ *      responses:
+ *        200:
+ *          description: Token_profiles count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Token_profiles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await Token_profilesDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/token_profiles/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Token_profiles]
+ *      summary: Find all token_profiles that match search criteria
+ *      description: Find all token_profiles that match search criteria
+ *      responses:
+ *        200:
+ *          description: Token_profiles list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Token_profiles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const organizationId = req.currentUser.organization?.id;
+
+  const payload = await Token_profilesDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/token_profiles/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Token_profiles]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Token_profiles"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await Token_profilesDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/routes/tokens.js

@@ -0,0 +1,466 @@
+const express = require('express');
+
+const TokensService = require('../services/tokens');
+const TokensDBApi = require('../db/api/tokens');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('tokens'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Tokens:
+ *        type: object
+ *        properties:
+
+ *          name:
+ *            type: string
+ *            default: name
+ *          symbol:
+ *            type: string
+ *            default: symbol
+
+ *          market_cap:
+ *            type: integer
+ *            format: int64
+ *          price:
+ *            type: integer
+ *            format: int64
+
+ *          
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Tokens
+ *   description: The Tokens managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/tokens:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Tokens]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Tokens"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Tokens"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await TokensService.create(req.body.data, req.currentUser, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Tokens]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Tokens"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Tokens"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await TokensService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/tokens/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Tokens]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Tokens"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Tokens"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await TokensService.update(req.body.data, req.body.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/tokens/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Tokens]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Tokens"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await TokensService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/tokens/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Tokens]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Tokens"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await TokensService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/tokens:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Tokens]
+ *      summary: Get all tokens
+ *      description: Get all tokens
+ *      responses:
+ *        200:
+ *          description: Tokens list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Tokens"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await TokensDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = [
+        'id',
+        'name',
+        'symbol',
+
+        'market_cap',
+        'price',
+        'launch_date',
+      ];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/tokens/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Tokens]
+ *      summary: Count all tokens
+ *      description: Count all tokens
+ *      responses:
+ *        200:
+ *          description: Tokens count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Tokens"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await TokensDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/tokens/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Tokens]
+ *      summary: Find all tokens that match search criteria
+ *      description: Find all tokens that match search criteria
+ *      responses:
+ *        200:
+ *          description: Tokens list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Tokens"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const organizationId = req.currentUser.organization?.id;
+
+  const payload = await TokensDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/tokens/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Tokens]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Tokens"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await TokensDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/routes/users.js

@@ -0,0 +1,458 @@
+const express = require('express');
+
+const UsersService = require('../services/users');
+const UsersDBApi = require('../db/api/users');
+const wrapAsync = require('../helpers').wrapAsync;
+
+const config = require('../config');
+
+const router = express.Router();
+
+const { parse } = require('json2csv');
+
+const { checkCrudPermissions } = require('../middlewares/check-permissions');
+
+router.use(checkCrudPermissions('users'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Users:
+ *        type: object
+ *        properties:
+
+ *          firstName:
+ *            type: string
+ *            default: firstName
+ *          lastName:
+ *            type: string
+ *            default: lastName
+ *          phoneNumber:
+ *            type: string
+ *            default: phoneNumber
+ *          email:
+ *            type: string
+ *            default: email
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Users
+ *   description: The Users managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/users:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Users]
+ *      summary: Add new item
+ *      description: Add new item
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Users"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Users"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        405:
+ *          description: Invalid input data
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await UsersService.create(req.body.data, req.currentUser, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ * /api/budgets/bulk-import:
+ *  post:
+ *    security:
+ *      - bearerAuth: []
+ *    tags: [Users]
+ *    summary: Bulk import items
+ *    description: Bulk import items
+ *    requestBody:
+ *      required: true
+ *      content:
+ *        application/json:
+ *         schema:
+ *          properties:
+ *            data:
+ *              description: Data of the updated items
+ *              type: array
+ *              items:
+ *                $ref: "#/components/schemas/Users"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Users"
+ *      401:
+ *        $ref: "#/components/responses/UnauthorizedError"
+ *      405:
+ *        description: Invalid input data
+ *      500:
+ *        description: Some server error
+ *
+ */
+router.post(
+  '/bulk-import',
+  wrapAsync(async (req, res) => {
+    const referer =
+      req.headers.referer ||
+      `${req.protocol}://${req.hostname}${req.originalUrl}`;
+    const link = new URL(referer);
+    await UsersService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/users/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Users]
+ *      summary: Update the data of the selected item
+ *      description: Update the data of the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to update
+ *          required: true
+ *          schema:
+ *            type: string
+ *      requestBody:
+ *        description: Set new item data
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                id:
+ *                  description: ID of the updated item
+ *                  type: string
+ *                data:
+ *                  description: Data of the updated item
+ *                  type: object
+ *                  $ref: "#/components/schemas/Users"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Users"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.put(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await UsersService.update(req.body.data, req.body.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/users/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Users]
+ *      summary: Delete the selected item
+ *      description: Delete the selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: Item ID to delete
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: The item was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Users"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.delete(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    await UsersService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/users/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Users]
+ *      summary: Delete the selected item list
+ *      description: Delete the selected item list
+ *      requestBody:
+ *        required: true
+ *        content:
+ *          application/json:
+ *            schema:
+ *              properties:
+ *                ids:
+ *                  description: IDs of the updated items
+ *                  type: array
+ *      responses:
+ *        200:
+ *          description: The items was successfully deleted
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Users"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await UsersService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/users:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Users]
+ *      summary: Get all users
+ *      description: Get all users
+ *      responses:
+ *        200:
+ *          description: Users list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Users"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/',
+  wrapAsync(async (req, res) => {
+    const filetype = req.query.filetype;
+
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await UsersDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = ['id', 'firstName', 'lastName', 'phoneNumber', 'email'];
+      const opts = { fields };
+      try {
+        const csv = parse(payload.rows, opts);
+        res.status(200).attachment(csv);
+        res.send(csv);
+      } catch (err) {
+        console.error(err);
+      }
+    } else {
+      res.status(200).send(payload);
+    }
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/users/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Users]
+ *      summary: Count all users
+ *      description: Count all users
+ *      responses:
+ *        200:
+ *          description: Users count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Users"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/count',
+  wrapAsync(async (req, res) => {
+    const globalAccess = req.currentUser.app_role.globalAccess;
+
+    const currentUser = req.currentUser;
+    const payload = await UsersDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/users/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Users]
+ *      summary: Find all users that match search criteria
+ *      description: Find all users that match search criteria
+ *      responses:
+ *        200:
+ *          description: Users list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Users"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Data not found
+ *        500:
+ *          description: Some server error
+ */
+router.get('/autocomplete', async (req, res) => {
+  const globalAccess = req.currentUser.app_role.globalAccess;
+
+  const organizationId = req.currentUser.organization?.id;
+
+  const payload = await UsersDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/users/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Users]
+ *      summary: Get selected item
+ *      description: Get selected item
+ *      parameters:
+ *        - in: path
+ *          name: id
+ *          description: ID of item to get
+ *          required: true
+ *          schema:
+ *            type: string
+ *      responses:
+ *        200:
+ *          description: Selected item successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Users"
+ *        400:
+ *          description: Invalid ID supplied
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Item not found
+ *        500:
+ *          description: Some server error
+ */
+router.get(
+  '/:id',
+  wrapAsync(async (req, res) => {
+    const payload = await UsersDBApi.findBy({ id: req.params.id });
+
+    delete payload.password;
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;

backend/src/services/auth.js

@@ -0,0 +1,228 @@
+const UsersDBApi = require('../db/api/users');
+const ValidationError = require('./notifications/errors/validation');
+const ForbiddenError = require('./notifications/errors/forbidden');
+const bcrypt = require('bcrypt');
+const EmailAddressVerificationEmail = require('./email/list/addressVerification');
+const InvitationEmail = require('./email/list/invitation');
+const PasswordResetEmail = require('./email/list/passwordReset');
+const EmailSender = require('./email');
+const config = require('../config');
+const helpers = require('../helpers');
+
+class Auth {
+  static async signup(email, password, organizationId, options = {}, host) {
+    const user = await UsersDBApi.findBy({ email });
+
+    const hashedPassword = await bcrypt.hash(
+      password,
+      config.bcrypt.saltRounds,
+    );
+
+    if (user) {
+      if (user.authenticationUid) {
+        throw new ValidationError('auth.emailAlreadyInUse');
+      }
+
+      if (user.disabled) {
+        throw new ValidationError('auth.userDisabled');
+      }
+
+      await UsersDBApi.updatePassword(user.id, hashedPassword, options);
+
+      if (EmailSender.isConfigured) {
+        await this.sendEmailAddressVerificationEmail(user.email, host);
+      }
+
+      const data = {
+        user: {
+          id: user.id,
+          email: user.email,
+        },
+      };
+
+      return helpers.jwtSign(data);
+    }
+
+    const newUser = await UsersDBApi.createFromAuth(
+      {
+        firstName: email.split('@')[0],
+        password: hashedPassword,
+        email: email,
+
+        organizationId: organizationId,
+      },
+      options,
+    );
+
+    if (EmailSender.isConfigured) {
+      await this.sendEmailAddressVerificationEmail(newUser.email, host);
+    }
+
+    const data = {
+      user: {
+        id: newUser.id,
+        email: newUser.email,
+      },
+    };
+
+    return helpers.jwtSign(data);
+  }
+
+  static async signin(email, password, options = {}) {
+    const user = await UsersDBApi.findBy({ email });
+
+    if (!user) {
+      throw new ValidationError('auth.userNotFound');
+    }
+
+    if (user.disabled) {
+      throw new ValidationError('auth.userDisabled');
+    }
+
+    if (!user.password) {
+      throw new ValidationError('auth.wrongPassword');
+    }
+
+    if (!EmailSender.isConfigured) {
+      user.emailVerified = true;
+    }
+
+    if (!user.emailVerified) {
+      throw new ValidationError('auth.userNotVerified');
+    }
+
+    const passwordsMatch = await bcrypt.compare(password, user.password);
+
+    if (!passwordsMatch) {
+      throw new ValidationError('auth.wrongPassword');
+    }
+
+    const data = {
+      user: {
+        id: user.id,
+        email: user.email,
+      },
+    };
+
+    return helpers.jwtSign(data);
+  }
+
+  static async sendEmailAddressVerificationEmail(email, host) {
+    let link;
+    try {
+      const token = await UsersDBApi.generateEmailVerificationToken(email);
+      link = `${host}/verify-email?token=${token}`;
+    } catch (error) {
+      console.error(error);
+      throw new ValidationError('auth.emailAddressVerificationEmail.error');
+    }
+
+    const emailAddressVerificationEmail = new EmailAddressVerificationEmail(
+      email,
+      link,
+    );
+
+    return new EmailSender(emailAddressVerificationEmail).send();
+  }
+
+  static async sendPasswordResetEmail(email, type = 'register', host) {
+    let link;
+
+    try {
+      const token = await UsersDBApi.generatePasswordResetToken(email);
+      link = `${host}/password-reset?token=${token}`;
+    } catch (error) {
+      console.error(error);
+      throw new ValidationError('auth.passwordReset.error');
+    }
+
+    let passwordResetEmail;
+    if (type === 'register') {
+      passwordResetEmail = new PasswordResetEmail(email, link);
+    }
+    if (type === 'invitation') {
+      passwordResetEmail = new InvitationEmail(email, link);
+    }
+
+    return new EmailSender(passwordResetEmail).send();
+  }
+
+  static async verifyEmail(token, options = {}) {
+    const user = await UsersDBApi.findByEmailVerificationToken(token, options);
+
+    if (!user) {
+      throw new ValidationError(
+        'auth.emailAddressVerificationEmail.invalidToken',
+      );
+    }
+
+    return UsersDBApi.markEmailVerified(user.id, options);
+  }
+
+  static async passwordUpdate(currentPassword, newPassword, options) {
+    const currentUser = options.currentUser || null;
+    if (!currentUser) {
+      throw new ForbiddenError();
+    }
+
+    const currentPasswordMatch = await bcrypt.compare(
+      currentPassword,
+      currentUser.password,
+    );
+
+    if (!currentPasswordMatch) {
+      throw new ValidationError('auth.wrongPassword');
+    }
+
+    const newPasswordMatch = await bcrypt.compare(
+      newPassword,
+      currentUser.password,
+    );
+
+    if (newPasswordMatch) {
+      throw new ValidationError('auth.passwordUpdate.samePassword');
+    }
+
+    const hashedPassword = await bcrypt.hash(
+      newPassword,
+      config.bcrypt.saltRounds,
+    );
+
+    return UsersDBApi.updatePassword(currentUser.id, hashedPassword, options);
+  }
+
+  static async passwordReset(token, password, options = {}) {
+    const user = await UsersDBApi.findByPasswordResetToken(token, options);
+
+    if (!user) {
+      throw new ValidationError('auth.passwordReset.invalidToken');
+    }
+
+    const hashedPassword = await bcrypt.hash(
+      password,
+      config.bcrypt.saltRounds,
+    );
+
+    return UsersDBApi.updatePassword(user.id, hashedPassword, options);
+  }
+
+  static async updateProfile(data, currentUser) {
+    let transaction = await db.sequelize.transaction();
+
+    try {
+      await UsersDBApi.findBy({ id: currentUser.id }, { transaction });
+
+      await UsersDBApi.update(currentUser.id, data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+}
+
+module.exports = Auth;

backend/src/services/email/htmlTemplates/addressVerification/emailAddressVerification.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      .email-container {
+        max-width: 600px;
+        margin: auto;
+        background-color: #ffffff;
+        border: 1px solid #e2e8f0;
+        border-radius: 4px;
+        overflow: hidden;
+      }
+      .email-header {
+        background-color: #3498db;
+        color: #fff;
+        padding: 16px;
+        text-align: center;
+      }
+      .email-body {
+        padding: 16px;
+      }
+      .email-footer {
+        padding: 16px;
+        background-color: #f7fafc;
+        text-align: center;
+        color: #4a5568;
+        font-size: 14px;
+      }
+      .link-primary {
+        color: #3498db;
+        text-decoration: none;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="email-container">
+      <div class="email-header">Verify your email for {appTitle}!</div>
+      <div class="email-body">
+        <p>Hello,</p>
+        <p>Follow this link to verify your email address.</p>
+        <p>
+          If you didn't ask to verify this address, you can ignore this email.
+        </p>
+        <p><a href="{signupUrl}" class="link-primary">{signupUrl}</a></p>
+      </div>
+      <div class="email-footer">
+        Thanks,<br />
+        The {appTitle} Team
+      </div>
+    </div>
+  </body>
+</html>

backend/src/services/email/htmlTemplates/invitation/invitationTemplate.html

@@ -0,0 +1,56 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      .email-container {
+        max-width: 600px;
+        margin: auto;
+        background-color: #ffffff;
+        border: 1px solid #e2e8f0;
+        border-radius: 4px;
+        overflow: hidden;
+      }
+      .email-header {
+        background-color: #3498db;
+        color: #fff;
+        padding: 16px;
+        text-align: center;
+      }
+      .email-body {
+        padding: 16px;
+      }
+      .email-footer {
+        padding: 16px;
+        background-color: #f7fafc;
+        text-align: center;
+        color: #4a5568;
+        font-size: 14px;
+      }
+      .btn-primary {
+        background-color: #3498db;
+        color: #fff !important;
+        padding: 8px 16px;
+        border-radius: 4px;
+        text-decoration: none;
+        display: inline-block;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="email-container">
+      <div class="email-header">Welcome to {appTitle}!</div>
+      <div class="email-body">
+        <p>Hello,</p>
+        <p>
+          You've been invited to join {appTitle}. Please click the button below
+          to set up your account.
+        </p>
+        <a href="{signupUrl}" class="btn-primary">Set up account</a>
+      </div>
+      <div class="email-footer">
+        Thanks,<br />
+        The {appTitle} Team
+      </div>
+    </div>
+  </body>
+</html>

backend/src/services/email/htmlTemplates/passwordReset/passwordResetEmail.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      .email-container {
+        max-width: 600px;
+        margin: auto;
+        background-color: #ffffff;
+        border: 1px solid #e2e8f0;
+        border-radius: 4px;
+        overflow: hidden;
+      }
+      .email-header {
+        background-color: #3498db;
+        color: #fff;
+        padding: 16px;
+        text-align: center;
+      }
+      .email-body {
+        padding: 16px;
+      }
+      .email-footer {
+        padding: 16px;
+        background-color: #f7fafc;
+        text-align: center;
+        color: #4a5568;
+        font-size: 14px;
+      }
+      .link-primary {
+        color: #3498db;
+        text-decoration: none;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="email-container">
+      <div class="email-header">Reset your password for {appTitle}</div>
+      <div class="email-body">
+        <p>Hello,</p>
+        <p>
+          Follow this link to reset your {appTitle} password for your
+          {accountName} account.
+        </p>
+        <p><a href="{resetUrl}" class="link-primary">{resetUrl}</a></p>
+        <p>
+          If you didn't ask to reset your password, you can ignore this email.
+        </p>
+      </div>
+      <div class="email-footer">
+        Thanks,<br />
+        The {appTitle} Team
+      </div>
+    </div>
+  </body>
+</html>

backend/src/services/email/index.js

@@ -0,0 +1,41 @@
+const config = require('../../config');
+const assert = require('assert');
+const nodemailer = require('nodemailer');
+
+module.exports = class EmailSender {
+  constructor(email) {
+    this.email = email;
+  }
+
+  async send() {
+    assert(this.email, 'email is required');
+    assert(this.email.to, 'email.to is required');
+    assert(this.email.subject, 'email.subject is required');
+    assert(this.email.html, 'email.html is required');
+
+    const htmlContent = await this.email.html();
+
+    const transporter = nodemailer.createTransport(this.transportConfig);
+
+    const mailOptions = {
+      from: this.from,
+      to: this.email.to,
+      subject: this.email.subject,
+      html: htmlContent,
+    };
+
+    return transporter.sendMail(mailOptions);
+  }
+
+  static get isConfigured() {
+    return !!config.email?.auth?.pass && !!config.email?.auth?.user;
+  }
+
+  get transportConfig() {
+    return config.email;
+  }
+
+  get from() {
+    return config.email.from;
+  }
+};

backend/src/services/email/list/addressVerification.js

@@ -0,0 +1,41 @@
+const { getNotification } = require('../../notifications/helpers');
+const fs = require('fs').promises;
+const path = require('path');
+
+module.exports = class EmailAddressVerificationEmail {
+  constructor(to, link) {
+    this.to = to;
+    this.link = link;
+  }
+
+  get subject() {
+    return getNotification(
+      'emails.emailAddressVerification.subject',
+      getNotification('app.title'),
+    );
+  }
+
+  async html() {
+    try {
+      const templatePath = path.join(
+        __dirname,
+        '../../email/htmlTemplates/addressVerification/emailAddressVerification.html',
+      );
+
+      const template = await fs.readFile(templatePath, 'utf8');
+
+      const appTitle = getNotification('app.title');
+      const signupUrl = this.link;
+
+      let html = template
+        .replace(/{appTitle}/g, appTitle)
+        .replace(/{signupUrl}/g, signupUrl)
+        .replace(/{to}/g, this.to);
+
+      return html;
+    } catch (error) {
+      console.error('Error generating invitation email HTML:', error);
+      throw error;
+    }
+  }
+};

backend/src/services/email/list/invitation.js

@@ -0,0 +1,41 @@
+const fs = require('fs').promises;
+const path = require('path');
+const { getNotification } = require('../../notifications/helpers');
+
+module.exports = class InvitationEmail {
+  constructor(to, host) {
+    this.to = to;
+    this.host = host;
+  }
+
+  get subject() {
+    return getNotification(
+      'emails.invitation.subject',
+      getNotification('app.title'),
+    );
+  }
+
+  async html() {
+    try {
+      const templatePath = path.join(
+        __dirname,
+        '../../email/htmlTemplates/invitation/invitationTemplate.html',
+      );
+
+      const template = await fs.readFile(templatePath, 'utf8');
+
+      const appTitle = getNotification('app.title');
+      const signupUrl = `${this.host}&invitation=true`;
+
+      let html = template
+        .replace(/{appTitle}/g, appTitle)
+        .replace(/{signupUrl}/g, signupUrl)
+        .replace(/{to}/g, this.to);
+
+      return html;
+    } catch (error) {
+      console.error('Error generating invitation email HTML:', error);
+      throw error;
+    }
+  }
+};

backend/src/services/email/list/passwordReset.js

@@ -0,0 +1,42 @@
+const { getNotification } = require('../../notifications/helpers');
+const path = require('path');
+const { promises: fs } = require('fs');
+
+module.exports = class PasswordResetEmail {
+  constructor(to, link) {
+    this.to = to;
+    this.link = link;
+  }
+
+  get subject() {
+    return getNotification(
+      'emails.passwordReset.subject',
+      getNotification('app.title'),
+    );
+  }
+
+  async html() {
+    try {
+      const templatePath = path.join(
+        __dirname,
+        '../../email/htmlTemplates/passwordReset/passwordResetEmail.html',
+      );
+
+      const template = await fs.readFile(templatePath, 'utf8');
+
+      const appTitle = getNotification('app.title');
+      const resetUrl = this.link;
+      const accountName = this.to;
+
+      let html = template
+        .replace(/{appTitle}/g, appTitle)
+        .replace(/{resetUrl}/g, resetUrl)
+        .replace(/{accountName}/g, accountName);
+
+      return html;
+    } catch (error) {
+      console.error('Error generating invitation email HTML:', error);
+      throw error;
+    }
+  }
+};

backend/src/services/file.js

@@ -0,0 +1,202 @@
+const formidable = require('formidable');
+const fs = require('fs');
+const config = require('../config');
+const path = require('path');
+const { format } = require('util');
+
+const ensureDirectoryExistence = (filePath) => {
+  const dirname = path.dirname(filePath);
+
+  if (fs.existsSync(dirname)) {
+    return true;
+  }
+
+  ensureDirectoryExistence(dirname);
+  fs.mkdirSync(dirname);
+};
+
+const uploadLocal = (
+  folder,
+  validations = {
+    entity: null,
+    maxFileSize: null,
+    folderIncludesAuthenticationUid: false,
+  },
+) => {
+  return (req, res) => {
+    if (!req.currentUser) {
+      res.sendStatus(403);
+      return;
+    }
+
+    if (validations.entity) {
+      res.sendStatus(403);
+      return;
+    }
+
+    if (validations.folderIncludesAuthenticationUid) {
+      folder = folder.replace(':userId', req.currentUser.authenticationUid);
+      if (
+        !req.currentUser.authenticationUid ||
+        !folder.includes(req.currentUser.authenticationUid)
+      ) {
+        res.sendStatus(403);
+        return;
+      }
+    }
+
+    const form = new formidable.IncomingForm();
+    form.uploadDir = config.uploadDir;
+
+    if (validations && validations.maxFileSize) {
+      form.maxFileSize = validations.maxFileSize;
+    }
+
+    form.parse(req, function (err, fields, files) {
+      const filename = String(fields.filename);
+      const fileTempUrl = files.file.path;
+
+      if (!filename) {
+        fs.unlinkSync(fileTempUrl);
+        res.sendStatus(500);
+        return;
+      }
+
+      const privateUrl = path.join(form.uploadDir, folder, filename);
+      ensureDirectoryExistence(privateUrl);
+      fs.renameSync(fileTempUrl, privateUrl);
+      res.sendStatus(200);
+    });
+
+    form.on('error', function (err) {
+      res.status(500).send(err);
+    });
+  };
+};
+
+const downloadLocal = async (req, res) => {
+  const privateUrl = req.query.privateUrl;
+  if (!privateUrl) {
+    return res.sendStatus(404);
+  }
+  res.download(path.join(config.uploadDir, privateUrl));
+};
+
+const initGCloud = () => {
+  const processFile = require('../middlewares/upload');
+  const { Storage } = require('@google-cloud/storage');
+
+  const crypto = require('crypto');
+  const hash = config.gcloud.hash;
+
+  const privateKey = process.env.GC_PRIVATE_KEY.replace(/\\\n/g, '\n');
+
+  const storage = new Storage({
+    projectId: process.env.GC_PROJECT_ID,
+    credentials: {
+      client_email: process.env.GC_CLIENT_EMAIL,
+      private_key: privateKey,
+    },
+  });
+
+  const bucket = storage.bucket(config.gcloud.bucket);
+  return { hash, bucket, processFile };
+};
+
+const uploadGCloud = async (folder, req, res) => {
+  try {
+    const { hash, bucket, processFile } = initGCloud();
+    await processFile(req, res);
+    let buffer = await req.file.buffer;
+    let filename = await req.body.filename;
+
+    if (!req.file) {
+      return res.status(400).send({ message: 'Please upload a file!' });
+    }
+
+    let path = `${hash}/${folder}/${filename}`;
+    let blob = bucket.file(path);
+
+    console.log(path);
+
+    const blobStream = blob.createWriteStream({
+      resumable: false,
+    });
+
+    blobStream.on('error', (err) => {
+      console.log('Upload error');
+      console.log(err.message);
+      res.status(500).send({ message: err.message });
+    });
+
+    console.log(`https://storage.googleapis.com/${bucket.name}/${blob.name}`);
+
+    blobStream.on('finish', async (data) => {
+      const publicUrl = format(
+        `https://storage.googleapis.com/${bucket.name}/${blob.name}`,
+      );
+
+      res.status(200).send({
+        message: 'Uploaded the file successfully: ' + path,
+        url: publicUrl,
+      });
+    });
+
+    blobStream.end(buffer);
+  } catch (err) {
+    console.log(err);
+
+    res.status(500).send({
+      message: `Could not upload the file. ${err}`,
+    });
+  }
+};
+
+const downloadGCloud = async (req, res) => {
+  try {
+    const { hash, bucket, processFile } = initGCloud();
+
+    const privateUrl = await req.query.privateUrl;
+    const filePath = `${hash}/${privateUrl}`;
+    const file = bucket.file(filePath);
+    const fileExists = await file.exists();
+
+    if (fileExists[0]) {
+      const stream = file.createReadStream();
+      stream.pipe(res);
+    } else {
+      res.status(404).send({
+        message: 'Could not download the file. ' + err,
+      });
+    }
+  } catch (err) {
+    res.status(404).send({
+      message: 'Could not download the file. ' + err,
+    });
+  }
+};
+
+const deleteGCloud = async (privateUrl) => {
+  try {
+    const { hash, bucket, processFile } = initGCloud();
+    const filePath = `${hash}/${privateUrl}`;
+
+    const file = bucket.file(filePath);
+    const fileExists = await file.exists();
+
+    if (fileExists[0]) {
+      file.delete();
+    }
+  } catch (err) {
+    console.log(`Cannot find the file ${privateUrl}`);
+  }
+};
+
+module.exports = {
+  initGCloud,
+  uploadLocal,
+  downloadLocal,
+  deleteGCloud,
+  uploadGCloud,
+  downloadGCloud,
+};

backend/src/services/notifications/errors/forbidden.js

@@ -0,0 +1,16 @@
+const { getNotification, isNotification } = require('../helpers');
+
+module.exports = class ForbiddenError extends Error {
+  constructor(messageCode) {
+    let message;
+
+    if (messageCode && isNotification(messageCode)) {
+      message = getNotification(messageCode);
+    }
+
+    message = message || getNotification('errors.forbidden.message');
+
+    super(message);
+    this.code = 403;
+  }
+};

backend/src/services/notifications/errors/validation.js

@@ -0,0 +1,16 @@
+const { getNotification, isNotification } = require('../helpers');
+
+module.exports = class ValidationError extends Error {
+  constructor(messageCode) {
+    let message;
+
+    if (messageCode && isNotification(messageCode)) {
+      message = getNotification(messageCode);
+    }
+
+    message = message || getNotification('errors.validation.message');
+
+    super(message);
+    this.code = 400;
+  }
+};

backend/src/services/notifications/helpers.js

@@ -0,0 +1,30 @@
+const _get = require('lodash/get');
+const errors = require('./list');
+
+function format(message, args) {
+  if (!message) {
+    return null;
+  }
+
+  return message.replace(/{(\d+)}/g, function (match, number) {
+    return typeof args[number] != 'undefined' ? args[number] : match;
+  });
+}
+
+const isNotification = (key) => {
+  const message = _get(errors, key);
+  return !!message;
+};
+
+const getNotification = (key, ...args) => {
+  const message = _get(errors, key);
+
+  if (!message) {
+    return key;
+  }
+
+  return format(message, args);
+};
+
+exports.getNotification = getNotification;
+exports.isNotification = isNotification;

backend/src/services/notifications/list.js

@@ -0,0 +1,100 @@
+const errors = {
+  app: {
+    title: 'reham',
+  },
+
+  auth: {
+    userDisabled: 'Your account is disabled',
+    forbidden: 'Forbidden',
+    unauthorized: 'Unauthorized',
+    userNotFound: `Sorry, we don't recognize your credentials`,
+    wrongPassword: `Sorry, we don't recognize your credentials`,
+    weakPassword: 'This password is too weak',
+    emailAlreadyInUse: 'Email is already in use',
+    invalidEmail: 'Please provide a valid email',
+    passwordReset: {
+      invalidToken: 'Password reset link is invalid or has expired',
+      error: `Email not recognized`,
+    },
+    passwordUpdate: {
+      samePassword: `You can't use the same password. Please create new password`,
+    },
+    userNotVerified: `Sorry, your email has not been verified yet`,
+    emailAddressVerificationEmail: {
+      invalidToken: 'Email verification link is invalid or has expired',
+      error: `Email not recognized`,
+    },
+  },
+
+  iam: {
+    errors: {
+      userAlreadyExists: 'User with this email already exists',
+      userNotFound: 'User not found',
+      disablingHimself: `You can't disable yourself`,
+      revokingOwnPermission: `You can't revoke your own owner permission`,
+      deletingHimself: `You can't delete yourself`,
+      emailRequired: 'Email is required',
+    },
+  },
+
+  importer: {
+    errors: {
+      invalidFileEmpty: 'The file is empty',
+      invalidFileExcel: 'Only excel (.xlsx) files are allowed',
+      invalidFileUpload:
+        'Invalid file. Make sure you are using the last version of the template.',
+      importHashRequired: 'Import hash is required',
+      importHashExistent: 'Data has already been imported',
+      userEmailMissing: 'Some items in the CSV do not have an email',
+    },
+  },
+
+  errors: {
+    forbidden: {
+      message: 'Forbidden',
+    },
+    validation: {
+      message: 'An error occurred',
+    },
+    searchQueryRequired: {
+      message: 'Search query is required',
+    },
+  },
+
+  emails: {
+    invitation: {
+      subject: `You've been invited to {0}`,
+      body: `    
+        <p>Hello,</p>
+        <p>You've been invited to {0} set password for your {1} account.</p>
+        <p><a href='{2}'>{2}</a></p>
+        <p>Thanks,</p>
+        <p>Your {0} team</p>
+      `,
+    },
+    emailAddressVerification: {
+      subject: `Verify your email for {0}`,
+      body: `
+        <p>Hello,</p>
+        <p>Follow this link to verify your email address.</p>
+        <p><a href='{0}'>{0}</a></p>
+        <p>If you didn't ask to verify this address, you can ignore this email.</p>
+        <p>Thanks,</p>
+        <p>Your {1} team</p>
+      `,
+    },
+    passwordReset: {
+      subject: `Reset your password for {0}`,
+      body: `
+        <p>Hello,</p>
+        <p>Follow this link to reset your {0} password for your {1} account.</p>
+        <p><a href='{2}'>{2}</a></p>
+        <p>If you didn't ask to reset your password, you can ignore this email.</p>
+        <p>Thanks,</p>
+        <p>Your {0} team</p>
+      `,
+    },
+  },
+};
+
+module.exports = errors;

backend/src/services/openai.js

@@ -0,0 +1,22 @@
+const axios = require('axios');
+const { v4: uuid } = require('uuid');
+const RoleService = require('./roles');
+const config = require('../config');
+
+module.exports = class OpenAiService {
+  static async getWidget(payload, userId, roleId) {
+    const response = await axios.post(
+      `${config.flHost}/${config.project_uuid}/project_customization_widgets.json`,
+      payload,
+    );
+
+    if (response.status >= 200 && response.status < 300) {
+      const { widget_id } = await response.data;
+      await RoleService.addRoleInfo(roleId, userId, 'widgets', widget_id);
+      return widget_id;
+    } else {
+      console.error('=======error=======', response.data);
+      return { value: null, error: response.data };
+    }
+  }
+};

backend/src/services/organizations.js

@@ -0,0 +1,117 @@
+const db = require('../db/models');
+const OrganizationsDBApi = require('../db/api/organizations');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+module.exports = class OrganizationsService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await OrganizationsDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await OrganizationsDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let organizations = await OrganizationsDBApi.findBy(
+        { id },
+        { transaction },
+      );
+
+      if (!organizations) {
+        throw new ValidationError('organizationsNotFound');
+      }
+
+      const updatedOrganizations = await OrganizationsDBApi.update(id, data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+      return updatedOrganizations;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await OrganizationsDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await OrganizationsDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

backend/src/services/permissions.js

@@ -0,0 +1,114 @@
+const db = require('../db/models');
+const PermissionsDBApi = require('../db/api/permissions');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+module.exports = class PermissionsService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await PermissionsDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await PermissionsDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let permissions = await PermissionsDBApi.findBy({ id }, { transaction });
+
+      if (!permissions) {
+        throw new ValidationError('permissionsNotFound');
+      }
+
+      const updatedPermissions = await PermissionsDBApi.update(id, data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+      return updatedPermissions;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await PermissionsDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await PermissionsDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

backend/src/services/roles.js

@@ -0,0 +1,391 @@
+const db = require('../db/models');
+const RolesDBApi = require('../db/api/roles');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+function buildWidgetResult(widget, queryResult, queryString) {
+  if (queryResult[0] && queryResult[0].length) {
+    const key = Object.keys(queryResult[0][0])[0];
+    const value =
+      widget.widget_type === 'scalar' ? queryResult[0][0][key] : queryResult[0];
+    const widgetData = JSON.parse(widget.data);
+    return { ...widget, ...widgetData, value, query: queryString };
+  } else {
+    return { ...widget, value: [], query: queryString };
+  }
+}
+
+async function executeQuery(queryString, currentUser) {
+  try {
+    return await db.sequelize.query(queryString, {
+      replacements: { organizationId: currentUser.organizationId },
+    });
+  } catch (e) {
+    console.log(e);
+    return [];
+  }
+}
+
+function insertWhereConditions(queryString, whereConditions) {
+  if (!whereConditions) return queryString;
+
+  const whereIndex = queryString.toLowerCase().indexOf('where');
+  const groupByIndex = queryString.toLowerCase().indexOf('group by');
+  const insertIndex =
+    whereIndex === -1
+      ? groupByIndex !== -1
+        ? groupByIndex
+        : queryString.length
+      : whereIndex + 5;
+
+  const prefix = queryString.substring(0, insertIndex);
+  const suffix = queryString.substring(insertIndex);
+  const conditionString =
+    whereIndex === -1
+      ? ` WHERE ${whereConditions} `
+      : ` ${whereConditions} AND `;
+
+  return `${prefix}${conditionString}${suffix}`;
+}
+
+function constructWhereConditions(mainTable, currentUser, replacements) {
+  const {
+    organizationId,
+    app_role: { globalAccess },
+  } = currentUser;
+  const tablesWithoutOrgId = ['permissions', 'roles'];
+  let whereConditions = '';
+
+  if (!globalAccess && !tablesWithoutOrgId.includes(mainTable)) {
+    whereConditions += `"${mainTable}"."organizationId" = :organizationId`;
+    replacements.organizationId = organizationId;
+  }
+
+  if (mainTable !== 'users') {
+    whereConditions += whereConditions ? ' AND ' : '';
+    whereConditions += `"${mainTable}"."deletedAt" IS NULL`;
+  }
+
+  return whereConditions;
+}
+
+function extractTableName(queryString) {
+  const tableNameRegex = /FROM\s+("?)([^"\s]+)\1\s*/i;
+  const match = tableNameRegex.exec(queryString);
+  return match ? match[2] : null;
+}
+
+function buildQueryString(widget, currentUser) {
+  let queryString = widget?.query || '';
+  const tableName = extractTableName(queryString);
+  const mainTable = JSON.parse(widget?.data)?.main_table || tableName;
+  const replacements = {};
+  const whereConditions = constructWhereConditions(
+    mainTable,
+    currentUser,
+    replacements,
+  );
+  queryString = insertWhereConditions(queryString, whereConditions);
+  console.log(queryString, 'queryString');
+  return queryString;
+}
+
+async function constructWidgetsResults(widgets, currentUser) {
+  const widgetsResults = [];
+  for (const widget of widgets) {
+    if (!widget) continue;
+    const queryString = buildQueryString(widget, currentUser);
+    const queryResult = await executeQuery(queryString, currentUser);
+    widgetsResults.push(buildWidgetResult(widget, queryResult, queryString));
+  }
+  return widgetsResults;
+}
+
+async function fetchWidgetsData(widgets) {
+  const widgetPromises = (widgets || []).map((widgetId) =>
+    axios.get(
+      `${config.flHost}/${config.project_uuid}/project_customization_widgets/${widgetId}.json`,
+    ),
+  );
+  const widgetResults = widgetPromises
+    ? await Promise.allSettled(widgetPromises)
+    : [];
+  return widgetResults
+    .filter((result) => result.status === 'fulfilled')
+    .map((result) => result.value.data);
+}
+
+async function processWidgets(widgets, currentUser) {
+  const widgetData = await fetchWidgetsData(widgets);
+  return constructWidgetsResults(widgetData, currentUser);
+}
+
+function parseCustomization(role) {
+  try {
+    return JSON.parse(role.role_customization || '{}');
+  } catch (e) {
+    console.log(e);
+    return {};
+  }
+}
+
+async function findRole(roleId, currentUser) {
+  const transaction = await db.sequelize.transaction();
+  try {
+    const role = roleId
+      ? await RolesDBApi.findBy({ id: roleId }, { transaction })
+      : await RolesDBApi.findBy({ name: 'User' }, { transaction });
+    await transaction.commit();
+    return role;
+  } catch (error) {
+    await transaction.rollback();
+    throw error;
+  }
+}
+
+module.exports = class RolesService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await RolesDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await RolesDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let roles = await RolesDBApi.findBy({ id }, { transaction });
+
+      if (!roles) {
+        throw new ValidationError('rolesNotFound');
+      }
+
+      const updatedRoles = await RolesDBApi.update(id, data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+      return updatedRoles;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await RolesDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await RolesDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async addRoleInfo(roleId, userId, key, widgetId, currentUser) {
+    const regexExpForUuid =
+      /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/gi;
+    const widgetIdIsUUID = regexExpForUuid.test(widgetId);
+
+    const transaction = await db.sequelize.transaction();
+    let role;
+    if (roleId) {
+      role = await RolesDBApi.findBy({ id: roleId }, { transaction });
+    } else {
+      role = await RolesDBApi.findBy({ name: 'User' }, { transaction });
+    }
+
+    if (!role) {
+      throw new ValidationError('rolesNotFound');
+    }
+
+    try {
+      let customization = {};
+      try {
+        customization = JSON.parse(role.role_customization || '{}');
+      } catch (e) {
+        console.log(e);
+      }
+
+      if (widgetIdIsUUID && Array.isArray(customization[key])) {
+        const el = customization[key].find((e) => e === widgetId);
+        !el ? customization[key].unshift(widgetId) : null;
+      }
+
+      if (widgetIdIsUUID && !customization[key]) {
+        customization[key] = [widgetId];
+      }
+
+      const newRole = await RolesDBApi.update(
+        role.id,
+        {
+          role_customization: JSON.stringify(customization),
+          name: role.name,
+          permissions: role.permissions,
+          globalAccess: role.globalAccess,
+        },
+        {
+          currentUser,
+          transaction,
+        },
+      );
+
+      await transaction.commit();
+
+      return newRole;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async removeRoleInfoById(infoId, roleId, key, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    let role;
+    if (roleId) {
+      role = await RolesDBApi.findBy({ id: roleId }, { transaction });
+    } else {
+      role = await RolesDBApi.findBy({ name: 'User' }, { transaction });
+    }
+    if (!role) {
+      await transaction.rollback();
+      throw new ValidationError('rolesNotFound');
+    }
+
+    let customization = {};
+    try {
+      customization = JSON.parse(role.role_customization || '{}');
+    } catch (e) {
+      console.log(e);
+    }
+
+    customization[key] = customization[key].filter((item) => item !== infoId);
+
+    const response = await axios.delete(
+      `${config.flHost}/${config.project_uuid}/project_customization_widgets/${infoId}.json`,
+    );
+    const { status } = await response;
+    try {
+      const result = await RolesDBApi.update(
+        role.id,
+        {
+          role_customization: JSON.stringify(customization),
+          name: role.name,
+          permissions: role.permissions,
+          globalAccess: role.globalAccess,
+        },
+        {
+          currentUser,
+          transaction,
+        },
+      );
+
+      await transaction.commit();
+      return result;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async getRoleInfoByKey(key, roleId, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    const organizationId = currentUser.organizationId;
+    let globalAccess = currentUser.app_role?.globalAccess;
+    let queryString = '';
+
+    try {
+      const role = await findRole(roleId, currentUser);
+      const customization = parseCustomization(role);
+
+      let result;
+      if (key === 'widgets') {
+        result = await processWidgets(customization[key], currentUser);
+      } else {
+        result = customization[key];
+      }
+
+      await transaction.commit();
+      return result;
+    } catch (error) {
+      console.error(error);
+      await transaction.rollback();
+    } finally {
+      if (transaction.finished !== 'commit') {
+        await transaction.rollback();
+      }
+    }
+  }
+};

backend/src/services/search.js

@@ -0,0 +1,147 @@
+const db = require('../db/models');
+const ValidationError = require('./notifications/errors/validation');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+/**
+ * @param {string} permission
+ * @param {object} currentUser
+ */
+async function checkPermissions(permission, currentUser) {
+  if (!currentUser) {
+    throw new ValidationError('auth.unauthorized');
+  }
+
+  const userPermission = currentUser.custom_permissions.find(
+    (cp) => cp.name === permission,
+  );
+
+  if (userPermission) {
+    return true;
+  }
+
+  try {
+    if (!currentUser.app_role) {
+      throw new ValidationError('auth.forbidden');
+    }
+
+    const permissions = await currentUser.app_role.getPermissions();
+
+    return !!permissions.find((p) => p.name === permission);
+  } catch (e) {
+    throw e;
+  }
+}
+
+module.exports = class SearchService {
+  static async search(searchQuery, currentUser, organizationId, globalAccess) {
+    try {
+      if (!searchQuery) {
+        throw new ValidationError('iam.errors.searchQueryRequired');
+      }
+      const tableColumns = {
+        users: ['firstName', 'lastName', 'phoneNumber', 'email'],
+
+        token_profiles: ['description'],
+
+        tokens: ['name', 'symbol'],
+
+        organizations: ['name'],
+      };
+      const columnsInt = {
+        subscriptions: ['price'],
+
+        tokens: ['market_cap', 'price'],
+      };
+
+      let allFoundRecords = [];
+
+      for (const tableName in tableColumns) {
+        if (tableColumns.hasOwnProperty(tableName)) {
+          const attributesToSearch = tableColumns[tableName];
+          const attributesIntToSearch = columnsInt[tableName] || [];
+          const whereCondition = {
+            [Op.or]: [
+              ...attributesToSearch.map((attribute) => ({
+                [attribute]: {
+                  [Op.iLike]: `%${searchQuery}%`,
+                },
+              })),
+              ...attributesIntToSearch.map((attribute) =>
+                Sequelize.where(
+                  Sequelize.cast(
+                    Sequelize.col(`${tableName}.${attribute}`),
+                    'varchar',
+                  ),
+                  { [Op.iLike]: `%${searchQuery}%` },
+                ),
+              ),
+            ],
+          };
+
+          if (
+            !globalAccess &&
+            tableName !== 'organizations' &&
+            organizationId
+          ) {
+            whereCondition.organizationId = organizationId;
+          }
+
+          const hasPermission = await checkPermissions(
+            `READ_${tableName.toUpperCase()}`,
+            currentUser,
+          );
+          if (!hasPermission) {
+            continue;
+          }
+
+          const foundRecords = await db[tableName].findAll({
+            where: whereCondition,
+            attributes: [
+              ...tableColumns[tableName],
+              'id',
+              ...attributesIntToSearch,
+            ],
+          });
+
+          const modifiedRecords = foundRecords.map((record) => {
+            const matchAttribute = [];
+
+            for (const attribute of attributesToSearch) {
+              if (
+                record[attribute]
+                  ?.toLowerCase()
+                  ?.includes(searchQuery.toLowerCase())
+              ) {
+                matchAttribute.push(attribute);
+              }
+            }
+
+            for (const attribute of attributesIntToSearch) {
+              const castedValue = String(record[attribute]);
+              if (
+                castedValue &&
+                castedValue.toLowerCase().includes(searchQuery.toLowerCase())
+              ) {
+                matchAttribute.push(attribute);
+              }
+            }
+
+            return {
+              ...record.get(),
+              matchAttribute,
+              tableName,
+            };
+          });
+
+          allFoundRecords = allFoundRecords.concat(modifiedRecords);
+        }
+      }
+
+      return allFoundRecords;
+    } catch (error) {
+      throw error;
+    }
+  }
+};

backend/src/services/subscriptions.js

@@ -0,0 +1,117 @@
+const db = require('../db/models');
+const SubscriptionsDBApi = require('../db/api/subscriptions');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+module.exports = class SubscriptionsService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await SubscriptionsDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await SubscriptionsDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let subscriptions = await SubscriptionsDBApi.findBy(
+        { id },
+        { transaction },
+      );
+
+      if (!subscriptions) {
+        throw new ValidationError('subscriptionsNotFound');
+      }
+
+      const updatedSubscriptions = await SubscriptionsDBApi.update(id, data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+      return updatedSubscriptions;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await SubscriptionsDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await SubscriptionsDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

backend/src/services/token_profiles.js

@@ -0,0 +1,117 @@
+const db = require('../db/models');
+const Token_profilesDBApi = require('../db/api/token_profiles');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+module.exports = class Token_profilesService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await Token_profilesDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await Token_profilesDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let token_profiles = await Token_profilesDBApi.findBy(
+        { id },
+        { transaction },
+      );
+
+      if (!token_profiles) {
+        throw new ValidationError('token_profilesNotFound');
+      }
+
+      const updatedToken_profiles = await Token_profilesDBApi.update(id, data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+      return updatedToken_profiles;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await Token_profilesDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await Token_profilesDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

backend/src/services/tokens.js

@@ -0,0 +1,114 @@
+const db = require('../db/models');
+const TokensDBApi = require('../db/api/tokens');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+module.exports = class TokensService {
+  static async create(data, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      await TokensDBApi.create(data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', async () => {
+            console.log('CSV results', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      await TokensDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+    try {
+      let tokens = await TokensDBApi.findBy({ id }, { transaction });
+
+      if (!tokens) {
+        throw new ValidationError('tokensNotFound');
+      }
+
+      const updatedTokens = await TokensDBApi.update(id, data, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+      return updatedTokens;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async deleteByIds(ids, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await TokensDBApi.deleteByIds(ids, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      await TokensDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

backend/src/services/users.js

@@ -0,0 +1,163 @@
+const db = require('../db/models');
+const UsersDBApi = require('../db/api/users');
+const processFile = require('../middlewares/upload');
+const ValidationError = require('./notifications/errors/validation');
+const csv = require('csv-parser');
+const axios = require('axios');
+const config = require('../config');
+const stream = require('stream');
+
+const InvitationEmail = require('./email/list/invitation');
+const EmailSender = require('./email');
+const AuthService = require('./auth');
+
+module.exports = class UsersService {
+  static async create(data, currentUser, sendInvitationEmails = true, host) {
+    let transaction = await db.sequelize.transaction();
+
+    const globalAccess = currentUser.app_role.globalAccess;
+
+    let email = data.email;
+    let emailsToInvite = [];
+    try {
+      if (email) {
+        let user = await UsersDBApi.findBy({ email }, { transaction });
+        if (user) {
+          throw new ValidationError('iam.errors.userAlreadyExists');
+        } else {
+          await UsersDBApi.create(
+            { data },
+
+            globalAccess,
+
+            {
+              currentUser,
+              transaction,
+            },
+          );
+          emailsToInvite.push(email);
+        }
+      } else {
+        throw new ValidationError('iam.errors.emailRequired');
+      }
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+    if (emailsToInvite && emailsToInvite.length) {
+      if (!sendInvitationEmails) return;
+
+      AuthService.sendPasswordResetEmail(email, 'invitation', host);
+    }
+  }
+
+  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+    const transaction = await db.sequelize.transaction();
+    let emailsToInvite = [];
+
+    try {
+      await processFile(req, res);
+      const bufferStream = new stream.PassThrough();
+      const results = [];
+
+      await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
+
+      await new Promise((resolve, reject) => {
+        bufferStream
+          .pipe(csv())
+          .on('data', (data) => results.push(data))
+          .on('end', () => {
+            console.log('results csv', results);
+            resolve();
+          })
+          .on('error', (error) => reject(error));
+      });
+
+      const hasAllEmails = results.every((result) => result.email);
+
+      if (!hasAllEmails) {
+        throw new ValidationError('importer.errors.userEmailMissing');
+      }
+
+      await UsersDBApi.bulkImport(results, {
+        transaction,
+        ignoreDuplicates: true,
+        validate: true,
+        currentUser: req.currentUser,
+      });
+
+      emailsToInvite = results.map((result) => result.email);
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+
+    if (emailsToInvite && emailsToInvite.length && !sendInvitationEmails) {
+      emailsToInvite.forEach((email) => {
+        AuthService.sendPasswordResetEmail(email, 'invitation', host);
+      });
+    }
+  }
+
+  static async update(data, id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    const globalAccess = currentUser.app_role.globalAccess;
+
+    try {
+      let users = await UsersDBApi.findBy({ id }, { transaction });
+
+      if (!users) {
+        throw new ValidationError('iam.errors.userNotFound');
+      }
+
+      const updatedUser = await UsersDBApi.update(
+        id,
+        data,
+
+        globalAccess,
+
+        {
+          currentUser,
+          transaction,
+        },
+      );
+
+      await transaction.commit();
+      return updatedUser;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+
+  static async remove(id, currentUser) {
+    const transaction = await db.sequelize.transaction();
+
+    try {
+      if (currentUser.id === id) {
+        throw new ValidationError('iam.errors.deletingHimself');
+      }
+
+      if (
+        currentUser.app_role?.name !== config.roles.admin &&
+        currentUser.app_role?.name !== config.roles.super_admin
+      ) {
+        throw new ValidationError('errors.forbidden.message');
+      }
+
+      await UsersDBApi.remove(id, {
+        currentUser,
+        transaction,
+      });
+
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+};

backend/yarn.lock

@@ -0,0 +1,4470 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@apidevtools/json-schema-ref-parser@^9.0.6":
+  version "9.1.2"
+  resolved "https://registry.yarnpkg.com/@apidevtools/json-schema-ref-parser/-/json-schema-ref-parser-9.1.2.tgz#8ff5386b365d4c9faa7c8b566ff16a46a577d9b8"
+  integrity sha512-r1w81DpR+KyRWd3f+rk6TNqMgedmAxZP5v5KWlXQWlgMUUtyEJch0DKEci1SorPMiSeM8XPl7MZ3miJ60JIpQg==
+  dependencies:
+    "@jsdevtools/ono" "^7.1.3"
+    "@types/json-schema" "^7.0.6"
+    call-me-maybe "^1.0.1"
+    js-yaml "^4.1.0"
+
+"@apidevtools/openapi-schemas@^2.0.4":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@apidevtools/openapi-schemas/-/openapi-schemas-2.1.0.tgz#9fa08017fb59d80538812f03fc7cac5992caaa17"
+  integrity sha512-Zc1AlqrJlX3SlpupFGpiLi2EbteyP7fXmUOGup6/DnkRgjP9bgMM/ag+n91rsv0U1Gpz0H3VILA/o3bW7Ua6BQ==
+
+"@apidevtools/swagger-methods@^3.0.2":
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/@apidevtools/swagger-methods/-/swagger-methods-3.0.2.tgz#b789a362e055b0340d04712eafe7027ddc1ac267"
+  integrity sha512-QAkD5kK2b1WfjDS/UQn/qQkbwF31uqRjPTrsCs5ZG9BQGAkjwvqGFjjPqAuzac/IYzpPtRzjCP1WrTuAIjMrXg==
+
+"@apidevtools/swagger-parser@10.0.3":
+  version "10.0.3"
+  resolved "https://registry.yarnpkg.com/@apidevtools/swagger-parser/-/swagger-parser-10.0.3.tgz#32057ae99487872c4dd96b314a1ab4b95d89eaf5"
+  integrity sha512-sNiLY51vZOmSPFZA5TF35KZ2HbgYklQnTSDnkghamzLb3EkNtcQnrBQEj5AOCxHpTtXpqMCRM1CrmV2rG6nw4g==
+  dependencies:
+    "@apidevtools/json-schema-ref-parser" "^9.0.6"
+    "@apidevtools/openapi-schemas" "^2.0.4"
+    "@apidevtools/swagger-methods" "^3.0.2"
+    "@jsdevtools/ono" "^7.1.3"
+    call-me-maybe "^1.0.1"
+    z-schema "^5.0.1"
+
+"@azure/abort-controller@^1.0.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@azure/abort-controller/-/abort-controller-1.1.0.tgz#788ee78457a55af8a1ad342acb182383d2119249"
+  integrity sha512-TrRLIoSQVzfAJX9H1JeFjzAoDGcoK1IYX1UImfceTZpsyYfWr09Ss1aHW1y5TrrR3iq6RZLBwJ3E24uwPhwahw==
+  dependencies:
+    tslib "^2.2.0"
+
+"@azure/abort-controller@^2.0.0":
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/@azure/abort-controller/-/abort-controller-2.1.2.tgz#42fe0ccab23841d9905812c58f1082d27784566d"
+  integrity sha512-nBrLsEWm4J2u5LpAPjxADTlq3trDgVZZXHNKabeXZtpq3d3AbN/KGO82R87rdDz5/lYB024rtEf10/q0urNgsA==
+  dependencies:
+    tslib "^2.6.2"
+
+"@azure/core-auth@^1.3.0", "@azure/core-auth@^1.4.0", "@azure/core-auth@^1.5.0":
+  version "1.7.2"
+  resolved "https://registry.yarnpkg.com/@azure/core-auth/-/core-auth-1.7.2.tgz#558b7cb7dd12b00beec07ae5df5907d74df1ebd9"
+  integrity sha512-Igm/S3fDYmnMq1uKS38Ae1/m37B3zigdlZw+kocwEhh5GjyKjPrXKO2J6rzpC1wAxrNil/jX9BJRqBshyjnF3g==
+  dependencies:
+    "@azure/abort-controller" "^2.0.0"
+    "@azure/core-util" "^1.1.0"
+    tslib "^2.6.2"
+
+"@azure/core-client@^1.3.0", "@azure/core-client@^1.5.0", "@azure/core-client@^1.9.2":
+  version "1.9.2"
+  resolved "https://registry.yarnpkg.com/@azure/core-client/-/core-client-1.9.2.tgz#6fc69cee2816883ab6c5cdd653ee4f2ff9774f74"
+  integrity sha512-kRdry/rav3fUKHl/aDLd/pDLcB+4pOFwPPTVEExuMyaI5r+JBbMWqRbCY1pn5BniDaU3lRxO9eaQ1AmSMehl/w==
+  dependencies:
+    "@azure/abort-controller" "^2.0.0"
+    "@azure/core-auth" "^1.4.0"
+    "@azure/core-rest-pipeline" "^1.9.1"
+    "@azure/core-tracing" "^1.0.0"
+    "@azure/core-util" "^1.6.1"
+    "@azure/logger" "^1.0.0"
+    tslib "^2.6.2"
+
+"@azure/core-http-compat@^2.0.1":
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/@azure/core-http-compat/-/core-http-compat-2.1.2.tgz#d1585ada24ba750dc161d816169b33b35f762f0d"
+  integrity sha512-5MnV1yqzZwgNLLjlizsU3QqOeQChkIXw781Fwh1xdAqJR5AA32IUaq6xv1BICJvfbHoa+JYcaij2HFkhLbNTJQ==
+  dependencies:
+    "@azure/abort-controller" "^2.0.0"
+    "@azure/core-client" "^1.3.0"
+    "@azure/core-rest-pipeline" "^1.3.0"
+
+"@azure/core-lro@^2.2.0":
+  version "2.7.2"
+  resolved "https://registry.yarnpkg.com/@azure/core-lro/-/core-lro-2.7.2.tgz#787105027a20e45c77651a98b01a4d3b01b75a08"
+  integrity sha512-0YIpccoX8m/k00O7mDDMdJpbr6mf1yWo2dfmxt5A8XVZVVMz2SSKaEbMCeJRvgQ0IaSlqhjT47p4hVIRRy90xw==
+  dependencies:
+    "@azure/abort-controller" "^2.0.0"
+    "@azure/core-util" "^1.2.0"
+    "@azure/logger" "^1.0.0"
+    tslib "^2.6.2"
+
+"@azure/core-paging@^1.1.1":
+  version "1.6.2"
+  resolved "https://registry.yarnpkg.com/@azure/core-paging/-/core-paging-1.6.2.tgz#40d3860dc2df7f291d66350b2cfd9171526433e7"
+  integrity sha512-YKWi9YuCU04B55h25cnOYZHxXYtEvQEbKST5vqRga7hWY9ydd3FZHdeQF8pyh+acWZvppw13M/LMGx0LABUVMA==
+  dependencies:
+    tslib "^2.6.2"
+
+"@azure/core-rest-pipeline@^1.1.0", "@azure/core-rest-pipeline@^1.3.0", "@azure/core-rest-pipeline@^1.8.1", "@azure/core-rest-pipeline@^1.9.1":
+  version "1.16.2"
+  resolved "https://registry.yarnpkg.com/@azure/core-rest-pipeline/-/core-rest-pipeline-1.16.2.tgz#3f71b09e45a65926cc598478b4f1bcd0fe67bf4b"
+  integrity sha512-Hnhm/PG9/SQ07JJyLDv3l9Qr8V3xgAe1hFoBYzt6LaalMxfL/ZqFaZf/bz5VN3pMcleCPwl8ivlS2Fjxq/iC8Q==
+  dependencies:
+    "@azure/abort-controller" "^2.0.0"
+    "@azure/core-auth" "^1.4.0"
+    "@azure/core-tracing" "^1.0.1"
+    "@azure/core-util" "^1.9.0"
+    "@azure/logger" "^1.0.0"
+    http-proxy-agent "^7.0.0"
+    https-proxy-agent "^7.0.0"
+    tslib "^2.6.2"
+
+"@azure/core-tracing@^1.0.0", "@azure/core-tracing@^1.0.1":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@azure/core-tracing/-/core-tracing-1.1.2.tgz#065dab4e093fb61899988a1cdbc827d9ad90b4ee"
+  integrity sha512-dawW9ifvWAWmUm9/h+/UQ2jrdvjCJ7VJEuCJ6XVNudzcOwm53BFZH4Q845vjfgoUAM8ZxokvVNxNxAITc502YA==
+  dependencies:
+    tslib "^2.6.2"
+
+"@azure/core-util@^1.0.0", "@azure/core-util@^1.1.0", "@azure/core-util@^1.2.0", "@azure/core-util@^1.3.0", "@azure/core-util@^1.6.1", "@azure/core-util@^1.9.0":
+  version "1.9.1"
+  resolved "https://registry.yarnpkg.com/@azure/core-util/-/core-util-1.9.1.tgz#05ea9505c5cdf29c55ccf99a648c66ddd678590b"
+  integrity sha512-OLsq0etbHO1MA7j6FouXFghuHrAFGk+5C1imcpQ2e+0oZhYF07WLA+NW2Vqs70R7d+zOAWiWM3tbE1sXcDN66g==
+  dependencies:
+    "@azure/abort-controller" "^2.0.0"
+    tslib "^2.6.2"
+
+"@azure/identity@^4.2.1":
+  version "4.4.0"
+  resolved "https://registry.yarnpkg.com/@azure/identity/-/identity-4.4.0.tgz#f2743e63d346000a70b0eed5a3b397dedd3984a7"
+  integrity sha512-oG6oFNMxUuoivYg/ElyZWVSZfw42JQyHbrp+lR7VJ1BYWsGzt34NwyDw3miPp1QI7Qm5+4KAd76wGsbHQmkpkg==
+  dependencies:
+    "@azure/abort-controller" "^1.0.0"
+    "@azure/core-auth" "^1.5.0"
+    "@azure/core-client" "^1.9.2"
+    "@azure/core-rest-pipeline" "^1.1.0"
+    "@azure/core-tracing" "^1.0.0"
+    "@azure/core-util" "^1.3.0"
+    "@azure/logger" "^1.0.0"
+    "@azure/msal-browser" "^3.14.0"
+    "@azure/msal-node" "^2.9.2"
+    events "^3.0.0"
+    jws "^4.0.0"
+    open "^8.0.0"
+    stoppable "^1.1.0"
+    tslib "^2.2.0"
+
+"@azure/keyvault-keys@^4.4.0":
+  version "4.8.0"
+  resolved "https://registry.yarnpkg.com/@azure/keyvault-keys/-/keyvault-keys-4.8.0.tgz#1513b3a187bb3a9a372b5980c593962fb793b2ad"
+  integrity sha512-jkuYxgkw0aaRfk40OQhFqDIupqblIOIlYESWB6DKCVDxQet1pyv86Tfk9M+5uFM0+mCs6+MUHU+Hxh3joiUn4Q==
+  dependencies:
+    "@azure/abort-controller" "^1.0.0"
+    "@azure/core-auth" "^1.3.0"
+    "@azure/core-client" "^1.5.0"
+    "@azure/core-http-compat" "^2.0.1"
+    "@azure/core-lro" "^2.2.0"
+    "@azure/core-paging" "^1.1.1"
+    "@azure/core-rest-pipeline" "^1.8.1"
+    "@azure/core-tracing" "^1.0.0"
+    "@azure/core-util" "^1.0.0"
+    "@azure/logger" "^1.0.0"
+    tslib "^2.2.0"
+
+"@azure/logger@^1.0.0":
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/@azure/logger/-/logger-1.1.3.tgz#09a8fd4850b9112865756e92d5e8b728ee457345"
+  integrity sha512-J8/cIKNQB1Fc9fuYqBVnrppiUtW+5WWJPCj/tAokC5LdSTwkWWttN+jsRgw9BLYD7JDBx7PceiqOBxJJ1tQz3Q==
+  dependencies:
+    tslib "^2.6.2"
+
+"@azure/msal-browser@^3.14.0":
+  version "3.19.1"
+  resolved "https://registry.yarnpkg.com/@azure/msal-browser/-/msal-browser-3.19.1.tgz#c5e5a7996f95cadc11920bffa2bf6321e3a24555"
+  integrity sha512-pqYP2gK0GCEa4OxtOqlS+EdFQqhXV6ZuESgSTYWq2ABXyxBVVdd5KNuqgR5SU0OwI2V1YWdFVvLDe1487dyQ0g==
+  dependencies:
+    "@azure/msal-common" "14.13.1"
+
+"@azure/msal-common@14.13.1":
+  version "14.13.1"
+  resolved "https://registry.yarnpkg.com/@azure/msal-common/-/msal-common-14.13.1.tgz#e296cf8cc556082af9c35d803496424e8a95d8b7"
+  integrity sha512-iUp3BYrsRZ4X3EiaZ2fDjNFjmtYMv9rEQd6c1op6ULn0HWk4ACvDmosL6NaBgWOhl1BAblIbd9vmB5/ilF8d4A==
+
+"@azure/msal-node@^2.9.2":
+  version "2.11.1"
+  resolved "https://registry.yarnpkg.com/@azure/msal-node/-/msal-node-2.11.1.tgz#7fea67a1c6904301eb8853fae7df86c34306a9cc"
+  integrity sha512-8ECtug4RL+zsgh20VL8KYHjrRO3MJOeAKEPRXT2lwtiu5U3BdyIdBb50+QZthEkIi60K6pc/pdOx/k5Jp4sLng==
+  dependencies:
+    "@azure/msal-common" "14.13.1"
+    jsonwebtoken "^9.0.0"
+    uuid "^8.3.0"
+
+"@google-cloud/paginator@^3.0.7":
+  version "3.0.7"
+  resolved "https://registry.yarnpkg.com/@google-cloud/paginator/-/paginator-3.0.7.tgz#fb6f8e24ec841f99defaebf62c75c2e744dd419b"
+  integrity sha512-jJNutk0arIQhmpUUQJPJErsojqo834KcyB6X7a1mxuic8i1tKXxde8E69IZxNZawRIlZdIK2QY4WALvlK5MzYQ==
+  dependencies:
+    arrify "^2.0.0"
+    extend "^3.0.2"
+
+"@google-cloud/projectify@^2.0.0":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@google-cloud/projectify/-/projectify-2.1.1.tgz#ae6af4fee02d78d044ae434699a630f8df0084ef"
+  integrity sha512-+rssMZHnlh0twl122gXY4/aCrk0G1acBqkHFfYddtsqpYXGxA29nj9V5V9SfC+GyOG00l650f6lG9KL+EpFEWQ==
+
+"@google-cloud/promisify@^2.0.0":
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/@google-cloud/promisify/-/promisify-2.0.4.tgz#9d8705ecb2baa41b6b2673f3a8e9b7b7e1abc52a"
+  integrity sha512-j8yRSSqswWi1QqUGKVEKOG03Q7qOoZP6/h2zN2YO+F5h2+DHU0bSrHCK9Y7lo2DI9fBd8qGAw795sf+3Jva4yA==
+
+"@google-cloud/storage@^5.18.2":
+  version "5.20.5"
+  resolved "https://registry.yarnpkg.com/@google-cloud/storage/-/storage-5.20.5.tgz#1de71fc88d37934a886bc815722c134b162d335d"
+  integrity sha512-lOs/dCyveVF8TkVFnFSF7IGd0CJrTm91qiK6JLu+Z8qiT+7Ag0RyVhxZIWkhiACqwABo7kSHDm8FdH8p2wxSSw==
+  dependencies:
+    "@google-cloud/paginator" "^3.0.7"
+    "@google-cloud/projectify" "^2.0.0"
+    "@google-cloud/promisify" "^2.0.0"
+    abort-controller "^3.0.0"
+    arrify "^2.0.0"
+    async-retry "^1.3.3"
+    compressible "^2.0.12"
+    configstore "^5.0.0"
+    duplexify "^4.0.0"
+    ent "^2.2.0"
+    extend "^3.0.2"
+    gaxios "^4.0.0"
+    google-auth-library "^7.14.1"
+    hash-stream-validation "^0.2.2"
+    mime "^3.0.0"
+    mime-types "^2.0.8"
+    p-limit "^3.0.1"
+    pumpify "^2.0.0"
+    retry-request "^4.2.2"
+    stream-events "^1.0.4"
+    teeny-request "^7.1.3"
+    uuid "^8.0.0"
+    xdg-basedir "^4.0.0"
+
+"@isaacs/cliui@^8.0.2":
+  version "8.0.2"
+  resolved "https://registry.yarnpkg.com/@isaacs/cliui/-/cliui-8.0.2.tgz#b37667b7bc181c168782259bab42474fbf52b550"
+  integrity sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==
+  dependencies:
+    string-width "^5.1.2"
+    string-width-cjs "npm:string-width@^4.2.0"
+    strip-ansi "^7.0.1"
+    strip-ansi-cjs "npm:strip-ansi@^6.0.1"
+    wrap-ansi "^8.1.0"
+    wrap-ansi-cjs "npm:wrap-ansi@^7.0.0"
+
+"@js-joda/core@^5.6.1":
+  version "5.6.3"
+  resolved "https://registry.yarnpkg.com/@js-joda/core/-/core-5.6.3.tgz#41ae1c07de1ebe0f6dde1abcbc9700a09b9c6056"
+  integrity sha512-T1rRxzdqkEXcou0ZprN1q9yDRlvzCPLqmlNt5IIsGBzoEVgLCCYrKEwc84+TvsXuAc95VAZwtWD2zVsKPY4bcA==
+
+"@jsdevtools/ono@^7.1.3":
+  version "7.1.3"
+  resolved "https://registry.yarnpkg.com/@jsdevtools/ono/-/ono-7.1.3.tgz#9df03bbd7c696a5c58885c34aa06da41c8543796"
+  integrity sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg==
+
+"@mapbox/node-pre-gyp@^1.0.11":
+  version "1.0.11"
+  resolved "https://registry.yarnpkg.com/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.11.tgz#417db42b7f5323d79e93b34a6d7a2a12c0df43fa"
+  integrity sha512-Yhlar6v9WQgUp/He7BdgzOz8lqMQ8sU+jkCq7Wx8Myc5YFJLbEe7lgui/V7G1qB1DJykHSGwreceSaD60Y0PUQ==
+  dependencies:
+    detect-libc "^2.0.0"
+    https-proxy-agent "^5.0.0"
+    make-dir "^3.1.0"
+    node-fetch "^2.6.7"
+    nopt "^5.0.0"
+    npmlog "^5.0.1"
+    rimraf "^3.0.2"
+    semver "^7.3.5"
+    tar "^6.1.11"
+
+"@one-ini/wasm@0.1.1":
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/@one-ini/wasm/-/wasm-0.1.1.tgz#6013659736c9dbfccc96e8a9c2b3de317df39323"
+  integrity sha512-XuySG1E38YScSJoMlqovLru4KTUNSjgVTIjyh7qMX6aNN5HY5Ct5LhRJdxO79JtTzKfzV/bnWpz+zquYrISsvw==
+
+"@pkgjs/parseargs@^0.11.0":
+  version "0.11.0"
+  resolved "https://registry.yarnpkg.com/@pkgjs/parseargs/-/parseargs-0.11.0.tgz#a77ea742fab25775145434eb1d2328cf5013ac33"
+  integrity sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==
+
+"@sindresorhus/is@^0.14.0":
+  version "0.14.0"
+  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-0.14.0.tgz#9fb3a3cf3132328151f353de4632e01e52102bea"
+  integrity sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==
+
+"@szmarczak/http-timer@^1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@szmarczak/http-timer/-/http-timer-1.1.2.tgz#b1665e2c461a2cd92f4c1bbf50d5454de0d4b421"
+  integrity sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==
+  dependencies:
+    defer-to-connect "^1.0.1"
+
+"@tootallnate/once@2":
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/@tootallnate/once/-/once-2.0.0.tgz#f544a148d3ab35801c1f633a7441fd87c2e484bf"
+  integrity sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==
+
+"@types/debug@^4.1.8":
+  version "4.1.12"
+  resolved "https://registry.yarnpkg.com/@types/debug/-/debug-4.1.12.tgz#a155f21690871953410df4b6b6f53187f0500917"
+  integrity sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==
+  dependencies:
+    "@types/ms" "*"
+
+"@types/json-schema@^7.0.6":
+  version "7.0.15"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.15.tgz#596a1747233694d50f6ad8a7869fcb6f56cf5841"
+  integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==
+
+"@types/ms@*":
+  version "0.7.34"
+  resolved "https://registry.yarnpkg.com/@types/ms/-/ms-0.7.34.tgz#10964ba0dee6ac4cd462e2795b6bebd407303433"
+  integrity sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==
+
+"@types/node@*", "@types/node@>=18":
+  version "20.14.11"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-20.14.11.tgz#09b300423343460455043ddd4d0ded6ac579b74b"
+  integrity sha512-kprQpL8MMeszbz6ojB5/tU8PLN4kesnN8Gjzw349rDlNgsSzg90lAVj3llK99Dh7JON+t9AuscPPFW6mPbTnSA==
+  dependencies:
+    undici-types "~5.26.4"
+
+"@types/readable-stream@^4.0.0":
+  version "4.0.15"
+  resolved "https://registry.yarnpkg.com/@types/readable-stream/-/readable-stream-4.0.15.tgz#e6ec26fe5b02f578c60baf1fa9452e90957d2bfb"
+  integrity sha512-oAZ3kw+kJFkEqyh7xORZOku1YAKvsFTogRY8kVl4vHpEKiDkfnSA/My8haRE7fvmix5Zyy+1pwzOi7yycGLBJw==
+  dependencies:
+    "@types/node" "*"
+    safe-buffer "~5.1.1"
+
+"@types/validator@^13.7.17":
+  version "13.12.0"
+  resolved "https://registry.yarnpkg.com/@types/validator/-/validator-13.12.0.tgz#1fe4c3ae9de5cf5193ce64717c99ef2fa7d8756f"
+  integrity sha512-nH45Lk7oPIJ1RVOF6JgFI6Dy0QpHEzq4QecZhvguxYPDwT8c93prCMqAtiIttm39voZ+DDR+qkNnMpJmMBRqag==
+
+abbrev@1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
+  integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
+
+abbrev@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-2.0.0.tgz#cf59829b8b4f03f89dda2771cb7f3653828c89bf"
+  integrity sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==
+
+abort-controller@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/abort-controller/-/abort-controller-3.0.0.tgz#eaf54d53b62bae4138e809ca225c8439a6efb392"
+  integrity sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==
+  dependencies:
+    event-target-shim "^5.0.0"
+
+accepts@^1.3.7, accepts@~1.3.8:
+  version "1.3.8"
+  resolved "https://registry.yarnpkg.com/accepts/-/accepts-1.3.8.tgz#0bf0be125b67014adcb0b0921e62db7bffe16b2e"
+  integrity sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==
+  dependencies:
+    mime-types "~2.1.34"
+    negotiator "0.6.3"
+
+agent-base@6:
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-6.0.2.tgz#49fff58577cfee3f37176feab4c22e00f86d7f77"
+  integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==
+  dependencies:
+    debug "4"
+
+agent-base@^7.0.2, agent-base@^7.1.0:
+  version "7.1.1"
+  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-7.1.1.tgz#bdbded7dfb096b751a2a087eeeb9664725b2e317"
+  integrity sha512-H0TSyFNDMomMNJQBn8wFV5YC/2eJ+VXECwOadZJT554xP6cODZHPX3H9QMQECxvrgiSOP1pHjy1sMWQVYJOUOA==
+  dependencies:
+    debug "^4.3.4"
+
+ansi-align@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-3.0.1.tgz#0cdf12e111ace773a86e9a1fad1225c43cb19a59"
+  integrity sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==
+  dependencies:
+    string-width "^4.1.0"
+
+ansi-colors@4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348"
+  integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==
+
+ansi-regex@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.1.tgz#123d6479e92ad45ad897d4054e3c7ca7db4944e1"
+  integrity sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==
+
+ansi-regex@^4.1.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.1.1.tgz#164daac87ab2d6f6db3a29875e2d1766582dabed"
+  integrity sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==
+
+ansi-regex@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
+  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
+
+ansi-regex@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a"
+  integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==
+
+ansi-styles@^3.2.0:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
+  integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
+  dependencies:
+    color-convert "^1.9.0"
+
+ansi-styles@^4.0.0, ansi-styles@^4.1.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
+  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
+  dependencies:
+    color-convert "^2.0.1"
+
+ansi-styles@^6.1.0:
+  version "6.2.1"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.1.tgz#0e62320cf99c21afff3b3012192546aacbfb05c5"
+  integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==
+
+anymatch@~3.1.1, anymatch@~3.1.2:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e"
+  integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
+  dependencies:
+    normalize-path "^3.0.0"
+    picomatch "^2.0.4"
+
+append-field@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/append-field/-/append-field-1.0.0.tgz#1e3440e915f0b1203d23748e78edd7b9b5b43e56"
+  integrity sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==
+
+"aproba@^1.0.3 || ^2.0.0":
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/aproba/-/aproba-2.0.0.tgz#52520b8ae5b569215b354efc0caa3fe1e45a8adc"
+  integrity sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==
+
+are-we-there-yet@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz#372e0e7bd279d8e94c653aaa1f67200884bf3e1c"
+  integrity sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==
+  dependencies:
+    delegates "^1.0.0"
+    readable-stream "^3.6.0"
+
+argparse@^1.0.7:
+  version "1.0.10"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
+  integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
+  dependencies:
+    sprintf-js "~1.0.2"
+
+argparse@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
+  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
+
+array-buffer-byte-length@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/array-buffer-byte-length/-/array-buffer-byte-length-1.0.1.tgz#1e5583ec16763540a27ae52eed99ff899223568f"
+  integrity sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==
+  dependencies:
+    call-bind "^1.0.5"
+    is-array-buffer "^3.0.4"
+
+array-flatten@1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/array-flatten/-/array-flatten-1.1.1.tgz#9a5f699051b1e7073328f2a008968b64ea2955d2"
+  integrity sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==
+
+array.prototype.map@^1.0.1:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/array.prototype.map/-/array.prototype.map-1.0.7.tgz#82fa4d6027272d1fca28a63bbda424d0185d78a7"
+  integrity sha512-XpcFfLoBEAhezrrNw1V+yLXkE7M6uR7xJEsxbG6c/V9v043qurwVJB9r9UTnoSioFDoz1i1VOydpWGmJpfVZbg==
+  dependencies:
+    call-bind "^1.0.7"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.2"
+    es-array-method-boxes-properly "^1.0.0"
+    es-object-atoms "^1.0.0"
+    is-string "^1.0.7"
+
+arraybuffer.prototype.slice@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.3.tgz#097972f4255e41bc3425e37dc3f6421cf9aefde6"
+  integrity sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==
+  dependencies:
+    array-buffer-byte-length "^1.0.1"
+    call-bind "^1.0.5"
+    define-properties "^1.2.1"
+    es-abstract "^1.22.3"
+    es-errors "^1.2.1"
+    get-intrinsic "^1.2.3"
+    is-array-buffer "^3.0.4"
+    is-shared-array-buffer "^1.0.2"
+
+arrify@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/arrify/-/arrify-2.0.1.tgz#c9655e9331e0abcd588d2a7cad7e9956f66701fa"
+  integrity sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==
+
+async-retry@^1.3.3:
+  version "1.3.3"
+  resolved "https://registry.yarnpkg.com/async-retry/-/async-retry-1.3.3.tgz#0e7f36c04d8478e7a58bdbed80cedf977785f280"
+  integrity sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==
+  dependencies:
+    retry "0.13.1"
+
+asynckit@^0.4.0:
+  version "0.4.0"
+  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
+  integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
+
+at-least-node@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/at-least-node/-/at-least-node-1.0.0.tgz#602cd4b46e844ad4effc92a8011a3c46e0238dc2"
+  integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==
+
+available-typed-arrays@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz#a5cc375d6a03c2efc87a553f3e0b1522def14846"
+  integrity sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==
+  dependencies:
+    possible-typed-array-names "^1.0.0"
+
+axios@^1.6.7:
+  version "1.7.2"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-1.7.2.tgz#b625db8a7051fbea61c35a3cbb3a1daa7b9c7621"
+  integrity sha512-2A8QhOMrbomlDuiLeK9XibIBzuHeRcqqNOHp0Cyp5EoJ1IFDh+XZH3A6BkXtv0K4gFGCI0Y4BM7B1wOEi0Rmgw==
+  dependencies:
+    follow-redirects "^1.15.6"
+    form-data "^4.0.0"
+    proxy-from-env "^1.1.0"
+
+balanced-match@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
+  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
+
+base64-js@^1.3.0, base64-js@^1.3.1:
+  version "1.5.1"
+  resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
+  integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
+
+base64url@3.x.x:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/base64url/-/base64url-3.0.1.tgz#6399d572e2bc3f90a9a8b22d5dbb0a32d33f788d"
+  integrity sha512-ir1UPr3dkwexU7FdV8qBBbNDRUhMmIekYMFZfi+C/sLNnRESKPl23nB9b2pltqfOQNnGzsDdId90AEtG5tCx4A==
+
+bcrypt@5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/bcrypt/-/bcrypt-5.1.1.tgz#0f732c6dcb4e12e5b70a25e326a72965879ba6e2"
+  integrity sha512-AGBHOG5hPYZ5Xl9KXzU5iKq9516yEmvCKDg3ecP5kX2aB6UqTeXZxk2ELnDgDm6BQSMlLt9rDB4LoSMx0rYwww==
+  dependencies:
+    "@mapbox/node-pre-gyp" "^1.0.11"
+    node-addon-api "^5.0.0"
+
+bignumber.js@^9.0.0:
+  version "9.1.2"
+  resolved "https://registry.yarnpkg.com/bignumber.js/-/bignumber.js-9.1.2.tgz#b7c4242259c008903b13707983b5f4bbd31eda0c"
+  integrity sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==
+
+binary-extensions@^2.0.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.3.0.tgz#f6e14a97858d327252200242d4ccfe522c445522"
+  integrity sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==
+
+bl@^6.0.11:
+  version "6.0.14"
+  resolved "https://registry.yarnpkg.com/bl/-/bl-6.0.14.tgz#b9ae9862118a3d2ebec999c5318466012314f96c"
+  integrity sha512-TJfbvGdL7KFGxTsEbsED7avqpFdY56q9IW0/aiytyheJzxST/+Io6cx/4Qx0K2/u0BPRDs65mjaQzYvMZeNocQ==
+  dependencies:
+    "@types/readable-stream" "^4.0.0"
+    buffer "^6.0.3"
+    inherits "^2.0.4"
+    readable-stream "^4.2.0"
+
+bluebird@^3.7.2:
+  version "3.7.2"
+  resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.7.2.tgz#9f229c15be272454ffa973ace0dbee79a1b0c36f"
+  integrity sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==
+
+body-parser@1.20.1:
+  version "1.20.1"
+  resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.1.tgz#b1812a8912c195cd371a3ee5e66faa2338a5c668"
+  integrity sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==
+  dependencies:
+    bytes "3.1.2"
+    content-type "~1.0.4"
+    debug "2.6.9"
+    depd "2.0.0"
+    destroy "1.2.0"
+    http-errors "2.0.0"
+    iconv-lite "0.4.24"
+    on-finished "2.4.1"
+    qs "6.11.0"
+    raw-body "2.5.1"
+    type-is "~1.6.18"
+    unpipe "1.0.0"
+
+boxen@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/boxen/-/boxen-4.2.0.tgz#e411b62357d6d6d36587c8ac3d5d974daa070e64"
+  integrity sha512-eB4uT9RGzg2odpER62bBwSLvUeGC+WbRjjyyFhGsKnc8wp/m0+hQsMUvUe3H2V0D5vw0nBdO1hCJoZo5mKeuIQ==
+  dependencies:
+    ansi-align "^3.0.0"
+    camelcase "^5.3.1"
+    chalk "^3.0.0"
+    cli-boxes "^2.2.0"
+    string-width "^4.1.0"
+    term-size "^2.1.0"
+    type-fest "^0.8.1"
+    widest-line "^3.1.0"
+
+brace-expansion@^1.1.7:
+  version "1.1.11"
+  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
+  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
+  dependencies:
+    balanced-match "^1.0.0"
+    concat-map "0.0.1"
+
+brace-expansion@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae"
+  integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==
+  dependencies:
+    balanced-match "^1.0.0"
+
+braces@~3.0.2:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.3.tgz#490332f40919452272d55a8480adc0c441358789"
+  integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==
+  dependencies:
+    fill-range "^7.1.1"
+
+browser-stdout@1.3.1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
+  integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
+
+buffer-equal-constant-time@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz#f8e71132f7ffe6e01a5c9697a4c6f3e48d5cc819"
+  integrity sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==
+
+buffer-from@^1.0.0:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
+  integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
+
+buffer-writer@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/buffer-writer/-/buffer-writer-2.0.0.tgz#ce7eb81a38f7829db09c873f2fbb792c0c98ec04"
+  integrity sha512-a7ZpuTZU1TRtnwyCNW3I5dc0wWNC3VR9S++Ewyk2HHZdrO3CQJqSpd+95Us590V6AL7JqUAH2IwZ/398PmNFgw==
+
+buffer@^6.0.3:
+  version "6.0.3"
+  resolved "https://registry.yarnpkg.com/buffer/-/buffer-6.0.3.tgz#2ace578459cc8fbe2a70aaa8f52ee63b6a74c6c6"
+  integrity sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==
+  dependencies:
+    base64-js "^1.3.1"
+    ieee754 "^1.2.1"
+
+busboy@^0.2.11:
+  version "0.2.14"
+  resolved "https://registry.yarnpkg.com/busboy/-/busboy-0.2.14.tgz#6c2a622efcf47c57bbbe1e2a9c37ad36c7925453"
+  integrity sha512-InWFDomvlkEj+xWLBfU3AvnbVYqeTWmQopiW0tWWEy5yehYm2YkGEc59sUmw/4ty5Zj/b0WHGs1LgecuBSBGrg==
+  dependencies:
+    dicer "0.2.5"
+    readable-stream "1.1.x"
+
+bytes@3.1.2:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5"
+  integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==
+
+cacheable-request@^6.0.0:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/cacheable-request/-/cacheable-request-6.1.0.tgz#20ffb8bd162ba4be11e9567d823db651052ca912"
+  integrity sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg==
+  dependencies:
+    clone-response "^1.0.2"
+    get-stream "^5.1.0"
+    http-cache-semantics "^4.0.0"
+    keyv "^3.0.0"
+    lowercase-keys "^2.0.0"
+    normalize-url "^4.1.0"
+    responselike "^1.0.2"
+
+call-bind@^1.0.2, call-bind@^1.0.5, call-bind@^1.0.6, call-bind@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.7.tgz#06016599c40c56498c18769d2730be242b6fa3b9"
+  integrity sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==
+  dependencies:
+    es-define-property "^1.0.0"
+    es-errors "^1.3.0"
+    function-bind "^1.1.2"
+    get-intrinsic "^1.2.4"
+    set-function-length "^1.2.1"
+
+call-me-maybe@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/call-me-maybe/-/call-me-maybe-1.0.2.tgz#03f964f19522ba643b1b0693acb9152fe2074baa"
+  integrity sha512-HpX65o1Hnr9HH25ojC1YGs7HCQLq0GCOibSaWER0eNpgJ/Z1MZv2mTc7+xh6WOPxbRVcmgbv4hGU+uSQ/2xFZQ==
+
+camelcase@^5.0.0, camelcase@^5.3.1:
+  version "5.3.1"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
+  integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
+
+chalk@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-3.0.0.tgz#3f73c2bf526591f574cc492c51e2456349f844e4"
+  integrity sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==
+  dependencies:
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
+chalk@^4.0.0:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
+  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
+  dependencies:
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
+chokidar@3.4.2:
+  version "3.4.2"
+  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.4.2.tgz#38dc8e658dec3809741eb3ef7bb0a47fe424232d"