Initial version

2025-10-18 01:38:52 +00:00 · 2025-10-18 01:38:52 +00:00 · 4e268c4478
commit 4e268c4478
543 changed files with 113072 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,3 @@
+node_modules/
+*/node_modules/
+*/build/
--- a/502.html
+++ b/502.html
@ -0,0 +1,187 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Service Starting</title>
+    <style>
+        body {
+            font-family: sans-serif;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+            background-color: #EFF2FF;
+            margin: 0;
+            padding: 20px;
+        }
+
+        .container {
+            text-align: center;
+            padding: 30px 40px;
+            background-color: #fff;
+            border-radius: 20px;
+            margin-bottom: 20px;
+            max-width: 538px;
+            width: 100%;
+            box-shadow: 0 13px 34px 0 rgba(167, 187, 242, 0.2);
+            box-sizing: border-box;
+        }
+
+        #status-heading {
+            font-size: 24px;
+            font-weight: 700;
+            color: #02004E;
+            margin-bottom: 20px;
+        }
+
+        h2 {
+            color: #333;
+            margin-bottom: 15px;
+        }
+
+        p {
+            color: #666;
+            font-size: 1.1em;
+            margin-bottom: 10px;
+        }
+
+        .tip {
+            font-weight: 300;
+            font-size: 17px;
+            line-height: 150%;
+            letter-spacing: 0;
+            text-align: center;
+            margin-top: 30px;
+        }
+
+        .loader-container {
+            position: relative;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+
+        .loader {
+            width: 100px;
+            aspect-ratio: 1;
+            border-radius: 50%;
+            background:
+                radial-gradient(farthest-side, #5C7EF1 94%, #0000) top/8px 8px no-repeat,
+                conic-gradient(#0000 30%, #5C7EF1);
+            -webkit-mask: radial-gradient(farthest-side, #0000 calc(100% - 8px), #000 0);
+            animation: l13 2s infinite linear;
+        }
+
+        @keyframes l13 {
+            100% {
+                transform: rotate(1turn)
+            }
+        }
+
+        .app-logo {
+            position: absolute;
+            width: 36px;
+        }
+
+        .panel {
+            padding: 0 18px;
+            display: none;
+            background-color: white;
+            overflow: hidden;
+            margin-top: 10px;
+        }
+        .show {
+            display: block;
+        }
+
+        .project-info {
+            border: 1px solid #8C9DFF;
+            border-radius: 10px;
+            padding: 12px 16px;
+            max-width: 600px;
+            margin: 40px auto;
+            background-color: #FBFCFF;
+        }
+
+        .project-info h2 {
+            color: #02004E;
+            font-size: 14px;
+            font-weight: 500;
+            margin-bottom: 10px;
+            text-align: left;
+        }
+
+        .project-info p {
+            color: #686791;
+            font-size: 12px;
+            font-weight: 400;
+            text-align: left;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <h2 id="status-heading">Loading the app, just a moment…</h2>
+        <p class="tip">The application is currently launching. The page will automatically refresh once site is
+            available.</p>
+        <div class="project-info">
+            <h2>Car zone</h2>
+            <p>Carzone: Multi-tenant SaaS for car rental agencies.</p>
+        </div>
+        <div class="loader-container">
+            <img src="https://flatlogic.com/blog/wp-content/uploads/2025/05/logo-bot-1.png" alt="App Logo"
+                class="app-logo">
+            <div class="loader"></div>
+        </div>
+        <div class="panel">
+            <video width="100%" height="315" controls loop>
+                <source
+                    src="https://flatlogic.com/blog/wp-content/uploads/2025/04/20250430_1336_professional_dynamo_spinner_simple_compose_01jt349yvtenxt7xhg8hhr85j8.mp4"
+                    type="video/mp4">
+                Your browser does not support the video tag.
+            </video>
+        </div>
+    </div>
+    <script>
+        function checkAvailability() {
+            fetch('/')
+                .then(response => {
+                    if (response.ok) {
+                        window.location.reload();
+                    } else {
+                        setTimeout(checkAvailability, 5000);
+                    }
+                })
+                .catch(() => {
+                    setTimeout(checkAvailability, 5000);
+                });
+        }
+        document.addEventListener('DOMContentLoaded', checkAvailability);
+
+        document.addEventListener('DOMContentLoaded', function () {
+            const appTitle = document.querySelector('#status-heading');
+            const panel = document.querySelector('.panel');
+            const video = panel.querySelector('video');
+            let clickCount = 0;
+
+            appTitle.addEventListener('click', function () {
+                clickCount++;
+                if (clickCount === 5) {
+                    panel.classList.toggle('show');
+                    if (panel.classList.contains('show')) {
+                        video.play();
+                    } else {
+                        video.pause();
+                    }
+                    clickCount = 0;
+                }
+            });
+        });
+    </script>
+</body>
+
+</html>
--- a/17
+++ b/17
@ -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"]
+
--- a/Dockerfile.dev
+++ b/Dockerfile.dev
@ -0,0 +1,85 @@
+# 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 curl
+RUN apk add --no-cache lsof procps
+RUN yarn global add concurrently
+
+RUN apk add --no-cache \
+    chromium \
+    nss \
+    freetype \
+    harfbuzz \
+    ttf-freefont \
+    fontconfig
+
+ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true
+ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium-browser
+
+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 all files from root to /app
+COPY . /app
+
+# Copy Nginx configuration
+COPY nginx.conf /etc/nginx/nginx.conf
+
+# Copy custom error page
+COPY 502.html /usr/share/nginx/html/502.html
+
+# Change owner and permissions of the error page
+RUN chown nginx:nginx /usr/share/nginx/html/502.html && \
+    chmod 644 /usr/share/nginx/html/502.html
+
+# Expose the port the app runs on
+EXPOSE 8080
+ENV NODE_ENV=dev_stage
+ENV FRONT_PORT=3001
+ENV BACKEND_PORT=3000
+ENV APP_SHELL_PORT=4000
+
+
+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 backend (port 3000) to be available...' && \
+  while ! nc -z localhost ${BACKEND_PORT}; do \
+    sleep 2; \
+  done && \
+  echo 'Backend is up. Starting app_shell for Git check...' && \
+  yarn --cwd /app/app-shell start && \
+  wait $NGINX_PID"]
--- a/1
+++ b/1
@ -0,0 +1 @@
+https://flatlogic.com/
--- a/README.md
+++ b/README.md
@ -0,0 +1,200 @@
+
+
+# Car zone
+
+## 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`
--- a/app-shell/.eslintrc.cjs
+++ b/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',
+    },
+  },
+];
--- a/app-shell/.prettierrc
+++ b/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"
+}
--- a/app-shell/.sequelizerc
+++ b/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")
+};
--- a/app-shell/Dockerfile
+++ b/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" ]
--- a/app-shell/README.md
+++ b/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`
--- a/app-shell/package.json
+++ b/app-shell/package.json
@ -0,0 +1,43 @@
+{
+  "name": "app-shell",
+  "description": "app-shell",
+  "scripts": {
+    "start": "node ./src/index.js"
+  },
+  "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",
+    "puppeteer": "^24.10.0",
+    "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"
+  }
+}
--- a/app-shell/src/_schema.json
+++ b/app-shell/src/_schema.json
--- a/app-shell/src/config.js
+++ b/app-shell/src/config.js
@ -0,0 +1,18 @@
+
+
+const config = {
+  admin_pass: "9023ec63",
+  admin_email: "admin@flatlogic.com",
+  schema_encryption_key: process.env.SCHEMA_ENCRYPTION_KEY || '',
+
+  project_uuid: '9023ec63-5313-4bee-9c57-4d8ac698b0e7',
+  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;
--- a/app-shell/src/helpers.js
+++ b/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' });
+  }
+};
--- a/app-shell/src/index.js
+++ b/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 = '35035';
+    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 ? result.message : result);
+          // 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;
--- a/app-shell/src/middlewares/check-permissions.js
+++ b/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;
--- a/app-shell/src/middlewares/modify-path.js
+++ b/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;
--- a/app-shell/src/routes/executor.js
+++ b/app-shell/src/routes/executor.js
@ -0,0 +1,346 @@
+const express = require('express');
+const multer = require('multer');
+const upload = multer({ dest: 'uploads/' });
+const fs = require('fs');
+
+const ExecutorService = require('../services/executor');
+const { takeScreenshot } = require("../services/screenshot_service");
+
+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.post(
+    '/search_files',
+    wrapAsync(async (req, res) => {
+        try {
+            const { searchStrings } = req.body;
+
+            if (
+                typeof searchStrings !== 'string' &&
+                !(
+                    Array.isArray(searchStrings) &&
+                    searchStrings.every(item => typeof item === 'string')
+                )
+            ) {
+                return res.status(400).send({ error: 'searchStrings must be a string or an array of strings' });
+            }
+
+            const result = await ExecutorService.searchFiles(searchStrings);
+            res.status(200).send(result);
+        } catch (error) {
+            res.status(500).send({ error: error.message });
+        }
+    }),
+);
+
+router.post(
+    '/screenshot',
+    wrapAsync(async (req, res) => {
+        const FRONT_PORT = process.env.FRONT_PORT || 3001;
+        const targetUrl = `http://localhost:${FRONT_PORT}${req.body.url || '/'}`;
+
+        const filename = req.query.filename || `screenshot-${Date.now()}.png`;
+        const fullPage = req.query.fullPage !== 'false';
+
+        try {
+            console.log(`[App-Shell/Screenshot Route]: request to take screenshot of ${targetUrl} with filename ${filename} and fullPage=${fullPage}`);
+            const outputPath = await takeScreenshot(targetUrl, filename, fullPage);
+
+            res.sendFile(outputPath, async (err) => {
+                if (err) {
+                    console.error(`[App-Shell/Screenshot Route]: error sending screenshot ${outputPath}:`, err);
+                    if (err.code === 'ENOENT') {
+                        res.status(404).send('Screenshot not found.');
+                    } else {
+                        res.status(500).send('Error sending screenshot: ' + err.message);
+                    }
+                } else {
+                    console.log(`[App-Shell/Screenshot Route]: Screenshot sent successfully: ${outputPath}`);
+                }
+            });
+
+        } catch (error) {
+            console.error(`[App-Shell/Screenshot Route]: Could not take screenshot of ${targetUrl}:`, error);
+            res.status(500).send(`Error taking screenshot: ${error.message}`);
+        }
+    })
+)
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;
--- a/app-shell/src/routes/vcs.js
+++ b/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, dev_schema } = req.body;
+    const result = await VSC.commitChanges(message, files, dev_schema);
+    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;
--- a/app-shell/src/services/database.js
+++ b/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();
--- a/app-shell/src/services/executor.js
+++ b/app-shell/src/services/executor.js
--- a/app-shell/src/services/notifications/errors/forbidden.js
+++ b/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;
+  }
+};
--- a/app-shell/src/services/notifications/errors/validation.js
+++ b/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;
+  }
+};
--- a/app-shell/src/services/notifications/helpers.js
+++ b/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;
--- a/app-shell/src/services/notifications/list.js
+++ b/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;
--- a/app-shell/src/services/project-events.js
+++ b/app-shell/src/services/project-events.js
@ -0,0 +1,67 @@
+const axios = require('axios');
+const config = require('../config.js');
+
+class ProjectEventsService {
+    /**
+     * Sends a project event to the Rails backend
+     *
+     * @param {string} eventType - Type of the event
+     * @param {object} payload - Event payload data
+     * @param {object} options - Additional options
+     * @param {string} [options.conversationId] - Optional conversation ID
+     * @param {boolean} [options.isError=false] - Whether this is an error event
+     * @returns {Promise<object>} - Response from the webhook
+     */
+    static async sendEvent(eventType, payload = {}, options = {}) {
+        try {
+            console.log(`[DEBUG] Sending project event: ${eventType}`);
+
+            const webhookUrl = `https://flatlogic.com/projects/events_webhook`;
+
+            // Prepare the event data
+            const eventData = {
+                project_uuid: config.project_uuid,
+                event_type: eventType,
+                payload: {
+                    ...payload,
+                    message: `[APP] ${payload.message}`,
+                    is_error: options.isError || false,
+                    system_message: true,
+                    is_command_info: true
+                }
+            };
+
+            // Add conversation ID if provided
+            if (options.conversationId) {
+                eventData.conversation_id = options.conversationId;
+            }
+
+            const headers = {
+                'Content-Type': 'application/json',
+                'x-project-uuid': config.project_uuid
+            };
+
+            console.log(`[DEBUG] Event data: ${JSON.stringify(eventData)}`);
+
+            const response = await axios.post(webhookUrl, eventData, { headers });
+
+            console.log(`[DEBUG] Event sent successfully, status: ${response.status}`);
+            return response.data;
+        } catch (error) {
+            console.error(`[ERROR] Failed to send project event: ${error.message}`);
+            if (error.response) {
+                console.error(`[ERROR] Response status: ${error.response.status}`);
+                console.error(`[ERROR] Response data: ${JSON.stringify(error.response.data)}`);
+            }
+
+            // Don't throw the error, just return a failed status
+            // This prevents errors in the event service from breaking app functionality
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+}
+
+module.exports = ProjectEventsService;
--- a/app-shell/src/services/screenshot_service.js
+++ b/app-shell/src/services/screenshot_service.js
@ -0,0 +1,83 @@
+const puppeteer = require('puppeteer');
+const path = require('path');
+const fs = require('fs/promises');
+const config = require('../config');
+
+const BACKEND_URL = process.env.BACKEND_URL || 'http://localhost:3000';
+const SCREENSHOT_DIR = process.env.SCREENSHOT_DIR || '/tmp/screenshots';
+fs.mkdir(SCREENSHOT_DIR, { recursive: true }).catch(console.error);
+
+async function takeScreenshot(url, filename = `screenshot-${Date.now()}.png`, fullPage = true) {
+  let browser;
+
+  const response = await axios.post(
+      `${BACKEND_URL}/api/auth/signin/local`,
+      { email: config.admin_email, password: config.admin_pass },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }
+  );
+
+  const token = response.data;
+
+  const outputPath = path.join(SCREENSHOT_DIR, filename);
+
+  try {
+    browser = await puppeteer.launch({
+      headless: true,
+      args: [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--disable-dev-shm-usage',
+        '--disable-accelerated-2d-canvas',
+        '--disable-gpu',
+        'window-size=1920,1080'
+      ]
+    });
+    const page = await browser.newPage();
+
+    await page.setViewport({ width: 1920, height: 1080 });
+
+    if (token) {
+      await page.setRequestInterception(true);
+
+      page.on('request', interceptedRequest => {
+        if (interceptedRequest.isInterceptResolutionHandled()) {
+          return;
+        }
+
+        const headers = interceptedRequest.headers();
+        if (!headers['authorization'] && !headers['Authorization']) {
+          headers['Authorization'] = `Bearer ${token}`;
+        }
+
+        interceptedRequest.continue({ headers });
+      });
+
+      page.on('requestfailed', request => {
+        console.error(`[ScreenshotService]: Request failed: ${request.url()} - ${request.failure().errorText}`);
+      });
+    }
+
+    await page.goto(url, { waitUntil: 'load', timeout: 60000 });
+
+    await page.screenshot({
+      path: outputPath,
+      fullPage: true,
+    });
+
+    console.log(`[ScreenshotService]: Screenshot saved to ${outputPath}`);
+    return outputPath;
+  } catch (error) {
+    console.error(`[ScreenshotService]: Error taking screenshot: ${error.message}`);
+    throw error;
+  } finally {
+    if (browser) {
+      await browser.close();
+    }
+  }
+}
+
+module.exports = { takeScreenshot };
--- a/app-shell/src/services/vcs.js
+++ b/app-shell/src/services/vcs.js
--- a/app-shell/yarn.lock
+++ b/app-shell/yarn.lock
--- a/backend/.prettierrc
+++ b/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"
+}
--- a/backend/.sequelizerc
+++ b/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")
+};
--- a/backend/Dockerfile
+++ b/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" ]
--- a/backend/README.md
+++ b/backend/README.md
@ -0,0 +1,67 @@
+#Car zone - 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_car_zone;`
+
+- Then give that new user privileges to the new database then quit the `psql`.
+  - `postgres=> GRANT ALL PRIVILEGES ON DATABASE db_car_zone 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`
--- a/backend/package.json
+++ b/backend/package.json
@ -0,0 +1,53 @@
+{
+  "name": "carzone",
+  "description": "Car zone - template backend",
+  "scripts": {
+    "start": "npm run db:migrate && npm run db:seed && npm run watch",
+    "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",
+    "watch": "node watcher.js"
+  },
+  "dependencies": {
+    "@google-cloud/storage": "^5.18.2",
+    "axios": "^1.6.7",
+    "bcrypt": "5.1.1",
+    "chokidar": "^4.0.3",
+    "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"
+  }
+}
--- a/backend/src/auth/auth.js
+++ b/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 });
+    });
+}
--- a/backend/src/config.js
+++ b/backend/src/config.js
@ -0,0 +1,77 @@
+const os = require('os');
+
+const config = {
+  gcloud: {
+    bucket: 'fldemo-files',
+    hash: '8ccab677e922e55fea01395b0c4c415e',
+  },
+  bcrypt: {
+    saltRounds: 12,
+  },
+  admin_pass: '9023ec63',
+  user_pass: '4d8ac698b0e7',
+  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: 'Car zone <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: 'Customer Support',
+  },
+
+  project_uuid: '9023ec63-5313-4bee-9c57-4d8ac698b0e7',
+  flHost:
+    process.env.NODE_ENV === 'production' ||
+    process.env.NODE_ENV === 'dev_stage'
+      ? 'https://flatlogic.com/projects'
+      : 'http://localhost:3000/projects',
+
+  gpt_key: process.env.GPT_KEY || '',
+};
+
+config.pexelsKey = process.env.PEXELS_KEY || '';
+config.pexelsQuery = 'Abstract car rental concept';
+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;
--- a/backend/src/db/api/agences.js
+++ b/backend/src/db/api/agences.js
@ -0,0 +1,341 @@
+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 AgencesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const agences = await db.agences.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    return agences;
+  }
+
+  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 agencesData = 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 agences = await db.agences.bulkCreate(agencesData, { transaction });
+
+    // For each item created, replace relation files
+
+    return agences;
+  }
+
+  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 agences = await db.agences.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await agences.update(updatePayload, { transaction });
+
+    return agences;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const agences = await db.agences.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of agences) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of agences) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return agences;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const agences = await db.agences.findByPk(id, options);
+
+    await agences.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await agences.destroy({
+      transaction,
+    });
+
+    return agences;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const agences = await db.agences.findOne({ where }, { transaction });
+
+    if (!agences) {
+      return agences;
+    }
+
+    const output = agences.get({ plain: true });
+
+    output.users_agences = await agences.getUsers_agences({
+      transaction,
+    });
+
+    output.claims_agences = await agences.getClaims_agences({
+      transaction,
+    });
+
+    output.clients_agences = await agences.getClients_agences({
+      transaction,
+    });
+
+    output.company_profiles_agences = await agences.getCompany_profiles_agences(
+      {
+        transaction,
+      },
+    );
+
+    output.drivers_agences = await agences.getDrivers_agences({
+      transaction,
+    });
+
+    output.expenses_agences = await agences.getExpenses_agences({
+      transaction,
+    });
+
+    output.guarantees_agences = await agences.getGuarantees_agences({
+      transaction,
+    });
+
+    output.infractions_agences = await agences.getInfractions_agences({
+      transaction,
+    });
+
+    output.invoices_saas_agences = await agences.getInvoices_saas_agences({
+      transaction,
+    });
+
+    output.maintenance_agences = await agences.getMaintenance_agences({
+      transaction,
+    });
+
+    output.payments_agences = await agences.getPayments_agences({
+      transaction,
+    });
+
+    output.plans_agences = await agences.getPlans_agences({
+      transaction,
+    });
+
+    output.reservations_agences = await agences.getReservations_agences({
+      transaction,
+    });
+
+    output.subscriptions_agences = await agences.getSubscriptions_agences({
+      transaction,
+    });
+
+    output.tenants_agences = await agences.getTenants_agences({
+      transaction,
+    });
+
+    output.vehicle_conditions_agences =
+      await agences.getVehicle_conditions_agences({
+        transaction,
+      });
+
+    output.vehicles_agences = await agences.getVehicles_agences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    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('agences', '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.agencesId;
+    }
+
+    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.agences.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('agences', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.agences.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,
+    }));
+  }
+};
--- a/backend/src/db/api/claims.js
+++ b/backend/src/db/api/claims.js
@ -0,0 +1,463 @@
+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 ClaimsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const claims = await db.claims.create(
+      {
+        id: data.id || undefined,
+
+        category: data.category || null,
+        description: data.description || null,
+        status: data.status || null,
+        attachments: data.attachments || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await claims.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await claims.setClient(data.client || null, {
+      transaction,
+    });
+
+    await claims.setReservation(data.reservation || null, {
+      transaction,
+    });
+
+    await claims.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return claims;
+  }
+
+  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 claimsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      category: item.category || null,
+      description: item.description || null,
+      status: item.status || null,
+      attachments: item.attachments || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const claims = await db.claims.bulkCreate(claimsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return claims;
+  }
+
+  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 claims = await db.claims.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.category !== undefined) updatePayload.category = data.category;
+
+    if (data.description !== undefined)
+      updatePayload.description = data.description;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.attachments !== undefined)
+      updatePayload.attachments = data.attachments;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await claims.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await claims.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.client !== undefined) {
+      await claims.setClient(
+        data.client,
+
+        { transaction },
+      );
+    }
+
+    if (data.reservation !== undefined) {
+      await claims.setReservation(
+        data.reservation,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await claims.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return claims;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const claims = await db.claims.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of claims) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of claims) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return claims;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const claims = await db.claims.findByPk(id, options);
+
+    await claims.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await claims.destroy({
+      transaction,
+    });
+
+    return claims;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const claims = await db.claims.findOne({ where }, { transaction });
+
+    if (!claims) {
+      return claims;
+    }
+
+    const output = claims.get({ plain: true });
+
+    output.tenant = await claims.getTenant({
+      transaction,
+    });
+
+    output.client = await claims.getClient({
+      transaction,
+    });
+
+    output.reservation = await claims.getReservation({
+      transaction,
+    });
+
+    output.agences = await claims.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clients,
+        as: 'client',
+
+        where: filter.client
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.client
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  first_name: {
+                    [Op.or]: filter.client
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.reservations,
+        as: 'reservation',
+
+        where: filter.reservation
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.reservation
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  ref: {
+                    [Op.or]: filter.reservation
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.category) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('claims', 'category', filter.category),
+        };
+      }
+
+      if (filter.description) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('claims', 'description', filter.description),
+        };
+      }
+
+      if (filter.attachments) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('claims', 'attachments', filter.attachments),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.claims.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('claims', 'category', query),
+        ],
+      };
+    }
+
+    const records = await db.claims.findAll({
+      attributes: ['id', 'category'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['category', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.category,
+    }));
+  }
+};
--- a/backend/src/db/api/clients.js
+++ b/backend/src/db/api/clients.js
@ -0,0 +1,539 @@
+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 ClientsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const clients = await db.clients.create(
+      {
+        id: data.id || undefined,
+
+        first_name: data.first_name || null,
+        last_name: data.last_name || null,
+        birth_date: data.birth_date || null,
+        phone: data.phone || null,
+        address: data.address || null,
+        id_type: data.id_type || null,
+        id_number: data.id_number || null,
+        id_issue_date: data.id_issue_date || null,
+        license_number: data.license_number || null,
+        license_issue_date: data.license_issue_date || null,
+        id_copy_url: data.id_copy_url || null,
+        license_copy_url: data.license_copy_url || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await clients.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await clients.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return clients;
+  }
+
+  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 clientsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      first_name: item.first_name || null,
+      last_name: item.last_name || null,
+      birth_date: item.birth_date || null,
+      phone: item.phone || null,
+      address: item.address || null,
+      id_type: item.id_type || null,
+      id_number: item.id_number || null,
+      id_issue_date: item.id_issue_date || null,
+      license_number: item.license_number || null,
+      license_issue_date: item.license_issue_date || null,
+      id_copy_url: item.id_copy_url || null,
+      license_copy_url: item.license_copy_url || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const clients = await db.clients.bulkCreate(clientsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return clients;
+  }
+
+  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 clients = await db.clients.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.first_name !== undefined)
+      updatePayload.first_name = data.first_name;
+
+    if (data.last_name !== undefined) updatePayload.last_name = data.last_name;
+
+    if (data.birth_date !== undefined)
+      updatePayload.birth_date = data.birth_date;
+
+    if (data.phone !== undefined) updatePayload.phone = data.phone;
+
+    if (data.address !== undefined) updatePayload.address = data.address;
+
+    if (data.id_type !== undefined) updatePayload.id_type = data.id_type;
+
+    if (data.id_number !== undefined) updatePayload.id_number = data.id_number;
+
+    if (data.id_issue_date !== undefined)
+      updatePayload.id_issue_date = data.id_issue_date;
+
+    if (data.license_number !== undefined)
+      updatePayload.license_number = data.license_number;
+
+    if (data.license_issue_date !== undefined)
+      updatePayload.license_issue_date = data.license_issue_date;
+
+    if (data.id_copy_url !== undefined)
+      updatePayload.id_copy_url = data.id_copy_url;
+
+    if (data.license_copy_url !== undefined)
+      updatePayload.license_copy_url = data.license_copy_url;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await clients.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await clients.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await clients.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return clients;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const clients = await db.clients.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of clients) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of clients) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return clients;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const clients = await db.clients.findByPk(id, options);
+
+    await clients.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await clients.destroy({
+      transaction,
+    });
+
+    return clients;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const clients = await db.clients.findOne({ where }, { transaction });
+
+    if (!clients) {
+      return clients;
+    }
+
+    const output = clients.get({ plain: true });
+
+    output.claims_client = await clients.getClaims_client({
+      transaction,
+    });
+
+    output.reservations_client = await clients.getReservations_client({
+      transaction,
+    });
+
+    output.tenant = await clients.getTenant({
+      transaction,
+    });
+
+    output.agences = await clients.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.first_name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('clients', 'first_name', filter.first_name),
+        };
+      }
+
+      if (filter.last_name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('clients', 'last_name', filter.last_name),
+        };
+      }
+
+      if (filter.phone) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('clients', 'phone', filter.phone),
+        };
+      }
+
+      if (filter.address) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('clients', 'address', filter.address),
+        };
+      }
+
+      if (filter.id_number) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('clients', 'id_number', filter.id_number),
+        };
+      }
+
+      if (filter.license_number) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'clients',
+            'license_number',
+            filter.license_number,
+          ),
+        };
+      }
+
+      if (filter.id_copy_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('clients', 'id_copy_url', filter.id_copy_url),
+        };
+      }
+
+      if (filter.license_copy_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'clients',
+            'license_copy_url',
+            filter.license_copy_url,
+          ),
+        };
+      }
+
+      if (filter.birth_dateRange) {
+        const [start, end] = filter.birth_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            birth_date: {
+              ...where.birth_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            birth_date: {
+              ...where.birth_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.id_issue_dateRange) {
+        const [start, end] = filter.id_issue_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            id_issue_date: {
+              ...where.id_issue_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            id_issue_date: {
+              ...where.id_issue_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.license_issue_dateRange) {
+        const [start, end] = filter.license_issue_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            license_issue_date: {
+              ...where.license_issue_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            license_issue_date: {
+              ...where.license_issue_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.id_type) {
+        where = {
+          ...where,
+          id_type: filter.id_type,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.clients.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('clients', 'first_name', query),
+        ],
+      };
+    }
+
+    const records = await db.clients.findAll({
+      attributes: ['id', 'first_name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['first_name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.first_name,
+    }));
+  }
+};
--- a/backend/src/db/api/company_profiles.js
+++ b/backend/src/db/api/company_profiles.js
@ -0,0 +1,469 @@
+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 Company_profilesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const company_profiles = await db.company_profiles.create(
+      {
+        id: data.id || undefined,
+
+        legal_name: data.legal_name || null,
+        address: data.address || null,
+        phone: data.phone || null,
+        email: data.email || null,
+        website: data.website || null,
+        rc: data.rc || null,
+        ice: data.ice || null,
+        patente: data.patente || null,
+        logo_url: data.logo_url || null,
+        pdf_footer: data.pdf_footer || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await company_profiles.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await company_profiles.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return company_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 company_profilesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      legal_name: item.legal_name || null,
+      address: item.address || null,
+      phone: item.phone || null,
+      email: item.email || null,
+      website: item.website || null,
+      rc: item.rc || null,
+      ice: item.ice || null,
+      patente: item.patente || null,
+      logo_url: item.logo_url || null,
+      pdf_footer: item.pdf_footer || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const company_profiles = await db.company_profiles.bulkCreate(
+      company_profilesData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return company_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 company_profiles = await db.company_profiles.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.legal_name !== undefined)
+      updatePayload.legal_name = data.legal_name;
+
+    if (data.address !== undefined) updatePayload.address = data.address;
+
+    if (data.phone !== undefined) updatePayload.phone = data.phone;
+
+    if (data.email !== undefined) updatePayload.email = data.email;
+
+    if (data.website !== undefined) updatePayload.website = data.website;
+
+    if (data.rc !== undefined) updatePayload.rc = data.rc;
+
+    if (data.ice !== undefined) updatePayload.ice = data.ice;
+
+    if (data.patente !== undefined) updatePayload.patente = data.patente;
+
+    if (data.logo_url !== undefined) updatePayload.logo_url = data.logo_url;
+
+    if (data.pdf_footer !== undefined)
+      updatePayload.pdf_footer = data.pdf_footer;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await company_profiles.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await company_profiles.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await company_profiles.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return company_profiles;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const company_profiles = await db.company_profiles.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of company_profiles) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of company_profiles) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return company_profiles;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const company_profiles = await db.company_profiles.findByPk(id, options);
+
+    await company_profiles.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await company_profiles.destroy({
+      transaction,
+    });
+
+    return company_profiles;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const company_profiles = await db.company_profiles.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!company_profiles) {
+      return company_profiles;
+    }
+
+    const output = company_profiles.get({ plain: true });
+
+    output.tenant = await company_profiles.getTenant({
+      transaction,
+    });
+
+    output.agences = await company_profiles.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.legal_name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'company_profiles',
+            'legal_name',
+            filter.legal_name,
+          ),
+        };
+      }
+
+      if (filter.address) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('company_profiles', 'address', filter.address),
+        };
+      }
+
+      if (filter.phone) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('company_profiles', 'phone', filter.phone),
+        };
+      }
+
+      if (filter.email) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('company_profiles', 'email', filter.email),
+        };
+      }
+
+      if (filter.website) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('company_profiles', 'website', filter.website),
+        };
+      }
+
+      if (filter.rc) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('company_profiles', 'rc', filter.rc),
+        };
+      }
+
+      if (filter.ice) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('company_profiles', 'ice', filter.ice),
+        };
+      }
+
+      if (filter.patente) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('company_profiles', 'patente', filter.patente),
+        };
+      }
+
+      if (filter.logo_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'company_profiles',
+            'logo_url',
+            filter.logo_url,
+          ),
+        };
+      }
+
+      if (filter.pdf_footer) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'company_profiles',
+            'pdf_footer',
+            filter.pdf_footer,
+          ),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.company_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('company_profiles', 'legal_name', query),
+        ],
+      };
+    }
+
+    const records = await db.company_profiles.findAll({
+      attributes: ['id', 'legal_name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['legal_name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.legal_name,
+    }));
+  }
+};
--- a/backend/src/db/api/drivers.js
+++ b/backend/src/db/api/drivers.js
@ -0,0 +1,459 @@
+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 DriversDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const drivers = await db.drivers.create(
+      {
+        id: data.id || undefined,
+
+        full_name: data.full_name || null,
+        license_number: data.license_number || null,
+        license_issue_date: data.license_issue_date || null,
+        id_copy_url: data.id_copy_url || null,
+        license_copy_url: data.license_copy_url || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await drivers.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await drivers.setReservation(data.reservation || null, {
+      transaction,
+    });
+
+    await drivers.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return drivers;
+  }
+
+  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 driversData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      full_name: item.full_name || null,
+      license_number: item.license_number || null,
+      license_issue_date: item.license_issue_date || null,
+      id_copy_url: item.id_copy_url || null,
+      license_copy_url: item.license_copy_url || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const drivers = await db.drivers.bulkCreate(driversData, { transaction });
+
+    // For each item created, replace relation files
+
+    return drivers;
+  }
+
+  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 drivers = await db.drivers.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.full_name !== undefined) updatePayload.full_name = data.full_name;
+
+    if (data.license_number !== undefined)
+      updatePayload.license_number = data.license_number;
+
+    if (data.license_issue_date !== undefined)
+      updatePayload.license_issue_date = data.license_issue_date;
+
+    if (data.id_copy_url !== undefined)
+      updatePayload.id_copy_url = data.id_copy_url;
+
+    if (data.license_copy_url !== undefined)
+      updatePayload.license_copy_url = data.license_copy_url;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await drivers.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await drivers.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.reservation !== undefined) {
+      await drivers.setReservation(
+        data.reservation,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await drivers.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return drivers;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const drivers = await db.drivers.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of drivers) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of drivers) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return drivers;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const drivers = await db.drivers.findByPk(id, options);
+
+    await drivers.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await drivers.destroy({
+      transaction,
+    });
+
+    return drivers;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const drivers = await db.drivers.findOne({ where }, { transaction });
+
+    if (!drivers) {
+      return drivers;
+    }
+
+    const output = drivers.get({ plain: true });
+
+    output.tenant = await drivers.getTenant({
+      transaction,
+    });
+
+    output.reservation = await drivers.getReservation({
+      transaction,
+    });
+
+    output.agences = await drivers.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.reservations,
+        as: 'reservation',
+
+        where: filter.reservation
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.reservation
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  ref: {
+                    [Op.or]: filter.reservation
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.full_name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('drivers', 'full_name', filter.full_name),
+        };
+      }
+
+      if (filter.license_number) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'drivers',
+            'license_number',
+            filter.license_number,
+          ),
+        };
+      }
+
+      if (filter.id_copy_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('drivers', 'id_copy_url', filter.id_copy_url),
+        };
+      }
+
+      if (filter.license_copy_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'drivers',
+            'license_copy_url',
+            filter.license_copy_url,
+          ),
+        };
+      }
+
+      if (filter.license_issue_dateRange) {
+        const [start, end] = filter.license_issue_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            license_issue_date: {
+              ...where.license_issue_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            license_issue_date: {
+              ...where.license_issue_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.drivers.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('drivers', 'full_name', query),
+        ],
+      };
+    }
+
+    const records = await db.drivers.findAll({
+      attributes: ['id', 'full_name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['full_name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.full_name,
+    }));
+  }
+};
--- a/backend/src/db/api/expenses.js
+++ b/backend/src/db/api/expenses.js
@ -0,0 +1,482 @@
+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 ExpensesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const expenses = await db.expenses.create(
+      {
+        id: data.id || undefined,
+
+        type: data.type || null,
+        category: data.category || null,
+        amount: data.amount || null,
+        date: data.date || null,
+        note: data.note || null,
+        attachment_url: data.attachment_url || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await expenses.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await expenses.setVehicle(data.vehicle || null, {
+      transaction,
+    });
+
+    await expenses.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return expenses;
+  }
+
+  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 expensesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      type: item.type || null,
+      category: item.category || null,
+      amount: item.amount || null,
+      date: item.date || null,
+      note: item.note || null,
+      attachment_url: item.attachment_url || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const expenses = await db.expenses.bulkCreate(expensesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return expenses;
+  }
+
+  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 expenses = await db.expenses.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.type !== undefined) updatePayload.type = data.type;
+
+    if (data.category !== undefined) updatePayload.category = data.category;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    if (data.date !== undefined) updatePayload.date = data.date;
+
+    if (data.note !== undefined) updatePayload.note = data.note;
+
+    if (data.attachment_url !== undefined)
+      updatePayload.attachment_url = data.attachment_url;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await expenses.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await expenses.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.vehicle !== undefined) {
+      await expenses.setVehicle(
+        data.vehicle,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await expenses.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return expenses;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const expenses = await db.expenses.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of expenses) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of expenses) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return expenses;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const expenses = await db.expenses.findByPk(id, options);
+
+    await expenses.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await expenses.destroy({
+      transaction,
+    });
+
+    return expenses;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const expenses = await db.expenses.findOne({ where }, { transaction });
+
+    if (!expenses) {
+      return expenses;
+    }
+
+    const output = expenses.get({ plain: true });
+
+    output.tenant = await expenses.getTenant({
+      transaction,
+    });
+
+    output.vehicle = await expenses.getVehicle({
+      transaction,
+    });
+
+    output.agences = await expenses.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.vehicles,
+        as: 'vehicle',
+
+        where: filter.vehicle
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.vehicle
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  plate_number: {
+                    [Op.or]: filter.vehicle
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.category) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('expenses', 'category', filter.category),
+        };
+      }
+
+      if (filter.note) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('expenses', 'note', filter.note),
+        };
+      }
+
+      if (filter.attachment_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'expenses',
+            'attachment_url',
+            filter.attachment_url,
+          ),
+        };
+      }
+
+      if (filter.amountRange) {
+        const [start, end] = filter.amountRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            amount: {
+              ...where.amount,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            amount: {
+              ...where.amount,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.dateRange) {
+        const [start, end] = filter.dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            date: {
+              ...where.date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            date: {
+              ...where.date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.type) {
+        where = {
+          ...where,
+          type: filter.type,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.expenses.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('expenses', 'category', query),
+        ],
+      };
+    }
+
+    const records = await db.expenses.findAll({
+      attributes: ['id', 'category'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['category', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.category,
+    }));
+  }
+};
--- a/backend/src/db/api/file.js
+++ b/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,
+      });
+    }
+  }
+};
--- a/backend/src/db/api/guarantees.js
+++ b/backend/src/db/api/guarantees.js
@ -0,0 +1,438 @@
+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 GuaranteesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const guarantees = await db.guarantees.create(
+      {
+        id: data.id || undefined,
+
+        method: data.method || null,
+        amount: data.amount || null,
+        status: data.status || null,
+        proof_url: data.proof_url || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await guarantees.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await guarantees.setReservation(data.reservation || null, {
+      transaction,
+    });
+
+    await guarantees.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return guarantees;
+  }
+
+  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 guaranteesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      method: item.method || null,
+      amount: item.amount || null,
+      status: item.status || null,
+      proof_url: item.proof_url || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const guarantees = await db.guarantees.bulkCreate(guaranteesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return guarantees;
+  }
+
+  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 guarantees = await db.guarantees.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.method !== undefined) updatePayload.method = data.method;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.proof_url !== undefined) updatePayload.proof_url = data.proof_url;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await guarantees.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await guarantees.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.reservation !== undefined) {
+      await guarantees.setReservation(
+        data.reservation,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await guarantees.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return guarantees;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const guarantees = await db.guarantees.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of guarantees) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of guarantees) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return guarantees;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const guarantees = await db.guarantees.findByPk(id, options);
+
+    await guarantees.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await guarantees.destroy({
+      transaction,
+    });
+
+    return guarantees;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const guarantees = await db.guarantees.findOne({ where }, { transaction });
+
+    if (!guarantees) {
+      return guarantees;
+    }
+
+    const output = guarantees.get({ plain: true });
+
+    output.tenant = await guarantees.getTenant({
+      transaction,
+    });
+
+    output.reservation = await guarantees.getReservation({
+      transaction,
+    });
+
+    output.agences = await guarantees.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.reservations,
+        as: 'reservation',
+
+        where: filter.reservation
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.reservation
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  ref: {
+                    [Op.or]: filter.reservation
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.proof_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('guarantees', 'proof_url', filter.proof_url),
+        };
+      }
+
+      if (filter.amountRange) {
+        const [start, end] = filter.amountRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            amount: {
+              ...where.amount,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            amount: {
+              ...where.amount,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.method) {
+        where = {
+          ...where,
+          method: filter.method,
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.guarantees.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('guarantees', 'method', query),
+        ],
+      };
+    }
+
+    const records = await db.guarantees.findAll({
+      attributes: ['id', 'method'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['method', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.method,
+    }));
+  }
+};
--- a/backend/src/db/api/infractions.js
+++ b/backend/src/db/api/infractions.js
@ -0,0 +1,524 @@
+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 InfractionsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const infractions = await db.infractions.create(
+      {
+        id: data.id || undefined,
+
+        ref_no: data.ref_no || null,
+        date: data.date || null,
+        location: data.location || null,
+        amount: data.amount || null,
+        status: data.status || null,
+        proof_url: data.proof_url || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await infractions.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await infractions.setVehicle(data.vehicle || null, {
+      transaction,
+    });
+
+    await infractions.setReservation(data.reservation || null, {
+      transaction,
+    });
+
+    await infractions.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return infractions;
+  }
+
+  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 infractionsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      ref_no: item.ref_no || null,
+      date: item.date || null,
+      location: item.location || null,
+      amount: item.amount || null,
+      status: item.status || null,
+      proof_url: item.proof_url || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const infractions = await db.infractions.bulkCreate(infractionsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return infractions;
+  }
+
+  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 infractions = await db.infractions.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.ref_no !== undefined) updatePayload.ref_no = data.ref_no;
+
+    if (data.date !== undefined) updatePayload.date = data.date;
+
+    if (data.location !== undefined) updatePayload.location = data.location;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.proof_url !== undefined) updatePayload.proof_url = data.proof_url;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await infractions.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await infractions.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.vehicle !== undefined) {
+      await infractions.setVehicle(
+        data.vehicle,
+
+        { transaction },
+      );
+    }
+
+    if (data.reservation !== undefined) {
+      await infractions.setReservation(
+        data.reservation,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await infractions.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return infractions;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const infractions = await db.infractions.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of infractions) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of infractions) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return infractions;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const infractions = await db.infractions.findByPk(id, options);
+
+    await infractions.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await infractions.destroy({
+      transaction,
+    });
+
+    return infractions;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const infractions = await db.infractions.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!infractions) {
+      return infractions;
+    }
+
+    const output = infractions.get({ plain: true });
+
+    output.tenant = await infractions.getTenant({
+      transaction,
+    });
+
+    output.vehicle = await infractions.getVehicle({
+      transaction,
+    });
+
+    output.reservation = await infractions.getReservation({
+      transaction,
+    });
+
+    output.agences = await infractions.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.vehicles,
+        as: 'vehicle',
+
+        where: filter.vehicle
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.vehicle
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  plate_number: {
+                    [Op.or]: filter.vehicle
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.reservations,
+        as: 'reservation',
+
+        where: filter.reservation
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.reservation
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  ref: {
+                    [Op.or]: filter.reservation
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.ref_no) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('infractions', 'ref_no', filter.ref_no),
+        };
+      }
+
+      if (filter.location) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('infractions', 'location', filter.location),
+        };
+      }
+
+      if (filter.proof_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('infractions', 'proof_url', filter.proof_url),
+        };
+      }
+
+      if (filter.dateRange) {
+        const [start, end] = filter.dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            date: {
+              ...where.date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            date: {
+              ...where.date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.amountRange) {
+        const [start, end] = filter.amountRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            amount: {
+              ...where.amount,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            amount: {
+              ...where.amount,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.infractions.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('infractions', 'ref_no', query),
+        ],
+      };
+    }
+
+    const records = await db.infractions.findAll({
+      attributes: ['id', 'ref_no'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['ref_no', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.ref_no,
+    }));
+  }
+};
--- a/backend/src/db/api/invoices_saas.js
+++ b/backend/src/db/api/invoices_saas.js
@ -0,0 +1,481 @@
+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 Invoices_saasDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const invoices_saas = await db.invoices_saas.create(
+      {
+        id: data.id || undefined,
+
+        invoice_number: data.invoice_number || null,
+        amount_mad: data.amount_mad || null,
+        status: data.status || null,
+        issued_at: data.issued_at || null,
+        pdf_url: data.pdf_url || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await invoices_saas.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await invoices_saas.setSubscription(data.subscription || null, {
+      transaction,
+    });
+
+    await invoices_saas.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return invoices_saas;
+  }
+
+  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 invoices_saasData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      invoice_number: item.invoice_number || null,
+      amount_mad: item.amount_mad || null,
+      status: item.status || null,
+      issued_at: item.issued_at || null,
+      pdf_url: item.pdf_url || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const invoices_saas = await db.invoices_saas.bulkCreate(invoices_saasData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return invoices_saas;
+  }
+
+  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 invoices_saas = await db.invoices_saas.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.invoice_number !== undefined)
+      updatePayload.invoice_number = data.invoice_number;
+
+    if (data.amount_mad !== undefined)
+      updatePayload.amount_mad = data.amount_mad;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.issued_at !== undefined) updatePayload.issued_at = data.issued_at;
+
+    if (data.pdf_url !== undefined) updatePayload.pdf_url = data.pdf_url;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await invoices_saas.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await invoices_saas.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.subscription !== undefined) {
+      await invoices_saas.setSubscription(
+        data.subscription,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await invoices_saas.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return invoices_saas;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const invoices_saas = await db.invoices_saas.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of invoices_saas) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of invoices_saas) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return invoices_saas;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const invoices_saas = await db.invoices_saas.findByPk(id, options);
+
+    await invoices_saas.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await invoices_saas.destroy({
+      transaction,
+    });
+
+    return invoices_saas;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const invoices_saas = await db.invoices_saas.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!invoices_saas) {
+      return invoices_saas;
+    }
+
+    const output = invoices_saas.get({ plain: true });
+
+    output.tenant = await invoices_saas.getTenant({
+      transaction,
+    });
+
+    output.subscription = await invoices_saas.getSubscription({
+      transaction,
+    });
+
+    output.agences = await invoices_saas.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.subscriptions,
+        as: 'subscription',
+
+        where: filter.subscription
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.subscription
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  provider_customer_id: {
+                    [Op.or]: filter.subscription
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.invoice_number) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'invoices_saas',
+            'invoice_number',
+            filter.invoice_number,
+          ),
+        };
+      }
+
+      if (filter.pdf_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('invoices_saas', 'pdf_url', filter.pdf_url),
+        };
+      }
+
+      if (filter.amount_madRange) {
+        const [start, end] = filter.amount_madRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            amount_mad: {
+              ...where.amount_mad,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            amount_mad: {
+              ...where.amount_mad,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.issued_atRange) {
+        const [start, end] = filter.issued_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            issued_at: {
+              ...where.issued_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            issued_at: {
+              ...where.issued_at,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.invoices_saas.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('invoices_saas', 'invoice_number', query),
+        ],
+      };
+    }
+
+    const records = await db.invoices_saas.findAll({
+      attributes: ['id', 'invoice_number'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['invoice_number', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.invoice_number,
+    }));
+  }
+};
--- a/backend/src/db/api/maintenance.js
+++ b/backend/src/db/api/maintenance.js
@ -0,0 +1,505 @@
+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 MaintenanceDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const maintenance = await db.maintenance.create(
+      {
+        id: data.id || undefined,
+
+        type: data.type || null,
+        scheduled_at: data.scheduled_at || null,
+        odometer: data.odometer || null,
+        cost: data.cost || null,
+        notes: data.notes || null,
+        attachments: data.attachments || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await maintenance.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await maintenance.setVehicle(data.vehicle || null, {
+      transaction,
+    });
+
+    await maintenance.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return maintenance;
+  }
+
+  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 maintenanceData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      type: item.type || null,
+      scheduled_at: item.scheduled_at || null,
+      odometer: item.odometer || null,
+      cost: item.cost || null,
+      notes: item.notes || null,
+      attachments: item.attachments || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const maintenance = await db.maintenance.bulkCreate(maintenanceData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return maintenance;
+  }
+
+  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 maintenance = await db.maintenance.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.type !== undefined) updatePayload.type = data.type;
+
+    if (data.scheduled_at !== undefined)
+      updatePayload.scheduled_at = data.scheduled_at;
+
+    if (data.odometer !== undefined) updatePayload.odometer = data.odometer;
+
+    if (data.cost !== undefined) updatePayload.cost = data.cost;
+
+    if (data.notes !== undefined) updatePayload.notes = data.notes;
+
+    if (data.attachments !== undefined)
+      updatePayload.attachments = data.attachments;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await maintenance.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await maintenance.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.vehicle !== undefined) {
+      await maintenance.setVehicle(
+        data.vehicle,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await maintenance.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return maintenance;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const maintenance = await db.maintenance.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of maintenance) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of maintenance) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return maintenance;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const maintenance = await db.maintenance.findByPk(id, options);
+
+    await maintenance.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await maintenance.destroy({
+      transaction,
+    });
+
+    return maintenance;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const maintenance = await db.maintenance.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!maintenance) {
+      return maintenance;
+    }
+
+    const output = maintenance.get({ plain: true });
+
+    output.tenant = await maintenance.getTenant({
+      transaction,
+    });
+
+    output.vehicle = await maintenance.getVehicle({
+      transaction,
+    });
+
+    output.agences = await maintenance.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.vehicles,
+        as: 'vehicle',
+
+        where: filter.vehicle
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.vehicle
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  plate_number: {
+                    [Op.or]: filter.vehicle
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.notes) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('maintenance', 'notes', filter.notes),
+        };
+      }
+
+      if (filter.attachments) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'maintenance',
+            'attachments',
+            filter.attachments,
+          ),
+        };
+      }
+
+      if (filter.scheduled_atRange) {
+        const [start, end] = filter.scheduled_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            scheduled_at: {
+              ...where.scheduled_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            scheduled_at: {
+              ...where.scheduled_at,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.odometerRange) {
+        const [start, end] = filter.odometerRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            odometer: {
+              ...where.odometer,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            odometer: {
+              ...where.odometer,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.costRange) {
+        const [start, end] = filter.costRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            cost: {
+              ...where.cost,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            cost: {
+              ...where.cost,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.type) {
+        where = {
+          ...where,
+          type: filter.type,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.maintenance.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('maintenance', 'type', query),
+        ],
+      };
+    }
+
+    const records = await db.maintenance.findAll({
+      attributes: ['id', 'type'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['type', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.type,
+    }));
+  }
+};
--- a/backend/src/db/api/payments.js
+++ b/backend/src/db/api/payments.js
@ -0,0 +1,472 @@
+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 PaymentsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const payments = await db.payments.create(
+      {
+        id: data.id || undefined,
+
+        method: data.method || null,
+        amount: data.amount || null,
+        paid_at: data.paid_at || null,
+        receipt_ref: data.receipt_ref || null,
+        attachment_url: data.attachment_url || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await payments.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await payments.setReservation(data.reservation || null, {
+      transaction,
+    });
+
+    await payments.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return payments;
+  }
+
+  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 paymentsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      method: item.method || null,
+      amount: item.amount || null,
+      paid_at: item.paid_at || null,
+      receipt_ref: item.receipt_ref || null,
+      attachment_url: item.attachment_url || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const payments = await db.payments.bulkCreate(paymentsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return payments;
+  }
+
+  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 payments = await db.payments.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.method !== undefined) updatePayload.method = data.method;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    if (data.paid_at !== undefined) updatePayload.paid_at = data.paid_at;
+
+    if (data.receipt_ref !== undefined)
+      updatePayload.receipt_ref = data.receipt_ref;
+
+    if (data.attachment_url !== undefined)
+      updatePayload.attachment_url = data.attachment_url;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await payments.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await payments.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.reservation !== undefined) {
+      await payments.setReservation(
+        data.reservation,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await payments.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return payments;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const payments = await db.payments.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of payments) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of payments) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return payments;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const payments = await db.payments.findByPk(id, options);
+
+    await payments.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await payments.destroy({
+      transaction,
+    });
+
+    return payments;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const payments = await db.payments.findOne({ where }, { transaction });
+
+    if (!payments) {
+      return payments;
+    }
+
+    const output = payments.get({ plain: true });
+
+    output.tenant = await payments.getTenant({
+      transaction,
+    });
+
+    output.reservation = await payments.getReservation({
+      transaction,
+    });
+
+    output.agences = await payments.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.reservations,
+        as: 'reservation',
+
+        where: filter.reservation
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.reservation
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  ref: {
+                    [Op.or]: filter.reservation
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.receipt_ref) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('payments', 'receipt_ref', filter.receipt_ref),
+        };
+      }
+
+      if (filter.attachment_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'payments',
+            'attachment_url',
+            filter.attachment_url,
+          ),
+        };
+      }
+
+      if (filter.amountRange) {
+        const [start, end] = filter.amountRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            amount: {
+              ...where.amount,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            amount: {
+              ...where.amount,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.paid_atRange) {
+        const [start, end] = filter.paid_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            paid_at: {
+              ...where.paid_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            paid_at: {
+              ...where.paid_at,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.method) {
+        where = {
+          ...where,
+          method: filter.method,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.payments.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('payments', 'receipt_ref', query),
+        ],
+      };
+    }
+
+    const records = await db.payments.findAll({
+      attributes: ['id', 'receipt_ref'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['receipt_ref', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.receipt_ref,
+    }));
+  }
+};
--- a/backend/src/db/api/permissions.js
+++ b/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 userAgences = (user && user.agences?.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,
+    }));
+  }
+};
--- a/backend/src/db/api/plans.js
+++ b/backend/src/db/api/plans.js
@ -0,0 +1,371 @@
+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 PlansDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const plans = await db.plans.create(
+      {
+        id: data.id || undefined,
+
+        code: data.code || null,
+        name: data.name || null,
+        period: data.period || null,
+        price_mad: data.price_mad || null,
+        limits: data.limits || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await plans.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return plans;
+  }
+
+  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 plansData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      code: item.code || null,
+      name: item.name || null,
+      period: item.period || null,
+      price_mad: item.price_mad || null,
+      limits: item.limits || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const plans = await db.plans.bulkCreate(plansData, { transaction });
+
+    // For each item created, replace relation files
+
+    return plans;
+  }
+
+  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 plans = await db.plans.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.code !== undefined) updatePayload.code = data.code;
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    if (data.period !== undefined) updatePayload.period = data.period;
+
+    if (data.price_mad !== undefined) updatePayload.price_mad = data.price_mad;
+
+    if (data.limits !== undefined) updatePayload.limits = data.limits;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await plans.update(updatePayload, { transaction });
+
+    if (data.agences !== undefined) {
+      await plans.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return plans;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const plans = await db.plans.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of plans) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of plans) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return plans;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const plans = await db.plans.findByPk(id, options);
+
+    await plans.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await plans.destroy({
+      transaction,
+    });
+
+    return plans;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const plans = await db.plans.findOne({ where }, { transaction });
+
+    if (!plans) {
+      return plans;
+    }
+
+    const output = plans.get({ plain: true });
+
+    output.subscriptions_plan = await plans.getSubscriptions_plan({
+      transaction,
+    });
+
+    output.tenants_plan = await plans.getTenants_plan({
+      transaction,
+    });
+
+    output.agences = await plans.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.code) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('plans', 'code', filter.code),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('plans', 'name', filter.name),
+        };
+      }
+
+      if (filter.limits) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('plans', 'limits', filter.limits),
+        };
+      }
+
+      if (filter.price_madRange) {
+        const [start, end] = filter.price_madRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            price_mad: {
+              ...where.price_mad,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            price_mad: {
+              ...where.price_mad,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.period) {
+        where = {
+          ...where,
+          period: filter.period,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.plans.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('plans', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.plans.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,
+    }));
+  }
+};
--- a/backend/src/db/api/reservations.js
+++ b/backend/src/db/api/reservations.js
@ -0,0 +1,873 @@
+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 ReservationsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const reservations = await db.reservations.create(
+      {
+        id: data.id || undefined,
+
+        ref: data.ref || null,
+        status_manual: data.status_manual || null,
+        status_computed: data.status_computed || null,
+        start_at: data.start_at || null,
+        end_at: data.end_at || null,
+        pickup_address: data.pickup_address || null,
+        return_address: data.return_address || null,
+        options: data.options || null,
+        days: data.days || null,
+        price_per_day: data.price_per_day || null,
+        total_price: data.total_price || null,
+        paid_amount: data.paid_amount || null,
+        balance_amount: data.balance_amount || null,
+        guarantee_method: data.guarantee_method || null,
+        guarantee_amount: data.guarantee_amount || null,
+        guarantee_status: data.guarantee_status || null,
+        departure_validated_at: data.departure_validated_at || null,
+        return_validated_at: data.return_validated_at || null,
+        notes: data.notes || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await reservations.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await reservations.setClient(data.client || null, {
+      transaction,
+    });
+
+    await reservations.setVehicle(data.vehicle || null, {
+      transaction,
+    });
+
+    await reservations.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return reservations;
+  }
+
+  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 reservationsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      ref: item.ref || null,
+      status_manual: item.status_manual || null,
+      status_computed: item.status_computed || null,
+      start_at: item.start_at || null,
+      end_at: item.end_at || null,
+      pickup_address: item.pickup_address || null,
+      return_address: item.return_address || null,
+      options: item.options || null,
+      days: item.days || null,
+      price_per_day: item.price_per_day || null,
+      total_price: item.total_price || null,
+      paid_amount: item.paid_amount || null,
+      balance_amount: item.balance_amount || null,
+      guarantee_method: item.guarantee_method || null,
+      guarantee_amount: item.guarantee_amount || null,
+      guarantee_status: item.guarantee_status || null,
+      departure_validated_at: item.departure_validated_at || null,
+      return_validated_at: item.return_validated_at || null,
+      notes: item.notes || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const reservations = await db.reservations.bulkCreate(reservationsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return reservations;
+  }
+
+  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 reservations = await db.reservations.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.ref !== undefined) updatePayload.ref = data.ref;
+
+    if (data.status_manual !== undefined)
+      updatePayload.status_manual = data.status_manual;
+
+    if (data.status_computed !== undefined)
+      updatePayload.status_computed = data.status_computed;
+
+    if (data.start_at !== undefined) updatePayload.start_at = data.start_at;
+
+    if (data.end_at !== undefined) updatePayload.end_at = data.end_at;
+
+    if (data.pickup_address !== undefined)
+      updatePayload.pickup_address = data.pickup_address;
+
+    if (data.return_address !== undefined)
+      updatePayload.return_address = data.return_address;
+
+    if (data.options !== undefined) updatePayload.options = data.options;
+
+    if (data.days !== undefined) updatePayload.days = data.days;
+
+    if (data.price_per_day !== undefined)
+      updatePayload.price_per_day = data.price_per_day;
+
+    if (data.total_price !== undefined)
+      updatePayload.total_price = data.total_price;
+
+    if (data.paid_amount !== undefined)
+      updatePayload.paid_amount = data.paid_amount;
+
+    if (data.balance_amount !== undefined)
+      updatePayload.balance_amount = data.balance_amount;
+
+    if (data.guarantee_method !== undefined)
+      updatePayload.guarantee_method = data.guarantee_method;
+
+    if (data.guarantee_amount !== undefined)
+      updatePayload.guarantee_amount = data.guarantee_amount;
+
+    if (data.guarantee_status !== undefined)
+      updatePayload.guarantee_status = data.guarantee_status;
+
+    if (data.departure_validated_at !== undefined)
+      updatePayload.departure_validated_at = data.departure_validated_at;
+
+    if (data.return_validated_at !== undefined)
+      updatePayload.return_validated_at = data.return_validated_at;
+
+    if (data.notes !== undefined) updatePayload.notes = data.notes;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await reservations.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await reservations.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.client !== undefined) {
+      await reservations.setClient(
+        data.client,
+
+        { transaction },
+      );
+    }
+
+    if (data.vehicle !== undefined) {
+      await reservations.setVehicle(
+        data.vehicle,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await reservations.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return reservations;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const reservations = await db.reservations.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of reservations) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of reservations) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return reservations;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const reservations = await db.reservations.findByPk(id, options);
+
+    await reservations.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await reservations.destroy({
+      transaction,
+    });
+
+    return reservations;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const reservations = await db.reservations.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!reservations) {
+      return reservations;
+    }
+
+    const output = reservations.get({ plain: true });
+
+    output.claims_reservation = await reservations.getClaims_reservation({
+      transaction,
+    });
+
+    output.drivers_reservation = await reservations.getDrivers_reservation({
+      transaction,
+    });
+
+    output.guarantees_reservation =
+      await reservations.getGuarantees_reservation({
+        transaction,
+      });
+
+    output.infractions_reservation =
+      await reservations.getInfractions_reservation({
+        transaction,
+      });
+
+    output.payments_reservation = await reservations.getPayments_reservation({
+      transaction,
+    });
+
+    output.vehicle_conditions_reservation =
+      await reservations.getVehicle_conditions_reservation({
+        transaction,
+      });
+
+    output.tenant = await reservations.getTenant({
+      transaction,
+    });
+
+    output.client = await reservations.getClient({
+      transaction,
+    });
+
+    output.vehicle = await reservations.getVehicle({
+      transaction,
+    });
+
+    output.agences = await reservations.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clients,
+        as: 'client',
+
+        where: filter.client
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.client
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  first_name: {
+                    [Op.or]: filter.client
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.vehicles,
+        as: 'vehicle',
+
+        where: filter.vehicle
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.vehicle
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  plate_number: {
+                    [Op.or]: filter.vehicle
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.ref) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('reservations', 'ref', filter.ref),
+        };
+      }
+
+      if (filter.pickup_address) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'reservations',
+            'pickup_address',
+            filter.pickup_address,
+          ),
+        };
+      }
+
+      if (filter.return_address) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'reservations',
+            'return_address',
+            filter.return_address,
+          ),
+        };
+      }
+
+      if (filter.options) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('reservations', 'options', filter.options),
+        };
+      }
+
+      if (filter.notes) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('reservations', 'notes', filter.notes),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              start_at: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              end_at: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.start_atRange) {
+        const [start, end] = filter.start_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            start_at: {
+              ...where.start_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            start_at: {
+              ...where.start_at,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.end_atRange) {
+        const [start, end] = filter.end_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            end_at: {
+              ...where.end_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            end_at: {
+              ...where.end_at,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.daysRange) {
+        const [start, end] = filter.daysRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            days: {
+              ...where.days,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            days: {
+              ...where.days,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.price_per_dayRange) {
+        const [start, end] = filter.price_per_dayRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            price_per_day: {
+              ...where.price_per_day,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            price_per_day: {
+              ...where.price_per_day,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.total_priceRange) {
+        const [start, end] = filter.total_priceRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            total_price: {
+              ...where.total_price,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            total_price: {
+              ...where.total_price,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.paid_amountRange) {
+        const [start, end] = filter.paid_amountRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            paid_amount: {
+              ...where.paid_amount,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            paid_amount: {
+              ...where.paid_amount,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.balance_amountRange) {
+        const [start, end] = filter.balance_amountRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            balance_amount: {
+              ...where.balance_amount,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            balance_amount: {
+              ...where.balance_amount,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.guarantee_amountRange) {
+        const [start, end] = filter.guarantee_amountRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            guarantee_amount: {
+              ...where.guarantee_amount,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            guarantee_amount: {
+              ...where.guarantee_amount,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.departure_validated_atRange) {
+        const [start, end] = filter.departure_validated_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            departure_validated_at: {
+              ...where.departure_validated_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            departure_validated_at: {
+              ...where.departure_validated_at,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.return_validated_atRange) {
+        const [start, end] = filter.return_validated_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            return_validated_at: {
+              ...where.return_validated_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            return_validated_at: {
+              ...where.return_validated_at,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.status_manual) {
+        where = {
+          ...where,
+          status_manual: filter.status_manual,
+        };
+      }
+
+      if (filter.status_computed) {
+        where = {
+          ...where,
+          status_computed: filter.status_computed,
+        };
+      }
+
+      if (filter.guarantee_method) {
+        where = {
+          ...where,
+          guarantee_method: filter.guarantee_method,
+        };
+      }
+
+      if (filter.guarantee_status) {
+        where = {
+          ...where,
+          guarantee_status: filter.guarantee_status,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.reservations.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('reservations', 'ref', query),
+        ],
+      };
+    }
+
+    const records = await db.reservations.findAll({
+      attributes: ['id', 'ref'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['ref', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.ref,
+    }));
+  }
+};
--- a/backend/src/db/api/roles.js
+++ b/backend/src/db/api/roles.js
@ -0,0 +1,344 @@
+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 userAgences = (user && user.agences?.id) || null;
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.permissions,
+        as: 'permissions',
+        required: false,
+      },
+    ];
+
+    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,
+    }));
+  }
+};
--- a/backend/src/db/api/subscriptions.js
+++ b/backend/src/db/api/subscriptions.js
@ -0,0 +1,504 @@
+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,
+
+        status: data.status || null,
+        current_period_start: data.current_period_start || null,
+        current_period_end: data.current_period_end || null,
+        payment_provider: data.payment_provider || null,
+        provider_customer_id: data.provider_customer_id || null,
+        provider_subscription_id: data.provider_subscription_id || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await subscriptions.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await subscriptions.setPlan(data.plan || null, {
+      transaction,
+    });
+
+    await subscriptions.setAgences(data.agences || 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,
+
+      status: item.status || null,
+      current_period_start: item.current_period_start || null,
+      current_period_end: item.current_period_end || null,
+      payment_provider: item.payment_provider || null,
+      provider_customer_id: item.provider_customer_id || null,
+      provider_subscription_id: item.provider_subscription_id || 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.status !== undefined) updatePayload.status = data.status;
+
+    if (data.current_period_start !== undefined)
+      updatePayload.current_period_start = data.current_period_start;
+
+    if (data.current_period_end !== undefined)
+      updatePayload.current_period_end = data.current_period_end;
+
+    if (data.payment_provider !== undefined)
+      updatePayload.payment_provider = data.payment_provider;
+
+    if (data.provider_customer_id !== undefined)
+      updatePayload.provider_customer_id = data.provider_customer_id;
+
+    if (data.provider_subscription_id !== undefined)
+      updatePayload.provider_subscription_id = data.provider_subscription_id;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await subscriptions.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await subscriptions.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.plan !== undefined) {
+      await subscriptions.setPlan(
+        data.plan,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await subscriptions.setAgences(
+        data.agences,
+
+        { 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.invoices_saas_subscription =
+      await subscriptions.getInvoices_saas_subscription({
+        transaction,
+      });
+
+    output.tenant = await subscriptions.getTenant({
+      transaction,
+    });
+
+    output.plan = await subscriptions.getPlan({
+      transaction,
+    });
+
+    output.agences = await subscriptions.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.plans,
+        as: 'plan',
+
+        where: filter.plan
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.plan
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.plan
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.provider_customer_id) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'subscriptions',
+            'provider_customer_id',
+            filter.provider_customer_id,
+          ),
+        };
+      }
+
+      if (filter.provider_subscription_id) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'subscriptions',
+            'provider_subscription_id',
+            filter.provider_subscription_id,
+          ),
+        };
+      }
+
+      if (filter.current_period_startRange) {
+        const [start, end] = filter.current_period_startRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            current_period_start: {
+              ...where.current_period_start,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            current_period_start: {
+              ...where.current_period_start,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.current_period_endRange) {
+        const [start, end] = filter.current_period_endRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            current_period_end: {
+              ...where.current_period_end,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            current_period_end: {
+              ...where.current_period_end,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.payment_provider) {
+        where = {
+          ...where,
+          payment_provider: filter.payment_provider,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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', 'provider_customer_id', query),
+        ],
+      };
+    }
+
+    const records = await db.subscriptions.findAll({
+      attributes: ['id', 'provider_customer_id'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['provider_customer_id', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.provider_customer_id,
+    }));
+  }
+};
--- a/backend/src/db/api/tenants.js
+++ b/backend/src/db/api/tenants.js
@ -0,0 +1,484 @@
+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 TenantsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const tenants = await db.tenants.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        subdomain: data.subdomain || null,
+        status: data.status || null,
+        trial_ends_at: data.trial_ends_at || null,
+        billing_email: data.billing_email || null,
+        billing_phone: data.billing_phone || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await tenants.setPlan(data.plan || null, {
+      transaction,
+    });
+
+    await tenants.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return tenants;
+  }
+
+  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 tenantsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      subdomain: item.subdomain || null,
+      status: item.status || null,
+      trial_ends_at: item.trial_ends_at || null,
+      billing_email: item.billing_email || null,
+      billing_phone: item.billing_phone || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const tenants = await db.tenants.bulkCreate(tenantsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return tenants;
+  }
+
+  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 tenants = await db.tenants.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    if (data.subdomain !== undefined) updatePayload.subdomain = data.subdomain;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.trial_ends_at !== undefined)
+      updatePayload.trial_ends_at = data.trial_ends_at;
+
+    if (data.billing_email !== undefined)
+      updatePayload.billing_email = data.billing_email;
+
+    if (data.billing_phone !== undefined)
+      updatePayload.billing_phone = data.billing_phone;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await tenants.update(updatePayload, { transaction });
+
+    if (data.plan !== undefined) {
+      await tenants.setPlan(
+        data.plan,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await tenants.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return tenants;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const tenants = await db.tenants.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of tenants) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of tenants) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return tenants;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const tenants = await db.tenants.findByPk(id, options);
+
+    await tenants.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await tenants.destroy({
+      transaction,
+    });
+
+    return tenants;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const tenants = await db.tenants.findOne({ where }, { transaction });
+
+    if (!tenants) {
+      return tenants;
+    }
+
+    const output = tenants.get({ plain: true });
+
+    output.claims_tenant = await tenants.getClaims_tenant({
+      transaction,
+    });
+
+    output.clients_tenant = await tenants.getClients_tenant({
+      transaction,
+    });
+
+    output.company_profiles_tenant = await tenants.getCompany_profiles_tenant({
+      transaction,
+    });
+
+    output.drivers_tenant = await tenants.getDrivers_tenant({
+      transaction,
+    });
+
+    output.expenses_tenant = await tenants.getExpenses_tenant({
+      transaction,
+    });
+
+    output.guarantees_tenant = await tenants.getGuarantees_tenant({
+      transaction,
+    });
+
+    output.infractions_tenant = await tenants.getInfractions_tenant({
+      transaction,
+    });
+
+    output.invoices_saas_tenant = await tenants.getInvoices_saas_tenant({
+      transaction,
+    });
+
+    output.maintenance_tenant = await tenants.getMaintenance_tenant({
+      transaction,
+    });
+
+    output.payments_tenant = await tenants.getPayments_tenant({
+      transaction,
+    });
+
+    output.reservations_tenant = await tenants.getReservations_tenant({
+      transaction,
+    });
+
+    output.subscriptions_tenant = await tenants.getSubscriptions_tenant({
+      transaction,
+    });
+
+    output.vehicle_conditions_tenant =
+      await tenants.getVehicle_conditions_tenant({
+        transaction,
+      });
+
+    output.vehicles_tenant = await tenants.getVehicles_tenant({
+      transaction,
+    });
+
+    output.plan = await tenants.getPlan({
+      transaction,
+    });
+
+    output.agences = await tenants.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.plans,
+        as: 'plan',
+
+        where: filter.plan
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.plan
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.plan
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('tenants', 'name', filter.name),
+        };
+      }
+
+      if (filter.subdomain) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('tenants', 'subdomain', filter.subdomain),
+        };
+      }
+
+      if (filter.billing_email) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'tenants',
+            'billing_email',
+            filter.billing_email,
+          ),
+        };
+      }
+
+      if (filter.billing_phone) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'tenants',
+            'billing_phone',
+            filter.billing_phone,
+          ),
+        };
+      }
+
+      if (filter.trial_ends_atRange) {
+        const [start, end] = filter.trial_ends_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            trial_ends_at: {
+              ...where.trial_ends_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            trial_ends_at: {
+              ...where.trial_ends_at,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.tenants.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('tenants', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.tenants.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,
+    }));
+  }
+};
--- a/backend/src/db/api/users.js
+++ b/backend/src/db/api/users.js
@ -0,0 +1,800 @@
+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.setAgences(data.data.agences || 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.agences !== undefined) {
+      await users.setAgences(
+        data.agences,
+
+        { 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.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.agences = await users.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    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.agences,
+        as: 'agences',
+      },
+
+      {
+        model: db.permissions,
+        as: 'custom_permissions',
+        required: false,
+      },
+
+      {
+        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.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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: config.roles?.user || '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;
+  }
+};
--- a/backend/src/db/api/vehicle_conditions.js
+++ b/backend/src/db/api/vehicle_conditions.js
@ -0,0 +1,412 @@
+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 Vehicle_conditionsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const vehicle_conditions = await db.vehicle_conditions.create(
+      {
+        id: data.id || undefined,
+
+        before: data.before || null,
+        after: data.after || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await vehicle_conditions.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await vehicle_conditions.setReservation(data.reservation || null, {
+      transaction,
+    });
+
+    await vehicle_conditions.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return vehicle_conditions;
+  }
+
+  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 vehicle_conditionsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      before: item.before || null,
+      after: item.after || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const vehicle_conditions = await db.vehicle_conditions.bulkCreate(
+      vehicle_conditionsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return vehicle_conditions;
+  }
+
+  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 vehicle_conditions = await db.vehicle_conditions.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.before !== undefined) updatePayload.before = data.before;
+
+    if (data.after !== undefined) updatePayload.after = data.after;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await vehicle_conditions.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await vehicle_conditions.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.reservation !== undefined) {
+      await vehicle_conditions.setReservation(
+        data.reservation,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await vehicle_conditions.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return vehicle_conditions;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const vehicle_conditions = await db.vehicle_conditions.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of vehicle_conditions) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of vehicle_conditions) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return vehicle_conditions;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const vehicle_conditions = await db.vehicle_conditions.findByPk(
+      id,
+      options,
+    );
+
+    await vehicle_conditions.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await vehicle_conditions.destroy({
+      transaction,
+    });
+
+    return vehicle_conditions;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const vehicle_conditions = await db.vehicle_conditions.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!vehicle_conditions) {
+      return vehicle_conditions;
+    }
+
+    const output = vehicle_conditions.get({ plain: true });
+
+    output.tenant = await vehicle_conditions.getTenant({
+      transaction,
+    });
+
+    output.reservation = await vehicle_conditions.getReservation({
+      transaction,
+    });
+
+    output.agences = await vehicle_conditions.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.reservations,
+        as: 'reservation',
+
+        where: filter.reservation
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.reservation
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  ref: {
+                    [Op.or]: filter.reservation
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.before) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vehicle_conditions', 'before', filter.before),
+        };
+      }
+
+      if (filter.after) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vehicle_conditions', 'after', filter.after),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.vehicle_conditions.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('vehicle_conditions', 'before', query),
+        ],
+      };
+    }
+
+    const records = await db.vehicle_conditions.findAll({
+      attributes: ['id', 'before'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['before', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.before,
+    }));
+  }
+};
--- a/backend/src/db/api/vehicles.js
+++ b/backend/src/db/api/vehicles.js
@ -0,0 +1,599 @@
+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 VehiclesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const vehicles = await db.vehicles.create(
+      {
+        id: data.id || undefined,
+
+        plate_number: data.plate_number || null,
+        brand: data.brand || null,
+        model: data.model || null,
+        year: data.year || null,
+        color: data.color || null,
+        category: data.category || null,
+        fuel_type: data.fuel_type || null,
+        transmission: data.transmission || null,
+        mileage: data.mileage || null,
+        daily_price: data.daily_price || null,
+        status: data.status || null,
+        insurance_expiry: data.insurance_expiry || null,
+        tech_visit_expiry: data.tech_visit_expiry || null,
+        photos: data.photos || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await vehicles.setTenant(data.tenant || null, {
+      transaction,
+    });
+
+    await vehicles.setAgences(data.agences || null, {
+      transaction,
+    });
+
+    return vehicles;
+  }
+
+  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 vehiclesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      plate_number: item.plate_number || null,
+      brand: item.brand || null,
+      model: item.model || null,
+      year: item.year || null,
+      color: item.color || null,
+      category: item.category || null,
+      fuel_type: item.fuel_type || null,
+      transmission: item.transmission || null,
+      mileage: item.mileage || null,
+      daily_price: item.daily_price || null,
+      status: item.status || null,
+      insurance_expiry: item.insurance_expiry || null,
+      tech_visit_expiry: item.tech_visit_expiry || null,
+      photos: item.photos || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const vehicles = await db.vehicles.bulkCreate(vehiclesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return vehicles;
+  }
+
+  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 vehicles = await db.vehicles.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.plate_number !== undefined)
+      updatePayload.plate_number = data.plate_number;
+
+    if (data.brand !== undefined) updatePayload.brand = data.brand;
+
+    if (data.model !== undefined) updatePayload.model = data.model;
+
+    if (data.year !== undefined) updatePayload.year = data.year;
+
+    if (data.color !== undefined) updatePayload.color = data.color;
+
+    if (data.category !== undefined) updatePayload.category = data.category;
+
+    if (data.fuel_type !== undefined) updatePayload.fuel_type = data.fuel_type;
+
+    if (data.transmission !== undefined)
+      updatePayload.transmission = data.transmission;
+
+    if (data.mileage !== undefined) updatePayload.mileage = data.mileage;
+
+    if (data.daily_price !== undefined)
+      updatePayload.daily_price = data.daily_price;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.insurance_expiry !== undefined)
+      updatePayload.insurance_expiry = data.insurance_expiry;
+
+    if (data.tech_visit_expiry !== undefined)
+      updatePayload.tech_visit_expiry = data.tech_visit_expiry;
+
+    if (data.photos !== undefined) updatePayload.photos = data.photos;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await vehicles.update(updatePayload, { transaction });
+
+    if (data.tenant !== undefined) {
+      await vehicles.setTenant(
+        data.tenant,
+
+        { transaction },
+      );
+    }
+
+    if (data.agences !== undefined) {
+      await vehicles.setAgences(
+        data.agences,
+
+        { transaction },
+      );
+    }
+
+    return vehicles;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const vehicles = await db.vehicles.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of vehicles) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of vehicles) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return vehicles;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const vehicles = await db.vehicles.findByPk(id, options);
+
+    await vehicles.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await vehicles.destroy({
+      transaction,
+    });
+
+    return vehicles;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const vehicles = await db.vehicles.findOne({ where }, { transaction });
+
+    if (!vehicles) {
+      return vehicles;
+    }
+
+    const output = vehicles.get({ plain: true });
+
+    output.expenses_vehicle = await vehicles.getExpenses_vehicle({
+      transaction,
+    });
+
+    output.infractions_vehicle = await vehicles.getInfractions_vehicle({
+      transaction,
+    });
+
+    output.maintenance_vehicle = await vehicles.getMaintenance_vehicle({
+      transaction,
+    });
+
+    output.reservations_vehicle = await vehicles.getReservations_vehicle({
+      transaction,
+    });
+
+    output.tenant = await vehicles.getTenant({
+      transaction,
+    });
+
+    output.agences = await vehicles.getAgences({
+      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 userAgences = (user && user.agences?.id) || null;
+
+    if (userAgences) {
+      if (options?.currentUser?.agencesId) {
+        where.agencesId = options.currentUser.agencesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.tenants,
+        as: 'tenant',
+
+        where: filter.tenant
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.tenant
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.tenant
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.agences,
+        as: 'agences',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.plate_number) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'vehicles',
+            'plate_number',
+            filter.plate_number,
+          ),
+        };
+      }
+
+      if (filter.brand) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vehicles', 'brand', filter.brand),
+        };
+      }
+
+      if (filter.model) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vehicles', 'model', filter.model),
+        };
+      }
+
+      if (filter.color) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vehicles', 'color', filter.color),
+        };
+      }
+
+      if (filter.photos) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vehicles', 'photos', filter.photos),
+        };
+      }
+
+      if (filter.yearRange) {
+        const [start, end] = filter.yearRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            year: {
+              ...where.year,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            year: {
+              ...where.year,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.mileageRange) {
+        const [start, end] = filter.mileageRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            mileage: {
+              ...where.mileage,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            mileage: {
+              ...where.mileage,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.daily_priceRange) {
+        const [start, end] = filter.daily_priceRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            daily_price: {
+              ...where.daily_price,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            daily_price: {
+              ...where.daily_price,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.insurance_expiryRange) {
+        const [start, end] = filter.insurance_expiryRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            insurance_expiry: {
+              ...where.insurance_expiry,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            insurance_expiry: {
+              ...where.insurance_expiry,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.tech_visit_expiryRange) {
+        const [start, end] = filter.tech_visit_expiryRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            tech_visit_expiry: {
+              ...where.tech_visit_expiry,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            tech_visit_expiry: {
+              ...where.tech_visit_expiry,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.category) {
+        where = {
+          ...where,
+          category: filter.category,
+        };
+      }
+
+      if (filter.fuel_type) {
+        where = {
+          ...where,
+          fuel_type: filter.fuel_type,
+        };
+      }
+
+      if (filter.transmission) {
+        where = {
+          ...where,
+          transmission: filter.transmission,
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.agences) {
+        const listItems = filter.agences.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          agencesId: { [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.agencesId;
+    }
+
+    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.vehicles.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('vehicles', 'plate_number', query),
+        ],
+      };
+    }
+
+    const records = await db.vehicles.findAll({
+      attributes: ['id', 'plate_number'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['plate_number', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.plate_number,
+    }));
+  }
+};
--- a/backend/src/db/db.config.js
+++ b/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_car_zone',
+    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',
+  },
+};
--- a/backend/src/db/migrations/1760750720800.js
+++ b/backend/src/db/migrations/1760750720800.js
--- a/backend/src/db/models/agences.js
+++ b/backend/src/db/models/agences.js
@ -0,0 +1,185 @@
+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 agences = sequelize.define(
+    'agences',
+    {
+      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,
+    },
+  );
+
+  agences.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.agences.hasMany(db.users, {
+      as: 'users_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.claims, {
+      as: 'claims_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.clients, {
+      as: 'clients_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.company_profiles, {
+      as: 'company_profiles_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.drivers, {
+      as: 'drivers_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.expenses, {
+      as: 'expenses_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.guarantees, {
+      as: 'guarantees_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.infractions, {
+      as: 'infractions_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.invoices_saas, {
+      as: 'invoices_saas_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.maintenance, {
+      as: 'maintenance_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.payments, {
+      as: 'payments_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.plans, {
+      as: 'plans_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.reservations, {
+      as: 'reservations_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.subscriptions, {
+      as: 'subscriptions_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.tenants, {
+      as: 'tenants_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.vehicle_conditions, {
+      as: 'vehicle_conditions_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.agences.hasMany(db.vehicles, {
+      as: 'vehicles_agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.agences.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.agences.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return agences;
+};
--- a/backend/src/db/models/claims.js
+++ b/backend/src/db/models/claims.js
@ -0,0 +1,95 @@
+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 claims = sequelize.define(
+    'claims',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      category: {
+        type: DataTypes.TEXT,
+      },
+
+      description: {
+        type: DataTypes.TEXT,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['ouverte', 'en_cours', 'resolue'],
+      },
+
+      attachments: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  claims.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.claims.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.claims.belongsTo(db.clients, {
+      as: 'client',
+      foreignKey: {
+        name: 'clientId',
+      },
+      constraints: false,
+    });
+
+    db.claims.belongsTo(db.reservations, {
+      as: 'reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.claims.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.claims.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.claims.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return claims;
+};
--- a/backend/src/db/models/clients.js
+++ b/backend/src/db/models/clients.js
@ -0,0 +1,127 @@
+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 clients = sequelize.define(
+    'clients',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      first_name: {
+        type: DataTypes.TEXT,
+      },
+
+      last_name: {
+        type: DataTypes.TEXT,
+      },
+
+      birth_date: {
+        type: DataTypes.DATE,
+      },
+
+      phone: {
+        type: DataTypes.TEXT,
+      },
+
+      address: {
+        type: DataTypes.TEXT,
+      },
+
+      id_type: {
+        type: DataTypes.ENUM,
+
+        values: ['CIN', 'Passeport'],
+      },
+
+      id_number: {
+        type: DataTypes.TEXT,
+      },
+
+      id_issue_date: {
+        type: DataTypes.DATE,
+      },
+
+      license_number: {
+        type: DataTypes.TEXT,
+      },
+
+      license_issue_date: {
+        type: DataTypes.DATE,
+      },
+
+      id_copy_url: {
+        type: DataTypes.TEXT,
+      },
+
+      license_copy_url: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  clients.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.clients.hasMany(db.claims, {
+      as: 'claims_client',
+      foreignKey: {
+        name: 'clientId',
+      },
+      constraints: false,
+    });
+
+    db.clients.hasMany(db.reservations, {
+      as: 'reservations_client',
+      foreignKey: {
+        name: 'clientId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.clients.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.clients.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.clients.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.clients.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return clients;
+};
--- a/backend/src/db/models/company_profiles.js
+++ b/backend/src/db/models/company_profiles.js
@ -0,0 +1,101 @@
+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 company_profiles = sequelize.define(
+    'company_profiles',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      legal_name: {
+        type: DataTypes.TEXT,
+      },
+
+      address: {
+        type: DataTypes.TEXT,
+      },
+
+      phone: {
+        type: DataTypes.TEXT,
+      },
+
+      email: {
+        type: DataTypes.TEXT,
+      },
+
+      website: {
+        type: DataTypes.TEXT,
+      },
+
+      rc: {
+        type: DataTypes.TEXT,
+      },
+
+      ice: {
+        type: DataTypes.TEXT,
+      },
+
+      patente: {
+        type: DataTypes.TEXT,
+      },
+
+      logo_url: {
+        type: DataTypes.TEXT,
+      },
+
+      pdf_footer: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  company_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.company_profiles.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.company_profiles.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.company_profiles.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.company_profiles.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return company_profiles;
+};
--- a/backend/src/db/models/drivers.js
+++ b/backend/src/db/models/drivers.js
@ -0,0 +1,89 @@
+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 drivers = sequelize.define(
+    'drivers',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      full_name: {
+        type: DataTypes.TEXT,
+      },
+
+      license_number: {
+        type: DataTypes.TEXT,
+      },
+
+      license_issue_date: {
+        type: DataTypes.DATE,
+      },
+
+      id_copy_url: {
+        type: DataTypes.TEXT,
+      },
+
+      license_copy_url: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  drivers.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.drivers.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.drivers.belongsTo(db.reservations, {
+      as: 'reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.drivers.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.drivers.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.drivers.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return drivers;
+};
--- a/backend/src/db/models/expenses.js
+++ b/backend/src/db/models/expenses.js
@ -0,0 +1,95 @@
+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 expenses = sequelize.define(
+    'expenses',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      type: {
+        type: DataTypes.ENUM,
+
+        values: ['depense', 'revenu'],
+      },
+
+      category: {
+        type: DataTypes.TEXT,
+      },
+
+      amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      date: {
+        type: DataTypes.DATE,
+      },
+
+      note: {
+        type: DataTypes.TEXT,
+      },
+
+      attachment_url: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  expenses.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.expenses.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.expenses.belongsTo(db.vehicles, {
+      as: 'vehicle',
+      foreignKey: {
+        name: 'vehicleId',
+      },
+      constraints: false,
+    });
+
+    db.expenses.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.expenses.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.expenses.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return expenses;
+};
--- a/backend/src/db/models/file.js
+++ b/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;
+};
--- a/backend/src/db/models/guarantees.js
+++ b/backend/src/db/models/guarantees.js
@ -0,0 +1,89 @@
+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 guarantees = sequelize.define(
+    'guarantees',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      method: {
+        type: DataTypes.ENUM,
+
+        values: ['especes', 'carte_bloquee', 'cheque'],
+      },
+
+      amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['retenue', 'restituee', 'partielle'],
+      },
+
+      proof_url: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  guarantees.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.guarantees.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.guarantees.belongsTo(db.reservations, {
+      as: 'reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.guarantees.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.guarantees.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.guarantees.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return guarantees;
+};
--- a/backend/src/db/models/index.js
+++ b/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;
--- a/backend/src/db/models/infractions.js
+++ b/backend/src/db/models/infractions.js
@ -0,0 +1,103 @@
+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 infractions = sequelize.define(
+    'infractions',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      ref_no: {
+        type: DataTypes.TEXT,
+      },
+
+      date: {
+        type: DataTypes.DATE,
+      },
+
+      location: {
+        type: DataTypes.TEXT,
+      },
+
+      amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['ouverte', 'payee', 'conteste'],
+      },
+
+      proof_url: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  infractions.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.infractions.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.infractions.belongsTo(db.vehicles, {
+      as: 'vehicle',
+      foreignKey: {
+        name: 'vehicleId',
+      },
+      constraints: false,
+    });
+
+    db.infractions.belongsTo(db.reservations, {
+      as: 'reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.infractions.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.infractions.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.infractions.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return infractions;
+};
--- a/backend/src/db/models/invoices_saas.js
+++ b/backend/src/db/models/invoices_saas.js
@ -0,0 +1,91 @@
+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 invoices_saas = sequelize.define(
+    'invoices_saas',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      invoice_number: {
+        type: DataTypes.TEXT,
+      },
+
+      amount_mad: {
+        type: DataTypes.DECIMAL,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['draft', 'sent', 'paid', 'void'],
+      },
+
+      issued_at: {
+        type: DataTypes.DATE,
+      },
+
+      pdf_url: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  invoices_saas.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.invoices_saas.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.invoices_saas.belongsTo(db.subscriptions, {
+      as: 'subscription',
+      foreignKey: {
+        name: 'subscriptionId',
+      },
+      constraints: false,
+    });
+
+    db.invoices_saas.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.invoices_saas.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.invoices_saas.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return invoices_saas;
+};
--- a/backend/src/db/models/maintenance.js
+++ b/backend/src/db/models/maintenance.js
@ -0,0 +1,95 @@
+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 maintenance = sequelize.define(
+    'maintenance',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      type: {
+        type: DataTypes.ENUM,
+
+        values: ['preventive', 'corrective'],
+      },
+
+      scheduled_at: {
+        type: DataTypes.DATE,
+      },
+
+      odometer: {
+        type: DataTypes.INTEGER,
+      },
+
+      cost: {
+        type: DataTypes.DECIMAL,
+      },
+
+      notes: {
+        type: DataTypes.TEXT,
+      },
+
+      attachments: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  maintenance.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.maintenance.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.maintenance.belongsTo(db.vehicles, {
+      as: 'vehicle',
+      foreignKey: {
+        name: 'vehicleId',
+      },
+      constraints: false,
+    });
+
+    db.maintenance.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.maintenance.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.maintenance.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return maintenance;
+};
--- a/backend/src/db/models/payments.js
+++ b/backend/src/db/models/payments.js
@ -0,0 +1,91 @@
+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 payments = sequelize.define(
+    'payments',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      method: {
+        type: DataTypes.ENUM,
+
+        values: ['especes', 'carte', 'virement', 'cheque'],
+      },
+
+      amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      paid_at: {
+        type: DataTypes.DATE,
+      },
+
+      receipt_ref: {
+        type: DataTypes.TEXT,
+      },
+
+      attachment_url: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  payments.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.payments.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.payments.belongsTo(db.reservations, {
+      as: 'reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.payments.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.payments.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.payments.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return payments;
+};
--- a/backend/src/db/models/permissions.js
+++ b/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;
+};
--- a/backend/src/db/models/plans.js
+++ b/backend/src/db/models/plans.js
@ -0,0 +1,91 @@
+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 plans = sequelize.define(
+    'plans',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      code: {
+        type: DataTypes.TEXT,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      period: {
+        type: DataTypes.ENUM,
+
+        values: ['monthly', 'yearly', 'both'],
+      },
+
+      price_mad: {
+        type: DataTypes.DECIMAL,
+      },
+
+      limits: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  plans.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.plans.hasMany(db.subscriptions, {
+      as: 'subscriptions_plan',
+      foreignKey: {
+        name: 'planId',
+      },
+      constraints: false,
+    });
+
+    db.plans.hasMany(db.tenants, {
+      as: 'tenants_plan',
+      foreignKey: {
+        name: 'planId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.plans.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.plans.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.plans.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return plans;
+};
--- a/backend/src/db/models/reservations.js
+++ b/backend/src/db/models/reservations.js
@ -0,0 +1,223 @@
+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 reservations = sequelize.define(
+    'reservations',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      ref: {
+        type: DataTypes.TEXT,
+      },
+
+      status_manual: {
+        type: DataTypes.ENUM,
+
+        values: ['en_attente', 'confirmee', 'annulee'],
+      },
+
+      status_computed: {
+        type: DataTypes.ENUM,
+
+        values: [
+          'a_venir',
+
+          'en_cours',
+
+          'a_restituer',
+
+          'en_retard',
+
+          'terminee',
+
+          'annulee',
+
+          'no_show',
+        ],
+      },
+
+      start_at: {
+        type: DataTypes.DATE,
+      },
+
+      end_at: {
+        type: DataTypes.DATE,
+      },
+
+      pickup_address: {
+        type: DataTypes.TEXT,
+      },
+
+      return_address: {
+        type: DataTypes.TEXT,
+      },
+
+      options: {
+        type: DataTypes.TEXT,
+      },
+
+      days: {
+        type: DataTypes.INTEGER,
+      },
+
+      price_per_day: {
+        type: DataTypes.DECIMAL,
+      },
+
+      total_price: {
+        type: DataTypes.DECIMAL,
+      },
+
+      paid_amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      balance_amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      guarantee_method: {
+        type: DataTypes.ENUM,
+
+        values: ['especes', 'carte_bloquee', 'cheque', 'aucune'],
+      },
+
+      guarantee_amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      guarantee_status: {
+        type: DataTypes.ENUM,
+
+        values: ['retenue', 'restituee', 'partielle', 'non_applicable'],
+      },
+
+      departure_validated_at: {
+        type: DataTypes.DATE,
+      },
+
+      return_validated_at: {
+        type: DataTypes.DATE,
+      },
+
+      notes: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  reservations.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.reservations.hasMany(db.claims, {
+      as: 'claims_reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.reservations.hasMany(db.drivers, {
+      as: 'drivers_reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.reservations.hasMany(db.guarantees, {
+      as: 'guarantees_reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.reservations.hasMany(db.infractions, {
+      as: 'infractions_reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.reservations.hasMany(db.payments, {
+      as: 'payments_reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.reservations.hasMany(db.vehicle_conditions, {
+      as: 'vehicle_conditions_reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.reservations.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.reservations.belongsTo(db.clients, {
+      as: 'client',
+      foreignKey: {
+        name: 'clientId',
+      },
+      constraints: false,
+    });
+
+    db.reservations.belongsTo(db.vehicles, {
+      as: 'vehicle',
+      foreignKey: {
+        name: 'vehicleId',
+      },
+      constraints: false,
+    });
+
+    db.reservations.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.reservations.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.reservations.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return reservations;
+};
--- a/backend/src/db/models/roles.js
+++ b/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;
+};
--- a/backend/src/db/models/subscriptions.js
+++ b/backend/src/db/models/subscriptions.js
@ -0,0 +1,105 @@
+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,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['active', 'past_due', 'canceled', 'trialing'],
+      },
+
+      current_period_start: {
+        type: DataTypes.DATE,
+      },
+
+      current_period_end: {
+        type: DataTypes.DATE,
+      },
+
+      payment_provider: {
+        type: DataTypes.ENUM,
+
+        values: ['stripe', 'manual', 'none'],
+      },
+
+      provider_customer_id: {
+        type: DataTypes.TEXT,
+      },
+
+      provider_subscription_id: {
+        type: DataTypes.TEXT,
+      },
+
+      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
+
+    db.subscriptions.hasMany(db.invoices_saas, {
+      as: 'invoices_saas_subscription',
+      foreignKey: {
+        name: 'subscriptionId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.subscriptions.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.subscriptions.belongsTo(db.plans, {
+      as: 'plan',
+      foreignKey: {
+        name: 'planId',
+      },
+      constraints: false,
+    });
+
+    db.subscriptions.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.subscriptions.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.subscriptions.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return subscriptions;
+};
--- a/backend/src/db/models/tenants.js
+++ b/backend/src/db/models/tenants.js
@ -0,0 +1,199 @@
+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 tenants = sequelize.define(
+    'tenants',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      subdomain: {
+        type: DataTypes.TEXT,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['active', 'suspended', 'trial'],
+      },
+
+      trial_ends_at: {
+        type: DataTypes.DATE,
+      },
+
+      billing_email: {
+        type: DataTypes.TEXT,
+      },
+
+      billing_phone: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  tenants.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.tenants.hasMany(db.claims, {
+      as: 'claims_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.clients, {
+      as: 'clients_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.company_profiles, {
+      as: 'company_profiles_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.drivers, {
+      as: 'drivers_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.expenses, {
+      as: 'expenses_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.guarantees, {
+      as: 'guarantees_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.infractions, {
+      as: 'infractions_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.invoices_saas, {
+      as: 'invoices_saas_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.maintenance, {
+      as: 'maintenance_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.payments, {
+      as: 'payments_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.reservations, {
+      as: 'reservations_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.subscriptions, {
+      as: 'subscriptions_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.vehicle_conditions, {
+      as: 'vehicle_conditions_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.hasMany(db.vehicles, {
+      as: 'vehicles_tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.tenants.belongsTo(db.plans, {
+      as: 'plan',
+      foreignKey: {
+        name: 'planId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.tenants.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.tenants.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return tenants;
+};
--- a/backend/src/db/models/users.js
+++ b/backend/src/db/models/users.js
@ -0,0 +1,179 @@
+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
+
+    //end loop
+
+    db.users.belongsTo(db.roles, {
+      as: 'app_role',
+      foreignKey: {
+        name: 'app_roleId',
+      },
+      constraints: false,
+    });
+
+    db.users.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      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;
+}
--- a/backend/src/db/models/vehicle_conditions.js
+++ b/backend/src/db/models/vehicle_conditions.js
@ -0,0 +1,77 @@
+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 vehicle_conditions = sequelize.define(
+    'vehicle_conditions',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      before: {
+        type: DataTypes.TEXT,
+      },
+
+      after: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  vehicle_conditions.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.vehicle_conditions.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.vehicle_conditions.belongsTo(db.reservations, {
+      as: 'reservation',
+      foreignKey: {
+        name: 'reservationId',
+      },
+      constraints: false,
+    });
+
+    db.vehicle_conditions.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.vehicle_conditions.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.vehicle_conditions.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return vehicle_conditions;
+};
--- a/backend/src/db/models/vehicles.js
+++ b/backend/src/db/models/vehicles.js
@ -0,0 +1,157 @@
+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 vehicles = sequelize.define(
+    'vehicles',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      plate_number: {
+        type: DataTypes.TEXT,
+      },
+
+      brand: {
+        type: DataTypes.TEXT,
+      },
+
+      model: {
+        type: DataTypes.TEXT,
+      },
+
+      year: {
+        type: DataTypes.INTEGER,
+      },
+
+      color: {
+        type: DataTypes.TEXT,
+      },
+
+      category: {
+        type: DataTypes.ENUM,
+
+        values: ['citadine', 'berline', 'SUV', 'utilitaire', 'luxe'],
+      },
+
+      fuel_type: {
+        type: DataTypes.ENUM,
+
+        values: ['essence', 'diesel', 'hybride', 'electrique'],
+      },
+
+      transmission: {
+        type: DataTypes.ENUM,
+
+        values: ['manuelle', 'automatique'],
+      },
+
+      mileage: {
+        type: DataTypes.INTEGER,
+      },
+
+      daily_price: {
+        type: DataTypes.DECIMAL,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['disponible', 'reserve', 'en_location', 'hors_service'],
+      },
+
+      insurance_expiry: {
+        type: DataTypes.DATE,
+      },
+
+      tech_visit_expiry: {
+        type: DataTypes.DATE,
+      },
+
+      photos: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  vehicles.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.vehicles.hasMany(db.expenses, {
+      as: 'expenses_vehicle',
+      foreignKey: {
+        name: 'vehicleId',
+      },
+      constraints: false,
+    });
+
+    db.vehicles.hasMany(db.infractions, {
+      as: 'infractions_vehicle',
+      foreignKey: {
+        name: 'vehicleId',
+      },
+      constraints: false,
+    });
+
+    db.vehicles.hasMany(db.maintenance, {
+      as: 'maintenance_vehicle',
+      foreignKey: {
+        name: 'vehicleId',
+      },
+      constraints: false,
+    });
+
+    db.vehicles.hasMany(db.reservations, {
+      as: 'reservations_vehicle',
+      foreignKey: {
+        name: 'vehicleId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.vehicles.belongsTo(db.tenants, {
+      as: 'tenant',
+      foreignKey: {
+        name: 'tenantId',
+      },
+      constraints: false,
+    });
+
+    db.vehicles.belongsTo(db.agences, {
+      as: 'agences',
+      foreignKey: {
+        name: 'agencesId',
+      },
+      constraints: false,
+    });
+
+    db.vehicles.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.vehicles.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return vehicles;
+};
--- a/backend/src/db/reset.js
+++ b/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);
+  });
--- a/backend/src/db/seeders/20200430130759-admin-user.js
+++ b/backend/src/db/seeders/20200430130759-admin-user.js
@ -0,0 +1,84 @@
+'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 admin_hash = bcrypt.hashSync(
+      config.admin_pass,
+      config.bcrypt.saltRounds,
+    );
+    let user_hash = bcrypt.hashSync(config.user_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: admin_hash,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        {
+          id: ids[1],
+          firstName: 'John',
+          email: 'john@doe.com',
+          emailVerified: true,
+          provider: config.providers.LOCAL,
+          password: user_hash,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        {
+          id: ids[2],
+          firstName: 'Client',
+          email: 'client@hello.com',
+          emailVerified: true,
+          provider: config.providers.LOCAL,
+          password: user_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: admin_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;
+    }
+  },
+};
--- a/backend/src/db/seeders/20200430130760-user-roles.js
+++ b/backend/src/db/seeders/20200430130760-user-roles.js
--- a/backend/src/db/seeders/20231127130745-sample-data.js
+++ b/backend/src/db/seeders/20231127130745-sample-data.js
--- a/backend/src/db/utils.js
+++ b/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(),
+      },
+    );
+  }
+};
--- a/backend/src/helpers.js
+++ b/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' });
+  }
+};
--- a/backend/src/index.js
+++ b/backend/src/index.js
@ -0,0 +1,279 @@
+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 claimsRoutes = require('./routes/claims');
+
+const clientsRoutes = require('./routes/clients');
+
+const company_profilesRoutes = require('./routes/company_profiles');
+
+const driversRoutes = require('./routes/drivers');
+
+const expensesRoutes = require('./routes/expenses');
+
+const guaranteesRoutes = require('./routes/guarantees');
+
+const infractionsRoutes = require('./routes/infractions');
+
+const invoices_saasRoutes = require('./routes/invoices_saas');
+
+const maintenanceRoutes = require('./routes/maintenance');
+
+const paymentsRoutes = require('./routes/payments');
+
+const plansRoutes = require('./routes/plans');
+
+const reservationsRoutes = require('./routes/reservations');
+
+const subscriptionsRoutes = require('./routes/subscriptions');
+
+const tenantsRoutes = require('./routes/tenants');
+
+const vehicle_conditionsRoutes = require('./routes/vehicle_conditions');
+
+const vehiclesRoutes = require('./routes/vehicles');
+
+const rolesRoutes = require('./routes/roles');
+
+const permissionsRoutes = require('./routes/permissions');
+
+const agencesRoutes = require('./routes/agences');
+
+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: 'Car zone',
+      description:
+        'Car zone 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/claims',
+  passport.authenticate('jwt', { session: false }),
+  claimsRoutes,
+);
+
+app.use(
+  '/api/clients',
+  passport.authenticate('jwt', { session: false }),
+  clientsRoutes,
+);
+
+app.use(
+  '/api/company_profiles',
+  passport.authenticate('jwt', { session: false }),
+  company_profilesRoutes,
+);
+
+app.use(
+  '/api/drivers',
+  passport.authenticate('jwt', { session: false }),
+  driversRoutes,
+);
+
+app.use(
+  '/api/expenses',
+  passport.authenticate('jwt', { session: false }),
+  expensesRoutes,
+);
+
+app.use(
+  '/api/guarantees',
+  passport.authenticate('jwt', { session: false }),
+  guaranteesRoutes,
+);
+
+app.use(
+  '/api/infractions',
+  passport.authenticate('jwt', { session: false }),
+  infractionsRoutes,
+);
+
+app.use(
+  '/api/invoices_saas',
+  passport.authenticate('jwt', { session: false }),
+  invoices_saasRoutes,
+);
+
+app.use(
+  '/api/maintenance',
+  passport.authenticate('jwt', { session: false }),
+  maintenanceRoutes,
+);
+
+app.use(
+  '/api/payments',
+  passport.authenticate('jwt', { session: false }),
+  paymentsRoutes,
+);
+
+app.use(
+  '/api/plans',
+  passport.authenticate('jwt', { session: false }),
+  plansRoutes,
+);
+
+app.use(
+  '/api/reservations',
+  passport.authenticate('jwt', { session: false }),
+  reservationsRoutes,
+);
+
+app.use(
+  '/api/subscriptions',
+  passport.authenticate('jwt', { session: false }),
+  subscriptionsRoutes,
+);
+
+app.use(
+  '/api/tenants',
+  passport.authenticate('jwt', { session: false }),
+  tenantsRoutes,
+);
+
+app.use(
+  '/api/vehicle_conditions',
+  passport.authenticate('jwt', { session: false }),
+  vehicle_conditionsRoutes,
+);
+
+app.use(
+  '/api/vehicles',
+  passport.authenticate('jwt', { session: false }),
+  vehiclesRoutes,
+);
+
+app.use(
+  '/api/roles',
+  passport.authenticate('jwt', { session: false }),
+  rolesRoutes,
+);
+
+app.use(
+  '/api/permissions',
+  passport.authenticate('jwt', { session: false }),
+  permissionsRoutes,
+);
+
+app.use(
+  '/api/agences',
+  passport.authenticate('jwt', { session: false }),
+  agencesRoutes,
+);
+
+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;
--- a/backend/src/middlewares/check-permissions.js
+++ b/backend/src/middlewares/check-permissions.js
@ -0,0 +1,176 @@
+const ValidationError = require('../services/notifications/errors/validation');
+const RolesDBApi = require('../db/api/roles');
+
+// Cache for the 'Public' role object
+let publicRoleCache = null;
+
+// Function to asynchronously fetch and cache the 'Public' role
+async function fetchAndCachePublicRole() {
+  try {
+    // Use RolesDBApi to find the role by name 'Public'
+    publicRoleCache = await RolesDBApi.findBy({ name: 'Public' });
+
+    if (!publicRoleCache) {
+      console.error(
+        "WARNING: Role 'Public' not found in database during middleware startup. Check your migrations.",
+      );
+      // The system might not function correctly without this role. May need to throw an error or use a fallback stub.
+    } else {
+      console.log("'Public' role successfully loaded and cached.");
+    }
+  } catch (error) {
+    console.error(
+      "Error fetching 'Public' role during middleware startup:",
+      error,
+    );
+    // Handle the error during startup fetch
+    throw error; // Important to know if the app can proceed without the Public role
+  }
+}
+
+// Trigger the role fetching when the check-permissions.js module is imported/loaded
+// This should happen during application startup when routes are being configured.
+fetchAndCachePublicRole().catch((error) => {
+  // Handle the case where the fetchAndCachePublicRole promise is rejected
+  console.error(
+    'Critical error during permissions middleware initialization:',
+    error,
+  );
+  // Decide here if the process should exit if the Public role is essential.
+  // process.exit(1);
+});
+
+/**
+ * Middleware creator to check if the current user (or Public role) has a specific permission.
+ * @param {string} permission - The name of the required permission.
+ * @return {import("express").RequestHandler} Express middleware function.
+ */
+function checkPermissions(permission) {
+  return async (req, res, next) => {
+    const { currentUser } = req;
+
+    // 1. Check self-access bypass (only if the user is authenticated)
+    if (
+      currentUser &&
+      (currentUser.id === req.params.id || currentUser.id === req.body.id)
+    ) {
+      return next(); // User has access to their own resource
+    }
+
+    // 2. Check Custom Permissions (only if the user is authenticated)
+    if (currentUser) {
+      // Ensure custom_permissions is an array before using find
+      const customPermissions = Array.isArray(currentUser.custom_permissions)
+        ? currentUser.custom_permissions
+        : [];
+      const userPermission = customPermissions.find(
+        (cp) => cp.name === permission,
+      );
+      if (userPermission) {
+        return next(); // User has a custom permission
+      }
+    }
+
+    // 3. Determine the "effective" role for permission check
+    let effectiveRole = null;
+    try {
+      if (currentUser && currentUser.app_role) {
+        // User is authenticated and has an assigned role
+        effectiveRole = currentUser.app_role;
+      } else {
+        // User is NOT authenticated OR is authenticated but has no role
+        // Use the cached 'Public' role
+        if (!publicRoleCache) {
+          // If the cache is unexpectedly empty (e.g., startup error caught),
+          // we can try fetching the role again synchronously (less ideal) or just deny access.
+          console.error(
+            'Public role cache is empty. Attempting synchronous fetch...',
+          );
+          // Less efficient fallback option:
+          effectiveRole = await RolesDBApi.findBy({ name: 'Public' }); // Could be slow
+          if (!effectiveRole) {
+            // If even the synchronous attempt failed
+            return next(
+              new Error(
+                'Internal Server Error: Public role missing and cannot be fetched.',
+              ),
+            );
+          }
+        } else {
+          effectiveRole = publicRoleCache; // Use the cached object
+        }
+      }
+
+      // Check if we got a valid role object
+      if (!effectiveRole) {
+        return next(
+          new Error(
+            'Internal Server Error: Could not determine effective role.',
+          ),
+        );
+      }
+
+      // 4. Check Permissions on the "effective" role
+      // Assume the effectiveRole object (from app_role or RolesDBApi) has a getPermissions() method
+      // or a 'permissions' property (if permissions are eagerly loaded).
+      let rolePermissions = [];
+      if (typeof effectiveRole.getPermissions === 'function') {
+        rolePermissions = await effectiveRole.getPermissions(); // Get permissions asynchronously if the method exists
+      } else if (Array.isArray(effectiveRole.permissions)) {
+        rolePermissions = effectiveRole.permissions; // Or take from property if permissions are pre-loaded
+      } else {
+        console.error(
+          'Role object lacks getPermissions() method or permissions property:',
+          effectiveRole,
+        );
+        return next(
+          new Error('Internal Server Error: Invalid role object format.'),
+        );
+      }
+
+      if (rolePermissions.find((p) => p.name === permission)) {
+        next(); // The "effective" role has the required permission
+      } else {
+        // The "effective" role does not have the required permission
+        const roleName = effectiveRole.name || 'unknown role';
+        next(
+          new ValidationError(
+            'auth.forbidden',
+            `Role '${roleName}' denied access to '${permission}'.`,
+          ),
+        );
+      }
+    } catch (e) {
+      // Handle errors during role or permission fetching
+      console.error('Error during permission check:', e);
+      next(e); // Pass the error to the next middleware
+    }
+  };
+}
+
+const METHOD_MAP = {
+  POST: 'CREATE',
+  GET: 'READ',
+  PUT: 'UPDATE',
+  PATCH: 'UPDATE',
+  DELETE: 'DELETE',
+};
+
+/**
+ * Middleware creator to check standard CRUD permissions based on HTTP method and entity name.
+ * @param {string} name - The name of the entity.
+ * @return {import("express").RequestHandler} Express middleware function.
+ */
+function checkCrudPermissions(name) {
+  return (req, res, next) => {
+    // Dynamically determine the permission name (e.g., 'READ_USERS')
+    const permissionName = `${METHOD_MAP[req.method]}_${name.toUpperCase()}`;
+    // Call the checkPermissions middleware with the determined permission
+    checkPermissions(permissionName)(req, res, next);
+  };
+}
+
+module.exports = {
+  checkPermissions,
+  checkCrudPermissions,
+};
--- a/backend/src/middlewares/upload.js
+++ b/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;
--- a/backend/src/routes/agences.js
+++ b/backend/src/routes/agences.js
@ -0,0 +1,452 @@
+const express = require('express');
+
+const AgencesService = require('../services/agences');
+const AgencesDBApi = require('../db/api/agences');
+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('agences'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Agences:
+ *        type: object
+ *        properties:
+
+ *          name:
+ *            type: string
+ *            default: name
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Agences
+ *   description: The Agences managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/agences:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Agences]
+ *      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/Agences"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Agences"
+ *        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 AgencesService.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: [Agences]
+ *    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/Agences"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Agences"
+ *      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 AgencesService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/agences/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Agences]
+ *      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/Agences"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Agences"
+ *        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 AgencesService.update(req.body.data, req.body.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/agences/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Agences]
+ *      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/Agences"
+ *        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 AgencesService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/agences/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Agences]
+ *      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/Agences"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await AgencesService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/agences:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Agences]
+ *      summary: Get all agences
+ *      description: Get all agences
+ *      responses:
+ *        200:
+ *          description: Agences list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Agences"
+ *        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 AgencesDBApi.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/agences/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Agences]
+ *      summary: Count all agences
+ *      description: Count all agences
+ *      responses:
+ *        200:
+ *          description: Agences count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Agences"
+ *        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 AgencesDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/agences/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Agences]
+ *      summary: Find all agences that match search criteria
+ *      description: Find all agences that match search criteria
+ *      responses:
+ *        200:
+ *          description: Agences list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Agences"
+ *        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 AgencesDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/agences/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Agences]
+ *      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/Agences"
+ *        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 AgencesDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;
--- a/backend/src/routes/auth.js
+++ b/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;
--- a/backend/src/routes/claims.js
+++ b/backend/src/routes/claims.js
@ -0,0 +1,454 @@
+const express = require('express');
+
+const ClaimsService = require('../services/claims');
+const ClaimsDBApi = require('../db/api/claims');
+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('claims'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Claims:
+ *        type: object
+ *        properties:
+
+ *          category:
+ *            type: string
+ *            default: category
+ *          description:
+ *            type: string
+ *            default: description
+ *          attachments:
+ *            type: string
+ *            default: attachments
+
+ *          
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Claims
+ *   description: The Claims managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/claims:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Claims]
+ *      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/Claims"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Claims"
+ *        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 ClaimsService.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: [Claims]
+ *    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/Claims"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Claims"
+ *      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 ClaimsService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/claims/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Claims]
+ *      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/Claims"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Claims"
+ *        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 ClaimsService.update(req.body.data, req.body.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/claims/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Claims]
+ *      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/Claims"
+ *        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 ClaimsService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/claims/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Claims]
+ *      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/Claims"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await ClaimsService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/claims:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Claims]
+ *      summary: Get all claims
+ *      description: Get all claims
+ *      responses:
+ *        200:
+ *          description: Claims list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Claims"
+ *        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 ClaimsDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = ['id', 'category', 'description', 'attachments'];
+      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/claims/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Claims]
+ *      summary: Count all claims
+ *      description: Count all claims
+ *      responses:
+ *        200:
+ *          description: Claims count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Claims"
+ *        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 ClaimsDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/claims/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Claims]
+ *      summary: Find all claims that match search criteria
+ *      description: Find all claims that match search criteria
+ *      responses:
+ *        200:
+ *          description: Claims list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Claims"
+ *        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 ClaimsDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/claims/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Claims]
+ *      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/Claims"
+ *        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 ClaimsDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;
--- a/backend/src/routes/clients.js
+++ b/backend/src/routes/clients.js
@ -0,0 +1,488 @@
+const express = require('express');
+
+const ClientsService = require('../services/clients');
+const ClientsDBApi = require('../db/api/clients');
+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('clients'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Clients:
+ *        type: object
+ *        properties:
+
+ *          first_name:
+ *            type: string
+ *            default: first_name
+ *          last_name:
+ *            type: string
+ *            default: last_name
+ *          phone:
+ *            type: string
+ *            default: phone
+ *          address:
+ *            type: string
+ *            default: address
+ *          id_number:
+ *            type: string
+ *            default: id_number
+ *          license_number:
+ *            type: string
+ *            default: license_number
+ *          id_copy_url:
+ *            type: string
+ *            default: id_copy_url
+ *          license_copy_url:
+ *            type: string
+ *            default: license_copy_url
+
+ *          
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Clients
+ *   description: The Clients managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/clients:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Clients]
+ *      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/Clients"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Clients"
+ *        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 ClientsService.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: [Clients]
+ *    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/Clients"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Clients"
+ *      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 ClientsService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/clients/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Clients]
+ *      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/Clients"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Clients"
+ *        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 ClientsService.update(req.body.data, req.body.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/clients/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Clients]
+ *      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/Clients"
+ *        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 ClientsService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/clients/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Clients]
+ *      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/Clients"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await ClientsService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/clients:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Clients]
+ *      summary: Get all clients
+ *      description: Get all clients
+ *      responses:
+ *        200:
+ *          description: Clients list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Clients"
+ *        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 ClientsDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = [
+        'id',
+        'first_name',
+        'last_name',
+        'phone',
+        'address',
+        'id_number',
+        'license_number',
+        'id_copy_url',
+        'license_copy_url',
+
+        'birth_date',
+        'id_issue_date',
+        'license_issue_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/clients/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Clients]
+ *      summary: Count all clients
+ *      description: Count all clients
+ *      responses:
+ *        200:
+ *          description: Clients count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Clients"
+ *        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 ClientsDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/clients/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Clients]
+ *      summary: Find all clients that match search criteria
+ *      description: Find all clients that match search criteria
+ *      responses:
+ *        200:
+ *          description: Clients list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Clients"
+ *        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 ClientsDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/clients/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Clients]
+ *      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/Clients"
+ *        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 ClientsDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;
--- a/backend/src/routes/company_profiles.js
+++ b/backend/src/routes/company_profiles.js
@ -0,0 +1,498 @@
+const express = require('express');
+
+const Company_profilesService = require('../services/company_profiles');
+const Company_profilesDBApi = require('../db/api/company_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('company_profiles'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Company_profiles:
+ *        type: object
+ *        properties:
+
+ *          legal_name:
+ *            type: string
+ *            default: legal_name
+ *          address:
+ *            type: string
+ *            default: address
+ *          phone:
+ *            type: string
+ *            default: phone
+ *          email:
+ *            type: string
+ *            default: email
+ *          website:
+ *            type: string
+ *            default: website
+ *          rc:
+ *            type: string
+ *            default: rc
+ *          ice:
+ *            type: string
+ *            default: ice
+ *          patente:
+ *            type: string
+ *            default: patente
+ *          logo_url:
+ *            type: string
+ *            default: logo_url
+ *          pdf_footer:
+ *            type: string
+ *            default: pdf_footer
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Company_profiles
+ *   description: The Company_profiles managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/company_profiles:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Company_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/Company_profiles"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Company_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 Company_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: [Company_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/Company_profiles"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Company_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 Company_profilesService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/company_profiles/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Company_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/Company_profiles"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Company_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 Company_profilesService.update(
+      req.body.data,
+      req.body.id,
+      req.currentUser,
+    );
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/company_profiles/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Company_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/Company_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 Company_profilesService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/company_profiles/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Company_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/Company_profiles"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await Company_profilesService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/company_profiles:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Company_profiles]
+ *      summary: Get all company_profiles
+ *      description: Get all company_profiles
+ *      responses:
+ *        200:
+ *          description: Company_profiles list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Company_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 Company_profilesDBApi.findAll(
+      req.query,
+      globalAccess,
+      { currentUser },
+    );
+    if (filetype && filetype === 'csv') {
+      const fields = [
+        'id',
+        'legal_name',
+        'address',
+        'phone',
+        'email',
+        'website',
+        'rc',
+        'ice',
+        'patente',
+        'logo_url',
+        'pdf_footer',
+      ];
+      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/company_profiles/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Company_profiles]
+ *      summary: Count all company_profiles
+ *      description: Count all company_profiles
+ *      responses:
+ *        200:
+ *          description: Company_profiles count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Company_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 Company_profilesDBApi.findAll(
+      req.query,
+      globalAccess,
+      { countOnly: true, currentUser },
+    );
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/company_profiles/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Company_profiles]
+ *      summary: Find all company_profiles that match search criteria
+ *      description: Find all company_profiles that match search criteria
+ *      responses:
+ *        200:
+ *          description: Company_profiles list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Company_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 Company_profilesDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/company_profiles/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Company_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/Company_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 Company_profilesDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;
--- a/backend/src/routes/contactForm.js
+++ b/backend/src/routes/contactForm.js
--- a/backend/src/routes/drivers.js
+++ b/backend/src/routes/drivers.js
@ -0,0 +1,469 @@
+const express = require('express');
+
+const DriversService = require('../services/drivers');
+const DriversDBApi = require('../db/api/drivers');
+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('drivers'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Drivers:
+ *        type: object
+ *        properties:
+
+ *          full_name:
+ *            type: string
+ *            default: full_name
+ *          license_number:
+ *            type: string
+ *            default: license_number
+ *          id_copy_url:
+ *            type: string
+ *            default: id_copy_url
+ *          license_copy_url:
+ *            type: string
+ *            default: license_copy_url
+
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Drivers
+ *   description: The Drivers managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/drivers:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Drivers]
+ *      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/Drivers"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Drivers"
+ *        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 DriversService.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: [Drivers]
+ *    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/Drivers"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Drivers"
+ *      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 DriversService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/drivers/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Drivers]
+ *      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/Drivers"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Drivers"
+ *        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 DriversService.update(req.body.data, req.body.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/drivers/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Drivers]
+ *      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/Drivers"
+ *        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 DriversService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/drivers/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Drivers]
+ *      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/Drivers"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await DriversService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/drivers:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Drivers]
+ *      summary: Get all drivers
+ *      description: Get all drivers
+ *      responses:
+ *        200:
+ *          description: Drivers list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Drivers"
+ *        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 DriversDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = [
+        'id',
+        'full_name',
+        'license_number',
+        'id_copy_url',
+        'license_copy_url',
+
+        'license_issue_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/drivers/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Drivers]
+ *      summary: Count all drivers
+ *      description: Count all drivers
+ *      responses:
+ *        200:
+ *          description: Drivers count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Drivers"
+ *        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 DriversDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/drivers/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Drivers]
+ *      summary: Find all drivers that match search criteria
+ *      description: Find all drivers that match search criteria
+ *      responses:
+ *        200:
+ *          description: Drivers list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Drivers"
+ *        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 DriversDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/drivers/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Drivers]
+ *      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/Drivers"
+ *        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 DriversDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;
--- a/backend/src/routes/expenses.js
+++ b/backend/src/routes/expenses.js
@ -0,0 +1,471 @@
+const express = require('express');
+
+const ExpensesService = require('../services/expenses');
+const ExpensesDBApi = require('../db/api/expenses');
+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('expenses'));
+
+/**
+ *  @swagger
+ *  components:
+ *    schemas:
+ *      Expenses:
+ *        type: object
+ *        properties:
+
+ *          category:
+ *            type: string
+ *            default: category
+ *          note:
+ *            type: string
+ *            default: note
+ *          attachment_url:
+ *            type: string
+ *            default: attachment_url
+
+ *          amount:
+ *            type: integer
+ *            format: int64
+
+ *          
+ */
+
+/**
+ *  @swagger
+ * tags:
+ *   name: Expenses
+ *   description: The Expenses managing API
+ */
+
+/**
+ *  @swagger
+ *  /api/expenses:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Expenses]
+ *      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/Expenses"
+ *      responses:
+ *        200:
+ *          description: The item was successfully added
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Expenses"
+ *        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 ExpensesService.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: [Expenses]
+ *    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/Expenses"
+ *    responses:
+ *      200:
+ *        description: The items were successfully imported
+ *    content:
+ *      application/json:
+ *        schema:
+ *          $ref: "#/components/schemas/Expenses"
+ *      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 ExpensesService.bulkImport(req, res, true, link.host);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/expenses/{id}:
+ *    put:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Expenses]
+ *      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/Expenses"
+ *              required:
+ *                - id
+ *      responses:
+ *        200:
+ *          description: The item data was successfully updated
+ *          content:
+ *            application/json:
+ *              schema:
+ *                $ref: "#/components/schemas/Expenses"
+ *        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 ExpensesService.update(req.body.data, req.body.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ * @swagger
+ *  /api/expenses/{id}:
+ *    delete:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Expenses]
+ *      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/Expenses"
+ *        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 ExpensesService.remove(req.params.id, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/expenses/deleteByIds:
+ *    post:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Expenses]
+ *      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/Expenses"
+ *        401:
+ *          $ref: "#/components/responses/UnauthorizedError"
+ *        404:
+ *          description: Items not found
+ *        500:
+ *          description: Some server error
+ */
+router.post(
+  '/deleteByIds',
+  wrapAsync(async (req, res) => {
+    await ExpensesService.deleteByIds(req.body.data, req.currentUser);
+    const payload = true;
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/expenses:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Expenses]
+ *      summary: Get all expenses
+ *      description: Get all expenses
+ *      responses:
+ *        200:
+ *          description: Expenses list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Expenses"
+ *        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 ExpensesDBApi.findAll(req.query, globalAccess, {
+      currentUser,
+    });
+    if (filetype && filetype === 'csv') {
+      const fields = [
+        'id',
+        'category',
+        'note',
+        'attachment_url',
+
+        'amount',
+        '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/expenses/count:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Expenses]
+ *      summary: Count all expenses
+ *      description: Count all expenses
+ *      responses:
+ *        200:
+ *          description: Expenses count successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Expenses"
+ *        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 ExpensesDBApi.findAll(req.query, globalAccess, {
+      countOnly: true,
+      currentUser,
+    });
+
+    res.status(200).send(payload);
+  }),
+);
+
+/**
+ *  @swagger
+ *  /api/expenses/autocomplete:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Expenses]
+ *      summary: Find all expenses that match search criteria
+ *      description: Find all expenses that match search criteria
+ *      responses:
+ *        200:
+ *          description: Expenses list successfully received
+ *          content:
+ *            application/json:
+ *              schema:
+ *                type: array
+ *                items:
+ *                  $ref: "#/components/schemas/Expenses"
+ *        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 ExpensesDBApi.findAllAutocomplete(
+    req.query.query,
+    req.query.limit,
+    req.query.offset,
+    globalAccess,
+    organizationId,
+  );
+
+  res.status(200).send(payload);
+});
+
+/**
+ * @swagger
+ *  /api/expenses/{id}:
+ *    get:
+ *      security:
+ *        - bearerAuth: []
+ *      tags: [Expenses]
+ *      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/Expenses"
+ *        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 ExpensesDBApi.findBy({ id: req.params.id });
+
+    res.status(200).send(payload);
+  }),
+);
+
+router.use('/', require('../helpers').commonErrorHandler);
+
+module.exports = router;
--- a/backend/src/routes/file.js
+++ b/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;
--- a/Show More
+++ b/Show More