Initial version

2025-09-02 05:46:03 +00:00 · 2025-09-02 05:46:03 +00:00 · 1676b53366
commit 1676b53366
922 changed files with 196574 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>CTPLERP</h2>
+            <p>A comprehensive HRMS + ATS platform for seamless employee management.</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 @@
+
+
+# CTPLERP
+
+## 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: "1ee96857",
+  admin_email: "admin@flatlogic.com",
+  schema_encryption_key: process.env.SCHEMA_ENCRYPTION_KEY || '',
+
+  project_uuid: '1ee96857-e87a-431f-9118-b2ad6ee7f151',
+  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 = '33806';
+    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 @@
+#CTPLERP - 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_ctplerp;`
+
+- Then give that new user privileges to the new database then quit the `psql`.
+  - `postgres=> GRANT ALL PRIVILEGES ON DATABASE db_ctplerp 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": "ctplerp",
+  "description": "CTPLERP - 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: 'f9dbaa9b3e36fc0b0e8da83ac913a37d',
+  },
+  bcrypt: {
+    saltRounds: 12,
+  },
+  admin_pass: '1ee96857',
+  user_pass: 'b2ad6ee7f151',
+  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: 'CTPLERP <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: 'Finance Analyst',
+  },
+
+  project_uuid: '1ee96857-e87a-431f-9118-b2ad6ee7f151',
+  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 teamwork concept illustration';
+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/app_accounts.js
+++ b/backend/src/db/api/app_accounts.js
@ -0,0 +1,366 @@
+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 App_accountsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const app_accounts = await db.app_accounts.create(
+      {
+        id: data.id || undefined,
+
+        role: data.role || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await app_accounts.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await app_accounts.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return app_accounts;
+  }
+
+  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 app_accountsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      role: item.role || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const app_accounts = await db.app_accounts.bulkCreate(app_accountsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return app_accounts;
+  }
+
+  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 app_accounts = await db.app_accounts.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.role !== undefined) updatePayload.role = data.role;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await app_accounts.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await app_accounts.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await app_accounts.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return app_accounts;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const app_accounts = await db.app_accounts.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of app_accounts) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of app_accounts) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return app_accounts;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const app_accounts = await db.app_accounts.findByPk(id, options);
+
+    await app_accounts.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await app_accounts.destroy({
+      transaction,
+    });
+
+    return app_accounts;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const app_accounts = await db.app_accounts.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!app_accounts) {
+      return app_accounts;
+    }
+
+    const output = app_accounts.get({ plain: true });
+
+    output.employee = await app_accounts.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await app_accounts.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.role) {
+        where = {
+          ...where,
+          role: filter.role,
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.app_accounts.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('app_accounts', 'id', query),
+        ],
+      };
+    }
+
+    const records = await db.app_accounts.findAll({
+      attributes: ['id', 'id'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['id', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.id,
+    }));
+  }
+};
--- a/backend/src/db/api/applications.js
+++ b/backend/src/db/api/applications.js
@ -0,0 +1,435 @@
+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 ApplicationsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const applications = await db.applications.create(
+      {
+        id: data.id || undefined,
+
+        submitted_at: data.submitted_at || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await applications.setCandidate(data.candidate || null, {
+      transaction,
+    });
+
+    await applications.setRequisition(data.requisition || null, {
+      transaction,
+    });
+
+    await applications.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return applications;
+  }
+
+  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 applicationsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      submitted_at: item.submitted_at || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const applications = await db.applications.bulkCreate(applicationsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return applications;
+  }
+
+  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 applications = await db.applications.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.submitted_at !== undefined)
+      updatePayload.submitted_at = data.submitted_at;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await applications.update(updatePayload, { transaction });
+
+    if (data.candidate !== undefined) {
+      await applications.setCandidate(
+        data.candidate,
+
+        { transaction },
+      );
+    }
+
+    if (data.requisition !== undefined) {
+      await applications.setRequisition(
+        data.requisition,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await applications.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return applications;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const applications = await db.applications.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of applications) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of applications) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return applications;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const applications = await db.applications.findByPk(id, options);
+
+    await applications.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await applications.destroy({
+      transaction,
+    });
+
+    return applications;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const applications = await db.applications.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!applications) {
+      return applications;
+    }
+
+    const output = applications.get({ plain: true });
+
+    output.interviews_application =
+      await applications.getInterviews_application({
+        transaction,
+      });
+
+    output.offers_application = await applications.getOffers_application({
+      transaction,
+    });
+
+    output.candidate = await applications.getCandidate({
+      transaction,
+    });
+
+    output.requisition = await applications.getRequisition({
+      transaction,
+    });
+
+    output.organizations = await applications.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.candidates,
+        as: 'candidate',
+
+        where: filter.candidate
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.candidate
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.candidate
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.job_requisitions,
+        as: 'requisition',
+
+        where: filter.requisition
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.requisition
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  title: {
+                    [Op.or]: filter.requisition
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.submitted_atRange) {
+        const [start, end] = filter.submitted_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            submitted_at: {
+              ...where.submitted_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            submitted_at: {
+              ...where.submitted_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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.applications.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('applications', 'status', query),
+        ],
+      };
+    }
+
+    const records = await db.applications.findAll({
+      attributes: ['id', 'status'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['status', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.status,
+    }));
+  }
+};
--- a/backend/src/db/api/approvals.js
+++ b/backend/src/db/api/approvals.js
@ -0,0 +1,442 @@
+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 ApprovalsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const approvals = await db.approvals.create(
+      {
+        id: data.id || undefined,
+
+        object_type: data.object_type || null,
+        object_id: data.object_id || null,
+        step: data.step || null,
+        status: data.status || null,
+        timestamp: data.timestamp || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await approvals.setApprover(data.approver || null, {
+      transaction,
+    });
+
+    await approvals.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return approvals;
+  }
+
+  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 approvalsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      object_type: item.object_type || null,
+      object_id: item.object_id || null,
+      step: item.step || null,
+      status: item.status || null,
+      timestamp: item.timestamp || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const approvals = await db.approvals.bulkCreate(approvalsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return approvals;
+  }
+
+  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 approvals = await db.approvals.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.object_type !== undefined)
+      updatePayload.object_type = data.object_type;
+
+    if (data.object_id !== undefined) updatePayload.object_id = data.object_id;
+
+    if (data.step !== undefined) updatePayload.step = data.step;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.timestamp !== undefined) updatePayload.timestamp = data.timestamp;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await approvals.update(updatePayload, { transaction });
+
+    if (data.approver !== undefined) {
+      await approvals.setApprover(
+        data.approver,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await approvals.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return approvals;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const approvals = await db.approvals.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of approvals) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of approvals) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return approvals;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const approvals = await db.approvals.findByPk(id, options);
+
+    await approvals.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await approvals.destroy({
+      transaction,
+    });
+
+    return approvals;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const approvals = await db.approvals.findOne({ where }, { transaction });
+
+    if (!approvals) {
+      return approvals;
+    }
+
+    const output = approvals.get({ plain: true });
+
+    output.approver = await approvals.getApprover({
+      transaction,
+    });
+
+    output.organizations = await approvals.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'approver',
+
+        where: filter.approver
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.approver
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.approver
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.object_type) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('approvals', 'object_type', filter.object_type),
+        };
+      }
+
+      if (filter.object_idRange) {
+        const [start, end] = filter.object_idRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            object_id: {
+              ...where.object_id,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            object_id: {
+              ...where.object_id,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.stepRange) {
+        const [start, end] = filter.stepRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            step: {
+              ...where.step,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            step: {
+              ...where.step,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.timestampRange) {
+        const [start, end] = filter.timestampRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            timestamp: {
+              ...where.timestamp,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            timestamp: {
+              ...where.timestamp,
+              [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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.approvals.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('approvals', 'object_type', query),
+        ],
+      };
+    }
+
+    const records = await db.approvals.findAll({
+      attributes: ['id', 'object_type'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['object_type', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.object_type,
+    }));
+  }
+};
--- a/backend/src/db/api/audit_logs.js
+++ b/backend/src/db/api/audit_logs.js
@ -0,0 +1,398 @@
+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 Audit_logsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const audit_logs = await db.audit_logs.create(
+      {
+        id: data.id || undefined,
+
+        actor: data.actor || null,
+        action: data.action || null,
+        object_type: data.object_type || null,
+        object_id: data.object_id || null,
+        timestamp: data.timestamp || null,
+        diff: data.diff || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await audit_logs.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return audit_logs;
+  }
+
+  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 audit_logsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      actor: item.actor || null,
+      action: item.action || null,
+      object_type: item.object_type || null,
+      object_id: item.object_id || null,
+      timestamp: item.timestamp || null,
+      diff: item.diff || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const audit_logs = await db.audit_logs.bulkCreate(audit_logsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return audit_logs;
+  }
+
+  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 audit_logs = await db.audit_logs.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.actor !== undefined) updatePayload.actor = data.actor;
+
+    if (data.action !== undefined) updatePayload.action = data.action;
+
+    if (data.object_type !== undefined)
+      updatePayload.object_type = data.object_type;
+
+    if (data.object_id !== undefined) updatePayload.object_id = data.object_id;
+
+    if (data.timestamp !== undefined) updatePayload.timestamp = data.timestamp;
+
+    if (data.diff !== undefined) updatePayload.diff = data.diff;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await audit_logs.update(updatePayload, { transaction });
+
+    if (data.organizations !== undefined) {
+      await audit_logs.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return audit_logs;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const audit_logs = await db.audit_logs.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of audit_logs) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of audit_logs) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return audit_logs;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const audit_logs = await db.audit_logs.findByPk(id, options);
+
+    await audit_logs.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await audit_logs.destroy({
+      transaction,
+    });
+
+    return audit_logs;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const audit_logs = await db.audit_logs.findOne({ where }, { transaction });
+
+    if (!audit_logs) {
+      return audit_logs;
+    }
+
+    const output = audit_logs.get({ plain: true });
+
+    output.organizations = await audit_logs.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.actor) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('audit_logs', 'actor', filter.actor),
+        };
+      }
+
+      if (filter.action) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('audit_logs', 'action', filter.action),
+        };
+      }
+
+      if (filter.object_type) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'audit_logs',
+            'object_type',
+            filter.object_type,
+          ),
+        };
+      }
+
+      if (filter.diff) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('audit_logs', 'diff', filter.diff),
+        };
+      }
+
+      if (filter.object_idRange) {
+        const [start, end] = filter.object_idRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            object_id: {
+              ...where.object_id,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            object_id: {
+              ...where.object_id,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.timestampRange) {
+        const [start, end] = filter.timestampRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            timestamp: {
+              ...where.timestamp,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            timestamp: {
+              ...where.timestamp,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.audit_logs.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('audit_logs', 'actor', query),
+        ],
+      };
+    }
+
+    const records = await db.audit_logs.findAll({
+      attributes: ['id', 'actor'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['actor', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.actor,
+    }));
+  }
+};
--- a/backend/src/db/api/benefit_plans.js
+++ b/backend/src/db/api/benefit_plans.js
@ -0,0 +1,350 @@
+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 Benefit_plansDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const benefit_plans = await db.benefit_plans.create(
+      {
+        id: data.id || undefined,
+
+        carrier: data.carrier || null,
+        plan_type: data.plan_type || null,
+        country: data.country || null,
+        currency: data.currency || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await benefit_plans.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return benefit_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 benefit_plansData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      carrier: item.carrier || null,
+      plan_type: item.plan_type || null,
+      country: item.country || null,
+      currency: item.currency || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const benefit_plans = await db.benefit_plans.bulkCreate(benefit_plansData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return benefit_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 benefit_plans = await db.benefit_plans.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.carrier !== undefined) updatePayload.carrier = data.carrier;
+
+    if (data.plan_type !== undefined) updatePayload.plan_type = data.plan_type;
+
+    if (data.country !== undefined) updatePayload.country = data.country;
+
+    if (data.currency !== undefined) updatePayload.currency = data.currency;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await benefit_plans.update(updatePayload, { transaction });
+
+    if (data.organizations !== undefined) {
+      await benefit_plans.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return benefit_plans;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const benefit_plans = await db.benefit_plans.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of benefit_plans) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of benefit_plans) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return benefit_plans;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const benefit_plans = await db.benefit_plans.findByPk(id, options);
+
+    await benefit_plans.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await benefit_plans.destroy({
+      transaction,
+    });
+
+    return benefit_plans;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const benefit_plans = await db.benefit_plans.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!benefit_plans) {
+      return benefit_plans;
+    }
+
+    const output = benefit_plans.get({ plain: true });
+
+    output.enrollments_plan = await benefit_plans.getEnrollments_plan({
+      transaction,
+    });
+
+    output.organizations = await benefit_plans.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.carrier) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('benefit_plans', 'carrier', filter.carrier),
+        };
+      }
+
+      if (filter.country) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('benefit_plans', 'country', filter.country),
+        };
+      }
+
+      if (filter.currency) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('benefit_plans', 'currency', filter.currency),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.plan_type) {
+        where = {
+          ...where,
+          plan_type: filter.plan_type,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.benefit_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('benefit_plans', 'carrier', query),
+        ],
+      };
+    }
+
+    const records = await db.benefit_plans.findAll({
+      attributes: ['id', 'carrier'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['carrier', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.carrier,
+    }));
+  }
+};
--- a/backend/src/db/api/bills.js
+++ b/backend/src/db/api/bills.js
@ -0,0 +1,467 @@
+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 BillsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const bills = await db.bills.create(
+      {
+        id: data.id || undefined,
+
+        invoice_no: data.invoice_no || null,
+        invoice_date: data.invoice_date || null,
+        due_date: data.due_date || null,
+        amount: data.amount || null,
+        currency: data.currency || null,
+        category: data.category || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await bills.setVendor(data.vendor || null, {
+      transaction,
+    });
+
+    await bills.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return bills;
+  }
+
+  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 billsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      invoice_no: item.invoice_no || null,
+      invoice_date: item.invoice_date || null,
+      due_date: item.due_date || null,
+      amount: item.amount || null,
+      currency: item.currency || null,
+      category: item.category || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const bills = await db.bills.bulkCreate(billsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return bills;
+  }
+
+  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 bills = await db.bills.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.invoice_no !== undefined)
+      updatePayload.invoice_no = data.invoice_no;
+
+    if (data.invoice_date !== undefined)
+      updatePayload.invoice_date = data.invoice_date;
+
+    if (data.due_date !== undefined) updatePayload.due_date = data.due_date;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    if (data.currency !== undefined) updatePayload.currency = data.currency;
+
+    if (data.category !== undefined) updatePayload.category = data.category;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await bills.update(updatePayload, { transaction });
+
+    if (data.vendor !== undefined) {
+      await bills.setVendor(
+        data.vendor,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await bills.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return bills;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const bills = await db.bills.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of bills) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of bills) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return bills;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const bills = await db.bills.findByPk(id, options);
+
+    await bills.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await bills.destroy({
+      transaction,
+    });
+
+    return bills;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const bills = await db.bills.findOne({ where }, { transaction });
+
+    if (!bills) {
+      return bills;
+    }
+
+    const output = bills.get({ plain: true });
+
+    output.payments_bill = await bills.getPayments_bill({
+      transaction,
+    });
+
+    output.vendor = await bills.getVendor({
+      transaction,
+    });
+
+    output.organizations = await bills.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.vendors,
+        as: 'vendor',
+
+        where: filter.vendor
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.vendor
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.vendor
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.invoice_no) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('bills', 'invoice_no', filter.invoice_no),
+        };
+      }
+
+      if (filter.currency) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('bills', 'currency', filter.currency),
+        };
+      }
+
+      if (filter.category) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('bills', 'category', filter.category),
+        };
+      }
+
+      if (filter.invoice_dateRange) {
+        const [start, end] = filter.invoice_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            invoice_date: {
+              ...where.invoice_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            invoice_date: {
+              ...where.invoice_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.due_dateRange) {
+        const [start, end] = filter.due_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            due_date: {
+              ...where.due_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            due_date: {
+              ...where.due_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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.bills.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('bills', 'invoice_no', query),
+        ],
+      };
+    }
+
+    const records = await db.bills.findAll({
+      attributes: ['id', 'invoice_no'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['invoice_no', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.invoice_no,
+    }));
+  }
+};
--- a/backend/src/db/api/candidates.js
+++ b/backend/src/db/api/candidates.js
@ -0,0 +1,353 @@
+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 CandidatesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const candidates = await db.candidates.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        email: data.email || null,
+        phone: data.phone || null,
+        source: data.source || null,
+        current_stage: data.current_stage || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await candidates.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return candidates;
+  }
+
+  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 candidatesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      email: item.email || null,
+      phone: item.phone || null,
+      source: item.source || null,
+      current_stage: item.current_stage || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const candidates = await db.candidates.bulkCreate(candidatesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return candidates;
+  }
+
+  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 candidates = await db.candidates.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    if (data.email !== undefined) updatePayload.email = data.email;
+
+    if (data.phone !== undefined) updatePayload.phone = data.phone;
+
+    if (data.source !== undefined) updatePayload.source = data.source;
+
+    if (data.current_stage !== undefined)
+      updatePayload.current_stage = data.current_stage;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await candidates.update(updatePayload, { transaction });
+
+    if (data.organizations !== undefined) {
+      await candidates.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return candidates;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const candidates = await db.candidates.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of candidates) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of candidates) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return candidates;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const candidates = await db.candidates.findByPk(id, options);
+
+    await candidates.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await candidates.destroy({
+      transaction,
+    });
+
+    return candidates;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const candidates = await db.candidates.findOne({ where }, { transaction });
+
+    if (!candidates) {
+      return candidates;
+    }
+
+    const output = candidates.get({ plain: true });
+
+    output.applications_candidate = await candidates.getApplications_candidate({
+      transaction,
+    });
+
+    output.organizations = await candidates.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('candidates', 'name', filter.name),
+        };
+      }
+
+      if (filter.email) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('candidates', 'email', filter.email),
+        };
+      }
+
+      if (filter.phone) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('candidates', 'phone', filter.phone),
+        };
+      }
+
+      if (filter.source) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('candidates', 'source', filter.source),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.current_stage) {
+        where = {
+          ...where,
+          current_stage: filter.current_stage,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.candidates.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('candidates', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.candidates.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/cards.js
+++ b/backend/src/db/api/cards.js
@ -0,0 +1,394 @@
+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 CardsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const cards = await db.cards.create(
+      {
+        id: data.id || undefined,
+
+        type: data.type || null,
+        last4: data.last4 || null,
+        limit: data.limit || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await cards.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await cards.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return cards;
+  }
+
+  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 cardsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      type: item.type || null,
+      last4: item.last4 || null,
+      limit: item.limit || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const cards = await db.cards.bulkCreate(cardsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return cards;
+  }
+
+  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 cards = await db.cards.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.type !== undefined) updatePayload.type = data.type;
+
+    if (data.last4 !== undefined) updatePayload.last4 = data.last4;
+
+    if (data.limit !== undefined) updatePayload.limit = data.limit;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await cards.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await cards.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await cards.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return cards;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const cards = await db.cards.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of cards) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of cards) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return cards;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const cards = await db.cards.findByPk(id, options);
+
+    await cards.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await cards.destroy({
+      transaction,
+    });
+
+    return cards;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const cards = await db.cards.findOne({ where }, { transaction });
+
+    if (!cards) {
+      return cards;
+    }
+
+    const output = cards.get({ plain: true });
+
+    output.employee = await cards.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await cards.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.last4) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('cards', 'last4', filter.last4),
+        };
+      }
+
+      if (filter.limitRange) {
+        const [start, end] = filter.limitRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            limit: {
+              ...where.limit,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            limit: {
+              ...where.limit,
+              [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.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.cards.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('cards', 'last4', query),
+        ],
+      };
+    }
+
+    const records = await db.cards.findAll({
+      attributes: ['id', 'last4'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['last4', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.last4,
+    }));
+  }
+};
--- a/backend/src/db/api/compensations.js
+++ b/backend/src/db/api/compensations.js
@ -0,0 +1,435 @@
+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 CompensationsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const compensations = await db.compensations.create(
+      {
+        id: data.id || undefined,
+
+        base_pay: data.base_pay || null,
+        pay_type: data.pay_type || null,
+        pay_frequency: data.pay_frequency || null,
+        currency: data.currency || null,
+        effective_date: data.effective_date || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await compensations.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await compensations.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return compensations;
+  }
+
+  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 compensationsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      base_pay: item.base_pay || null,
+      pay_type: item.pay_type || null,
+      pay_frequency: item.pay_frequency || null,
+      currency: item.currency || null,
+      effective_date: item.effective_date || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const compensations = await db.compensations.bulkCreate(compensationsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return compensations;
+  }
+
+  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 compensations = await db.compensations.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.base_pay !== undefined) updatePayload.base_pay = data.base_pay;
+
+    if (data.pay_type !== undefined) updatePayload.pay_type = data.pay_type;
+
+    if (data.pay_frequency !== undefined)
+      updatePayload.pay_frequency = data.pay_frequency;
+
+    if (data.currency !== undefined) updatePayload.currency = data.currency;
+
+    if (data.effective_date !== undefined)
+      updatePayload.effective_date = data.effective_date;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await compensations.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await compensations.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await compensations.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return compensations;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const compensations = await db.compensations.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of compensations) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of compensations) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return compensations;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const compensations = await db.compensations.findByPk(id, options);
+
+    await compensations.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await compensations.destroy({
+      transaction,
+    });
+
+    return compensations;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const compensations = await db.compensations.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!compensations) {
+      return compensations;
+    }
+
+    const output = compensations.get({ plain: true });
+
+    output.employee = await compensations.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await compensations.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.currency) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('compensations', 'currency', filter.currency),
+        };
+      }
+
+      if (filter.base_payRange) {
+        const [start, end] = filter.base_payRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            base_pay: {
+              ...where.base_pay,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            base_pay: {
+              ...where.base_pay,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.effective_dateRange) {
+        const [start, end] = filter.effective_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            effective_date: {
+              ...where.effective_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            effective_date: {
+              ...where.effective_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.pay_type) {
+        where = {
+          ...where,
+          pay_type: filter.pay_type,
+        };
+      }
+
+      if (filter.pay_frequency) {
+        where = {
+          ...where,
+          pay_frequency: filter.pay_frequency,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.compensations.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('compensations', 'base_pay', query),
+        ],
+      };
+    }
+
+    const records = await db.compensations.findAll({
+      attributes: ['id', 'base_pay'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['base_pay', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.base_pay,
+    }));
+  }
+};
--- a/backend/src/db/api/deductions.js
+++ b/backend/src/db/api/deductions.js
@ -0,0 +1,416 @@
+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 DeductionsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const deductions = await db.deductions.create(
+      {
+        id: data.id || undefined,
+
+        type: data.type || null,
+        amount: data.amount || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await deductions.setPayroll_run(data.payroll_run || null, {
+      transaction,
+    });
+
+    await deductions.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await deductions.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return deductions;
+  }
+
+  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 deductionsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      type: item.type || null,
+      amount: item.amount || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const deductions = await db.deductions.bulkCreate(deductionsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return deductions;
+  }
+
+  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 deductions = await db.deductions.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.type !== undefined) updatePayload.type = data.type;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await deductions.update(updatePayload, { transaction });
+
+    if (data.payroll_run !== undefined) {
+      await deductions.setPayroll_run(
+        data.payroll_run,
+
+        { transaction },
+      );
+    }
+
+    if (data.employee !== undefined) {
+      await deductions.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await deductions.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return deductions;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const deductions = await db.deductions.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of deductions) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of deductions) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return deductions;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const deductions = await db.deductions.findByPk(id, options);
+
+    await deductions.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await deductions.destroy({
+      transaction,
+    });
+
+    return deductions;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const deductions = await db.deductions.findOne({ where }, { transaction });
+
+    if (!deductions) {
+      return deductions;
+    }
+
+    const output = deductions.get({ plain: true });
+
+    output.payroll_run = await deductions.getPayroll_run({
+      transaction,
+    });
+
+    output.employee = await deductions.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await deductions.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.payroll_runs,
+        as: 'payroll_run',
+
+        where: filter.payroll_run
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.payroll_run
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  country: {
+                    [Op.or]: filter.payroll_run
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.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.type) {
+        where = {
+          ...where,
+          type: filter.type,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.deductions.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('deductions', 'type', query),
+        ],
+      };
+    }
+
+    const records = await db.deductions.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/devices.js
+++ b/backend/src/db/api/devices.js
@ -0,0 +1,418 @@
+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 DevicesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const devices = await db.devices.create(
+      {
+        id: data.id || undefined,
+
+        type: data.type || null,
+        platform: data.platform || null,
+        serial: data.serial || null,
+        asset_tag: data.asset_tag || null,
+        status: data.status || null,
+        encryption: data.encryption || false,
+
+        os_version: data.os_version || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await devices.setOwner(data.owner || null, {
+      transaction,
+    });
+
+    await devices.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return devices;
+  }
+
+  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 devicesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      type: item.type || null,
+      platform: item.platform || null,
+      serial: item.serial || null,
+      asset_tag: item.asset_tag || null,
+      status: item.status || null,
+      encryption: item.encryption || false,
+
+      os_version: item.os_version || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const devices = await db.devices.bulkCreate(devicesData, { transaction });
+
+    // For each item created, replace relation files
+
+    return devices;
+  }
+
+  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 devices = await db.devices.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.type !== undefined) updatePayload.type = data.type;
+
+    if (data.platform !== undefined) updatePayload.platform = data.platform;
+
+    if (data.serial !== undefined) updatePayload.serial = data.serial;
+
+    if (data.asset_tag !== undefined) updatePayload.asset_tag = data.asset_tag;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.encryption !== undefined)
+      updatePayload.encryption = data.encryption;
+
+    if (data.os_version !== undefined)
+      updatePayload.os_version = data.os_version;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await devices.update(updatePayload, { transaction });
+
+    if (data.owner !== undefined) {
+      await devices.setOwner(
+        data.owner,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await devices.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return devices;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const devices = await db.devices.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of devices) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of devices) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return devices;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const devices = await db.devices.findByPk(id, options);
+
+    await devices.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await devices.destroy({
+      transaction,
+    });
+
+    return devices;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const devices = await db.devices.findOne({ where }, { transaction });
+
+    if (!devices) {
+      return devices;
+    }
+
+    const output = devices.get({ plain: true });
+
+    output.inventory_events_device = await devices.getInventory_events_device({
+      transaction,
+    });
+
+    output.owner = await devices.getOwner({
+      transaction,
+    });
+
+    output.organizations = await devices.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'owner',
+
+        where: filter.owner
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.owner
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.owner
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.serial) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('devices', 'serial', filter.serial),
+        };
+      }
+
+      if (filter.asset_tag) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('devices', 'asset_tag', filter.asset_tag),
+        };
+      }
+
+      if (filter.os_version) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('devices', 'os_version', filter.os_version),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.type) {
+        where = {
+          ...where,
+          type: filter.type,
+        };
+      }
+
+      if (filter.platform) {
+        where = {
+          ...where,
+          platform: filter.platform,
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.encryption) {
+        where = {
+          ...where,
+          encryption: filter.encryption,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.devices.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('devices', 'serial', query),
+        ],
+      };
+    }
+
+    const records = await db.devices.findAll({
+      attributes: ['id', 'serial'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['serial', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.serial,
+    }));
+  }
+};
--- a/backend/src/db/api/documents.js
+++ b/backend/src/db/api/documents.js
@ -0,0 +1,437 @@
+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 DocumentsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const documents = await db.documents.create(
+      {
+        id: data.id || undefined,
+
+        doc_type: data.doc_type || null,
+        country: data.country || null,
+        status: data.status || null,
+        signed_at: data.signed_at || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await documents.setOwner(data.owner || null, {
+      transaction,
+    });
+
+    await documents.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.documents.getTableName(),
+        belongsToColumn: 'file_ref',
+        belongsToId: documents.id,
+      },
+      data.file_ref,
+      options,
+    );
+
+    return documents;
+  }
+
+  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 documentsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      doc_type: item.doc_type || null,
+      country: item.country || null,
+      status: item.status || null,
+      signed_at: item.signed_at || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const documents = await db.documents.bulkCreate(documentsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    for (let i = 0; i < documents.length; i++) {
+      await FileDBApi.replaceRelationFiles(
+        {
+          belongsTo: db.documents.getTableName(),
+          belongsToColumn: 'file_ref',
+          belongsToId: documents[i].id,
+        },
+        data[i].file_ref,
+        options,
+      );
+    }
+
+    return documents;
+  }
+
+  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 documents = await db.documents.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.doc_type !== undefined) updatePayload.doc_type = data.doc_type;
+
+    if (data.country !== undefined) updatePayload.country = data.country;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.signed_at !== undefined) updatePayload.signed_at = data.signed_at;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await documents.update(updatePayload, { transaction });
+
+    if (data.owner !== undefined) {
+      await documents.setOwner(
+        data.owner,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await documents.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.documents.getTableName(),
+        belongsToColumn: 'file_ref',
+        belongsToId: documents.id,
+      },
+      data.file_ref,
+      options,
+    );
+
+    return documents;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const documents = await db.documents.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of documents) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of documents) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return documents;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const documents = await db.documents.findByPk(id, options);
+
+    await documents.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await documents.destroy({
+      transaction,
+    });
+
+    return documents;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const documents = await db.documents.findOne({ where }, { transaction });
+
+    if (!documents) {
+      return documents;
+    }
+
+    const output = documents.get({ plain: true });
+
+    output.owner = await documents.getOwner({
+      transaction,
+    });
+
+    output.file_ref = await documents.getFile_ref({
+      transaction,
+    });
+
+    output.organizations = await documents.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'owner',
+
+        where: filter.owner
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.owner
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.owner
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+
+      {
+        model: db.file,
+        as: 'file_ref',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.country) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('documents', 'country', filter.country),
+        };
+      }
+
+      if (filter.signed_atRange) {
+        const [start, end] = filter.signed_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            signed_at: {
+              ...where.signed_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            signed_at: {
+              ...where.signed_at,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.doc_type) {
+        where = {
+          ...where,
+          doc_type: filter.doc_type,
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.documents.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('documents', 'doc_type', query),
+        ],
+      };
+    }
+
+    const records = await db.documents.findAll({
+      attributes: ['id', 'doc_type'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['doc_type', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.doc_type,
+    }));
+  }
+};
--- a/backend/src/db/api/earnings.js
+++ b/backend/src/db/api/earnings.js
@ -0,0 +1,496 @@
+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 EarningsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const earnings = await db.earnings.create(
+      {
+        id: data.id || undefined,
+
+        component: data.component || null,
+        units: data.units || null,
+        rate: data.rate || null,
+        amount: data.amount || null,
+        currency: data.currency || null,
+        taxable: data.taxable || false,
+
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await earnings.setPayroll_run(data.payroll_run || null, {
+      transaction,
+    });
+
+    await earnings.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await earnings.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return earnings;
+  }
+
+  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 earningsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      component: item.component || null,
+      units: item.units || null,
+      rate: item.rate || null,
+      amount: item.amount || null,
+      currency: item.currency || null,
+      taxable: item.taxable || false,
+
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const earnings = await db.earnings.bulkCreate(earningsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return earnings;
+  }
+
+  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 earnings = await db.earnings.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.component !== undefined) updatePayload.component = data.component;
+
+    if (data.units !== undefined) updatePayload.units = data.units;
+
+    if (data.rate !== undefined) updatePayload.rate = data.rate;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    if (data.currency !== undefined) updatePayload.currency = data.currency;
+
+    if (data.taxable !== undefined) updatePayload.taxable = data.taxable;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await earnings.update(updatePayload, { transaction });
+
+    if (data.payroll_run !== undefined) {
+      await earnings.setPayroll_run(
+        data.payroll_run,
+
+        { transaction },
+      );
+    }
+
+    if (data.employee !== undefined) {
+      await earnings.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await earnings.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return earnings;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const earnings = await db.earnings.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of earnings) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of earnings) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return earnings;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const earnings = await db.earnings.findByPk(id, options);
+
+    await earnings.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await earnings.destroy({
+      transaction,
+    });
+
+    return earnings;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const earnings = await db.earnings.findOne({ where }, { transaction });
+
+    if (!earnings) {
+      return earnings;
+    }
+
+    const output = earnings.get({ plain: true });
+
+    output.payroll_run = await earnings.getPayroll_run({
+      transaction,
+    });
+
+    output.employee = await earnings.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await earnings.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.payroll_runs,
+        as: 'payroll_run',
+
+        where: filter.payroll_run
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.payroll_run
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  country: {
+                    [Op.or]: filter.payroll_run
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.component) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('earnings', 'component', filter.component),
+        };
+      }
+
+      if (filter.currency) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('earnings', 'currency', filter.currency),
+        };
+      }
+
+      if (filter.unitsRange) {
+        const [start, end] = filter.unitsRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            units: {
+              ...where.units,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            units: {
+              ...where.units,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.rateRange) {
+        const [start, end] = filter.rateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            rate: {
+              ...where.rate,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            rate: {
+              ...where.rate,
+              [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.taxable) {
+        where = {
+          ...where,
+          taxable: filter.taxable,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.earnings.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('earnings', 'component', query),
+        ],
+      };
+    }
+
+    const records = await db.earnings.findAll({
+      attributes: ['id', 'component'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['component', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.component,
+    }));
+  }
+};
--- a/backend/src/db/api/employees.js
+++ b/backend/src/db/api/employees.js
@ -0,0 +1,644 @@
+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 EmployeesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const employees = await db.employees.create(
+      {
+        id: data.id || undefined,
+
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await employees.setUser(data.user || null, {
+      transaction,
+    });
+
+    await employees.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    await employees.setEmployments(data.employments || [], {
+      transaction,
+    });
+
+    await employees.setPositions(data.positions || [], {
+      transaction,
+    });
+
+    await employees.setCompensations(data.compensations || [], {
+      transaction,
+    });
+
+    await employees.setDocuments(data.documents || [], {
+      transaction,
+    });
+
+    return employees;
+  }
+
+  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 employeesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const employees = await db.employees.bulkCreate(employeesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return employees;
+  }
+
+  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 employees = await db.employees.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    updatePayload.updatedById = currentUser.id;
+
+    await employees.update(updatePayload, { transaction });
+
+    if (data.user !== undefined) {
+      await employees.setUser(
+        data.user,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await employees.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    if (data.employments !== undefined) {
+      await employees.setEmployments(data.employments, { transaction });
+    }
+
+    if (data.positions !== undefined) {
+      await employees.setPositions(data.positions, { transaction });
+    }
+
+    if (data.compensations !== undefined) {
+      await employees.setCompensations(data.compensations, { transaction });
+    }
+
+    if (data.documents !== undefined) {
+      await employees.setDocuments(data.documents, { transaction });
+    }
+
+    return employees;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const employees = await db.employees.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of employees) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of employees) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return employees;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const employees = await db.employees.findByPk(id, options);
+
+    await employees.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await employees.destroy({
+      transaction,
+    });
+
+    return employees;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const employees = await db.employees.findOne({ where }, { transaction });
+
+    if (!employees) {
+      return employees;
+    }
+
+    const output = employees.get({ plain: true });
+
+    output.app_accounts_employee = await employees.getApp_accounts_employee({
+      transaction,
+    });
+
+    output.approvals_approver = await employees.getApprovals_approver({
+      transaction,
+    });
+
+    output.cards_employee = await employees.getCards_employee({
+      transaction,
+    });
+
+    output.compensations_employee = await employees.getCompensations_employee({
+      transaction,
+    });
+
+    output.deductions_employee = await employees.getDeductions_employee({
+      transaction,
+    });
+
+    output.devices_owner = await employees.getDevices_owner({
+      transaction,
+    });
+
+    output.documents_owner = await employees.getDocuments_owner({
+      transaction,
+    });
+
+    output.earnings_employee = await employees.getEarnings_employee({
+      transaction,
+    });
+
+    output.employments_employee = await employees.getEmployments_employee({
+      transaction,
+    });
+
+    output.enrollment_learnings_employee =
+      await employees.getEnrollment_learnings_employee({
+        transaction,
+      });
+
+    output.enrollment_learnings_assigned_by =
+      await employees.getEnrollment_learnings_assigned_by({
+        transaction,
+      });
+
+    output.enrollments_employee = await employees.getEnrollments_employee({
+      transaction,
+    });
+
+    output.expense_reports_employee =
+      await employees.getExpense_reports_employee({
+        transaction,
+      });
+
+    output.goals_employee = await employees.getGoals_employee({
+      transaction,
+    });
+
+    output.identity_accounts_employee =
+      await employees.getIdentity_accounts_employee({
+        transaction,
+      });
+
+    output.interviews_interviewer = await employees.getInterviews_interviewer({
+      transaction,
+    });
+
+    output.job_requisitions_recruiter =
+      await employees.getJob_requisitions_recruiter({
+        transaction,
+      });
+
+    output.leave_requests_employee = await employees.getLeave_requests_employee(
+      {
+        transaction,
+      },
+    );
+
+    output.positions_manager = await employees.getPositions_manager({
+      transaction,
+    });
+
+    output.reviews_employee = await employees.getReviews_employee({
+      transaction,
+    });
+
+    output.reviews_reviewer = await employees.getReviews_reviewer({
+      transaction,
+    });
+
+    output.schedule_shifts_employee =
+      await employees.getSchedule_shifts_employee({
+        transaction,
+      });
+
+    output.taxes_employee = await employees.getTaxes_employee({
+      transaction,
+    });
+
+    output.timecards_employee = await employees.getTimecards_employee({
+      transaction,
+    });
+
+    output.travel_bookings_employee =
+      await employees.getTravel_bookings_employee({
+        transaction,
+      });
+
+    output.user = await employees.getUser({
+      transaction,
+    });
+
+    output.employments = await employees.getEmployments({
+      transaction,
+    });
+
+    output.positions = await employees.getPositions({
+      transaction,
+    });
+
+    output.compensations = await employees.getCompensations({
+      transaction,
+    });
+
+    output.documents = await employees.getDocuments({
+      transaction,
+    });
+
+    output.organizations = await employees.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.users,
+        as: 'user',
+
+        where: filter.user
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.user
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  firstName: {
+                    [Op.or]: filter.user
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+
+      {
+        model: db.employments,
+        as: 'employments',
+        required: false,
+      },
+
+      {
+        model: db.positions,
+        as: 'positions',
+        required: false,
+      },
+
+      {
+        model: db.compensations,
+        as: 'compensations',
+        required: false,
+      },
+
+      {
+        model: db.documents,
+        as: 'documents',
+        required: false,
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.employments) {
+        const searchTerms = filter.employments.split('|');
+
+        include = [
+          {
+            model: db.employments,
+            as: 'employments_filter',
+            required: searchTerms.length > 0,
+            where:
+              searchTerms.length > 0
+                ? {
+                    [Op.or]: [
+                      {
+                        id: {
+                          [Op.in]: searchTerms.map((term) => Utils.uuid(term)),
+                        },
+                      },
+                      {
+                        employment_type: {
+                          [Op.or]: searchTerms.map((term) => ({
+                            [Op.iLike]: `%${term}%`,
+                          })),
+                        },
+                      },
+                    ],
+                  }
+                : undefined,
+          },
+          ...include,
+        ];
+      }
+
+      if (filter.positions) {
+        const searchTerms = filter.positions.split('|');
+
+        include = [
+          {
+            model: db.positions,
+            as: 'positions_filter',
+            required: searchTerms.length > 0,
+            where:
+              searchTerms.length > 0
+                ? {
+                    [Op.or]: [
+                      {
+                        id: {
+                          [Op.in]: searchTerms.map((term) => Utils.uuid(term)),
+                        },
+                      },
+                      {
+                        title: {
+                          [Op.or]: searchTerms.map((term) => ({
+                            [Op.iLike]: `%${term}%`,
+                          })),
+                        },
+                      },
+                    ],
+                  }
+                : undefined,
+          },
+          ...include,
+        ];
+      }
+
+      if (filter.compensations) {
+        const searchTerms = filter.compensations.split('|');
+
+        include = [
+          {
+            model: db.compensations,
+            as: 'compensations_filter',
+            required: searchTerms.length > 0,
+            where:
+              searchTerms.length > 0
+                ? {
+                    [Op.or]: [
+                      {
+                        id: {
+                          [Op.in]: searchTerms.map((term) => Utils.uuid(term)),
+                        },
+                      },
+                      {
+                        base_pay: {
+                          [Op.or]: searchTerms.map((term) => ({
+                            [Op.iLike]: `%${term}%`,
+                          })),
+                        },
+                      },
+                    ],
+                  }
+                : undefined,
+          },
+          ...include,
+        ];
+      }
+
+      if (filter.documents) {
+        const searchTerms = filter.documents.split('|');
+
+        include = [
+          {
+            model: db.documents,
+            as: 'documents_filter',
+            required: searchTerms.length > 0,
+            where:
+              searchTerms.length > 0
+                ? {
+                    [Op.or]: [
+                      {
+                        id: {
+                          [Op.in]: searchTerms.map((term) => Utils.uuid(term)),
+                        },
+                      },
+                      {
+                        doc_type: {
+                          [Op.or]: searchTerms.map((term) => ({
+                            [Op.iLike]: `%${term}%`,
+                          })),
+                        },
+                      },
+                    ],
+                  }
+                : undefined,
+          },
+          ...include,
+        ];
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.employees.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('employees', 'user', query),
+        ],
+      };
+    }
+
+    const records = await db.employees.findAll({
+      attributes: ['id', 'user'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['user', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.user,
+    }));
+  }
+};
--- a/backend/src/db/api/employments.js
+++ b/backend/src/db/api/employments.js
@ -0,0 +1,466 @@
+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 EmploymentsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const employments = await db.employments.create(
+      {
+        id: data.id || undefined,
+
+        employment_type: data.employment_type || null,
+        start_date: data.start_date || null,
+        end_date: data.end_date || null,
+        fte: data.fte || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await employments.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await employments.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return employments;
+  }
+
+  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 employmentsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      employment_type: item.employment_type || null,
+      start_date: item.start_date || null,
+      end_date: item.end_date || null,
+      fte: item.fte || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const employments = await db.employments.bulkCreate(employmentsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return employments;
+  }
+
+  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 employments = await db.employments.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.employment_type !== undefined)
+      updatePayload.employment_type = data.employment_type;
+
+    if (data.start_date !== undefined)
+      updatePayload.start_date = data.start_date;
+
+    if (data.end_date !== undefined) updatePayload.end_date = data.end_date;
+
+    if (data.fte !== undefined) updatePayload.fte = data.fte;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await employments.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await employments.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await employments.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return employments;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const employments = await db.employments.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of employments) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of employments) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return employments;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const employments = await db.employments.findByPk(id, options);
+
+    await employments.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await employments.destroy({
+      transaction,
+    });
+
+    return employments;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const employments = await db.employments.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!employments) {
+      return employments;
+    }
+
+    const output = employments.get({ plain: true });
+
+    output.employee = await employments.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await employments.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              start_date: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              end_date: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.start_dateRange) {
+        const [start, end] = filter.start_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            start_date: {
+              ...where.start_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            start_date: {
+              ...where.start_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.end_dateRange) {
+        const [start, end] = filter.end_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            end_date: {
+              ...where.end_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            end_date: {
+              ...where.end_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.fteRange) {
+        const [start, end] = filter.fteRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            fte: {
+              ...where.fte,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            fte: {
+              ...where.fte,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.employment_type) {
+        where = {
+          ...where,
+          employment_type: filter.employment_type,
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.employments.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('employments', 'employment_type', query),
+        ],
+      };
+    }
+
+    const records = await db.employments.findAll({
+      attributes: ['id', 'employment_type'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['employment_type', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.employment_type,
+    }));
+  }
+};
--- a/backend/src/db/api/enrollment_learnings.js
+++ b/backend/src/db/api/enrollment_learnings.js
@ -0,0 +1,471 @@
+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 Enrollment_learningsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const enrollment_learnings = await db.enrollment_learnings.create(
+      {
+        id: data.id || undefined,
+
+        due_date: data.due_date || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await enrollment_learnings.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await enrollment_learnings.setCourse(data.course || null, {
+      transaction,
+    });
+
+    await enrollment_learnings.setAssigned_by(data.assigned_by || null, {
+      transaction,
+    });
+
+    await enrollment_learnings.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return enrollment_learnings;
+  }
+
+  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 enrollment_learningsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      due_date: item.due_date || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const enrollment_learnings = await db.enrollment_learnings.bulkCreate(
+      enrollment_learningsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return enrollment_learnings;
+  }
+
+  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 enrollment_learnings = await db.enrollment_learnings.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.due_date !== undefined) updatePayload.due_date = data.due_date;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await enrollment_learnings.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await enrollment_learnings.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.course !== undefined) {
+      await enrollment_learnings.setCourse(
+        data.course,
+
+        { transaction },
+      );
+    }
+
+    if (data.assigned_by !== undefined) {
+      await enrollment_learnings.setAssigned_by(
+        data.assigned_by,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await enrollment_learnings.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return enrollment_learnings;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const enrollment_learnings = await db.enrollment_learnings.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of enrollment_learnings) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of enrollment_learnings) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return enrollment_learnings;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const enrollment_learnings = await db.enrollment_learnings.findByPk(
+      id,
+      options,
+    );
+
+    await enrollment_learnings.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await enrollment_learnings.destroy({
+      transaction,
+    });
+
+    return enrollment_learnings;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const enrollment_learnings = await db.enrollment_learnings.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!enrollment_learnings) {
+      return enrollment_learnings;
+    }
+
+    const output = enrollment_learnings.get({ plain: true });
+
+    output.employee = await enrollment_learnings.getEmployee({
+      transaction,
+    });
+
+    output.course = await enrollment_learnings.getCourse({
+      transaction,
+    });
+
+    output.assigned_by = await enrollment_learnings.getAssigned_by({
+      transaction,
+    });
+
+    output.organizations = await enrollment_learnings.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.learning_courses,
+        as: 'course',
+
+        where: filter.course
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.course
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  title: {
+                    [Op.or]: filter.course
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.employees,
+        as: 'assigned_by',
+
+        where: filter.assigned_by
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.assigned_by
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.assigned_by
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.due_dateRange) {
+        const [start, end] = filter.due_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            due_date: {
+              ...where.due_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            due_date: {
+              ...where.due_date,
+              [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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.enrollment_learnings.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('enrollment_learnings', 'course', query),
+        ],
+      };
+    }
+
+    const records = await db.enrollment_learnings.findAll({
+      attributes: ['id', 'course'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['course', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.course,
+    }));
+  }
+};
--- a/backend/src/db/api/enrollments.js
+++ b/backend/src/db/api/enrollments.js
@ -0,0 +1,480 @@
+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 EnrollmentsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const enrollments = await db.enrollments.create(
+      {
+        id: data.id || undefined,
+
+        effective_date: data.effective_date || null,
+        premium_employee: data.premium_employee || null,
+        premium_employer: data.premium_employer || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await enrollments.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await enrollments.setPlan(data.plan || null, {
+      transaction,
+    });
+
+    await enrollments.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return enrollments;
+  }
+
+  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 enrollmentsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      effective_date: item.effective_date || null,
+      premium_employee: item.premium_employee || null,
+      premium_employer: item.premium_employer || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const enrollments = await db.enrollments.bulkCreate(enrollmentsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return enrollments;
+  }
+
+  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 enrollments = await db.enrollments.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.effective_date !== undefined)
+      updatePayload.effective_date = data.effective_date;
+
+    if (data.premium_employee !== undefined)
+      updatePayload.premium_employee = data.premium_employee;
+
+    if (data.premium_employer !== undefined)
+      updatePayload.premium_employer = data.premium_employer;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await enrollments.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await enrollments.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.plan !== undefined) {
+      await enrollments.setPlan(
+        data.plan,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await enrollments.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return enrollments;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const enrollments = await db.enrollments.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of enrollments) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of enrollments) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return enrollments;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const enrollments = await db.enrollments.findByPk(id, options);
+
+    await enrollments.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await enrollments.destroy({
+      transaction,
+    });
+
+    return enrollments;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const enrollments = await db.enrollments.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!enrollments) {
+      return enrollments;
+    }
+
+    const output = enrollments.get({ plain: true });
+
+    output.employee = await enrollments.getEmployee({
+      transaction,
+    });
+
+    output.plan = await enrollments.getPlan({
+      transaction,
+    });
+
+    output.organizations = await enrollments.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.benefit_plans,
+        as: 'plan',
+
+        where: filter.plan
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.plan
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  carrier: {
+                    [Op.or]: filter.plan
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.effective_dateRange) {
+        const [start, end] = filter.effective_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            effective_date: {
+              ...where.effective_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            effective_date: {
+              ...where.effective_date,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.premium_employeeRange) {
+        const [start, end] = filter.premium_employeeRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            premium_employee: {
+              ...where.premium_employee,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            premium_employee: {
+              ...where.premium_employee,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.premium_employerRange) {
+        const [start, end] = filter.premium_employerRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            premium_employer: {
+              ...where.premium_employer,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            premium_employer: {
+              ...where.premium_employer,
+              [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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.enrollments.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('enrollments', 'plan', query),
+        ],
+      };
+    }
+
+    const records = await db.enrollments.findAll({
+      attributes: ['id', 'plan'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['plan', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.plan,
+    }));
+  }
+};
--- a/backend/src/db/api/expense_lines.js
+++ b/backend/src/db/api/expense_lines.js
@ -0,0 +1,474 @@
+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 Expense_linesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const expense_lines = await db.expense_lines.create(
+      {
+        id: data.id || undefined,
+
+        date: data.date || null,
+        merchant: data.merchant || null,
+        amount: data.amount || null,
+        currency: data.currency || null,
+        category: data.category || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await expense_lines.setReport(data.report || null, {
+      transaction,
+    });
+
+    await expense_lines.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.expense_lines.getTableName(),
+        belongsToColumn: 'receipt_ref',
+        belongsToId: expense_lines.id,
+      },
+      data.receipt_ref,
+      options,
+    );
+
+    return expense_lines;
+  }
+
+  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 expense_linesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      date: item.date || null,
+      merchant: item.merchant || null,
+      amount: item.amount || null,
+      currency: item.currency || null,
+      category: item.category || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const expense_lines = await db.expense_lines.bulkCreate(expense_linesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    for (let i = 0; i < expense_lines.length; i++) {
+      await FileDBApi.replaceRelationFiles(
+        {
+          belongsTo: db.expense_lines.getTableName(),
+          belongsToColumn: 'receipt_ref',
+          belongsToId: expense_lines[i].id,
+        },
+        data[i].receipt_ref,
+        options,
+      );
+    }
+
+    return expense_lines;
+  }
+
+  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 expense_lines = await db.expense_lines.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.date !== undefined) updatePayload.date = data.date;
+
+    if (data.merchant !== undefined) updatePayload.merchant = data.merchant;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    if (data.currency !== undefined) updatePayload.currency = data.currency;
+
+    if (data.category !== undefined) updatePayload.category = data.category;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await expense_lines.update(updatePayload, { transaction });
+
+    if (data.report !== undefined) {
+      await expense_lines.setReport(
+        data.report,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await expense_lines.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.expense_lines.getTableName(),
+        belongsToColumn: 'receipt_ref',
+        belongsToId: expense_lines.id,
+      },
+      data.receipt_ref,
+      options,
+    );
+
+    return expense_lines;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const expense_lines = await db.expense_lines.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of expense_lines) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of expense_lines) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return expense_lines;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const expense_lines = await db.expense_lines.findByPk(id, options);
+
+    await expense_lines.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await expense_lines.destroy({
+      transaction,
+    });
+
+    return expense_lines;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const expense_lines = await db.expense_lines.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!expense_lines) {
+      return expense_lines;
+    }
+
+    const output = expense_lines.get({ plain: true });
+
+    output.report = await expense_lines.getReport({
+      transaction,
+    });
+
+    output.receipt_ref = await expense_lines.getReceipt_ref({
+      transaction,
+    });
+
+    output.organizations = await expense_lines.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.expense_reports,
+        as: 'report',
+
+        where: filter.report
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.report
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  status: {
+                    [Op.or]: filter.report
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+
+      {
+        model: db.file,
+        as: 'receipt_ref',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.merchant) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('expense_lines', 'merchant', filter.merchant),
+        };
+      }
+
+      if (filter.currency) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('expense_lines', 'currency', filter.currency),
+        };
+      }
+
+      if (filter.category) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('expense_lines', 'category', filter.category),
+        };
+      }
+
+      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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.expense_lines.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('expense_lines', 'merchant', query),
+        ],
+      };
+    }
+
+    const records = await db.expense_lines.findAll({
+      attributes: ['id', 'merchant'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['merchant', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.merchant,
+    }));
+  }
+};
--- a/backend/src/db/api/expense_reports.js
+++ b/backend/src/db/api/expense_reports.js
@ -0,0 +1,407 @@
+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 Expense_reportsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const expense_reports = await db.expense_reports.create(
+      {
+        id: data.id || undefined,
+
+        submitted_at: data.submitted_at || null,
+        status: data.status || null,
+        policy_result: data.policy_result || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await expense_reports.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await expense_reports.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return expense_reports;
+  }
+
+  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 expense_reportsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      submitted_at: item.submitted_at || null,
+      status: item.status || null,
+      policy_result: item.policy_result || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const expense_reports = await db.expense_reports.bulkCreate(
+      expense_reportsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return expense_reports;
+  }
+
+  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 expense_reports = await db.expense_reports.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.submitted_at !== undefined)
+      updatePayload.submitted_at = data.submitted_at;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    if (data.policy_result !== undefined)
+      updatePayload.policy_result = data.policy_result;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await expense_reports.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await expense_reports.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await expense_reports.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return expense_reports;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const expense_reports = await db.expense_reports.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of expense_reports) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of expense_reports) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return expense_reports;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const expense_reports = await db.expense_reports.findByPk(id, options);
+
+    await expense_reports.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await expense_reports.destroy({
+      transaction,
+    });
+
+    return expense_reports;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const expense_reports = await db.expense_reports.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!expense_reports) {
+      return expense_reports;
+    }
+
+    const output = expense_reports.get({ plain: true });
+
+    output.expense_lines_report = await expense_reports.getExpense_lines_report(
+      {
+        transaction,
+      },
+    );
+
+    output.employee = await expense_reports.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await expense_reports.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.policy_result) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'expense_reports',
+            'policy_result',
+            filter.policy_result,
+          ),
+        };
+      }
+
+      if (filter.submitted_atRange) {
+        const [start, end] = filter.submitted_atRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            submitted_at: {
+              ...where.submitted_at,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            submitted_at: {
+              ...where.submitted_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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.expense_reports.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('expense_reports', 'status', query),
+        ],
+      };
+    }
+
+    const records = await db.expense_reports.findAll({
+      attributes: ['id', 'status'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['status', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.status,
+    }));
+  }
+};
--- 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/goals.js
+++ b/backend/src/db/api/goals.js
@ -0,0 +1,496 @@
+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 GoalsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const goals = await db.goals.create(
+      {
+        id: data.id || undefined,
+
+        type: data.type || null,
+        title: data.title || null,
+        metric: data.metric || null,
+        target: data.target || null,
+        start: data.start || null,
+        due: data.due || null,
+        progress: data.progress || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await goals.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await goals.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return goals;
+  }
+
+  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 goalsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      type: item.type || null,
+      title: item.title || null,
+      metric: item.metric || null,
+      target: item.target || null,
+      start: item.start || null,
+      due: item.due || null,
+      progress: item.progress || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const goals = await db.goals.bulkCreate(goalsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return goals;
+  }
+
+  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 goals = await db.goals.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.type !== undefined) updatePayload.type = data.type;
+
+    if (data.title !== undefined) updatePayload.title = data.title;
+
+    if (data.metric !== undefined) updatePayload.metric = data.metric;
+
+    if (data.target !== undefined) updatePayload.target = data.target;
+
+    if (data.start !== undefined) updatePayload.start = data.start;
+
+    if (data.due !== undefined) updatePayload.due = data.due;
+
+    if (data.progress !== undefined) updatePayload.progress = data.progress;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await goals.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await goals.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await goals.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return goals;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const goals = await db.goals.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of goals) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of goals) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return goals;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const goals = await db.goals.findByPk(id, options);
+
+    await goals.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await goals.destroy({
+      transaction,
+    });
+
+    return goals;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const goals = await db.goals.findOne({ where }, { transaction });
+
+    if (!goals) {
+      return goals;
+    }
+
+    const output = goals.get({ plain: true });
+
+    output.employee = await goals.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await goals.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.title) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('goals', 'title', filter.title),
+        };
+      }
+
+      if (filter.metric) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('goals', 'metric', filter.metric),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              start: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              due: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.targetRange) {
+        const [start, end] = filter.targetRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            target: {
+              ...where.target,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            target: {
+              ...where.target,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.startRange) {
+        const [start, end] = filter.startRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.dueRange) {
+        const [start, end] = filter.dueRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            due: {
+              ...where.due,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            due: {
+              ...where.due,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.progressRange) {
+        const [start, end] = filter.progressRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            progress: {
+              ...where.progress,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            progress: {
+              ...where.progress,
+              [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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.goals.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('goals', 'title', query),
+        ],
+      };
+    }
+
+    const records = await db.goals.findAll({
+      attributes: ['id', 'title'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['title', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.title,
+    }));
+  }
+};
--- a/backend/src/db/api/identity_accounts.js
+++ b/backend/src/db/api/identity_accounts.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 Identity_accountsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const identity_accounts = await db.identity_accounts.create(
+      {
+        id: data.id || undefined,
+
+        idp: data.idp || null,
+        username: data.username || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await identity_accounts.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await identity_accounts.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return identity_accounts;
+  }
+
+  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 identity_accountsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      idp: item.idp || null,
+      username: item.username || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const identity_accounts = await db.identity_accounts.bulkCreate(
+      identity_accountsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return identity_accounts;
+  }
+
+  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 identity_accounts = await db.identity_accounts.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.idp !== undefined) updatePayload.idp = data.idp;
+
+    if (data.username !== undefined) updatePayload.username = data.username;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await identity_accounts.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await identity_accounts.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await identity_accounts.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return identity_accounts;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const identity_accounts = await db.identity_accounts.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of identity_accounts) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of identity_accounts) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return identity_accounts;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const identity_accounts = await db.identity_accounts.findByPk(id, options);
+
+    await identity_accounts.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await identity_accounts.destroy({
+      transaction,
+    });
+
+    return identity_accounts;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const identity_accounts = await db.identity_accounts.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!identity_accounts) {
+      return identity_accounts;
+    }
+
+    const output = identity_accounts.get({ plain: true });
+
+    output.employee = await identity_accounts.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await identity_accounts.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.idp) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('identity_accounts', 'idp', filter.idp),
+        };
+      }
+
+      if (filter.username) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'identity_accounts',
+            'username',
+            filter.username,
+          ),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.identity_accounts.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('identity_accounts', 'username', query),
+        ],
+      };
+    }
+
+    const records = await db.identity_accounts.findAll({
+      attributes: ['id', 'username'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['username', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.username,
+    }));
+  }
+};
--- a/backend/src/db/api/interviews.js
+++ b/backend/src/db/api/interviews.js
@ -0,0 +1,474 @@
+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 InterviewsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const interviews = await db.interviews.create(
+      {
+        id: data.id || undefined,
+
+        type: data.type || null,
+        scheduled_at: data.scheduled_at || null,
+        rating: data.rating || null,
+        notes: data.notes || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await interviews.setApplication(data.application || null, {
+      transaction,
+    });
+
+    await interviews.setInterviewer(data.interviewer || null, {
+      transaction,
+    });
+
+    await interviews.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return interviews;
+  }
+
+  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 interviewsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      type: item.type || null,
+      scheduled_at: item.scheduled_at || null,
+      rating: item.rating || 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 interviews = await db.interviews.bulkCreate(interviewsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return interviews;
+  }
+
+  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 interviews = await db.interviews.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.rating !== undefined) updatePayload.rating = data.rating;
+
+    if (data.notes !== undefined) updatePayload.notes = data.notes;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await interviews.update(updatePayload, { transaction });
+
+    if (data.application !== undefined) {
+      await interviews.setApplication(
+        data.application,
+
+        { transaction },
+      );
+    }
+
+    if (data.interviewer !== undefined) {
+      await interviews.setInterviewer(
+        data.interviewer,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await interviews.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return interviews;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const interviews = await db.interviews.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of interviews) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of interviews) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return interviews;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const interviews = await db.interviews.findByPk(id, options);
+
+    await interviews.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await interviews.destroy({
+      transaction,
+    });
+
+    return interviews;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const interviews = await db.interviews.findOne({ where }, { transaction });
+
+    if (!interviews) {
+      return interviews;
+    }
+
+    const output = interviews.get({ plain: true });
+
+    output.application = await interviews.getApplication({
+      transaction,
+    });
+
+    output.interviewer = await interviews.getInterviewer({
+      transaction,
+    });
+
+    output.organizations = await interviews.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.applications,
+        as: 'application',
+
+        where: filter.application
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.application
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  status: {
+                    [Op.or]: filter.application
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.employees,
+        as: 'interviewer',
+
+        where: filter.interviewer
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.interviewer
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.interviewer
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.notes) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('interviews', 'notes', filter.notes),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              scheduled_at: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              scheduled_at: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      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.ratingRange) {
+        const [start, end] = filter.ratingRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            rating: {
+              ...where.rating,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            rating: {
+              ...where.rating,
+              [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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.interviews.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('interviews', 'type', query),
+        ],
+      };
+    }
+
+    const records = await db.interviews.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/inventory_events.js
+++ b/backend/src/db/api/inventory_events.js
@ -0,0 +1,400 @@
+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 Inventory_eventsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const inventory_events = await db.inventory_events.create(
+      {
+        id: data.id || undefined,
+
+        event_type: data.event_type || null,
+        timestamp: data.timestamp || null,
+        metadata: data.metadata || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await inventory_events.setDevice(data.device || null, {
+      transaction,
+    });
+
+    await inventory_events.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return inventory_events;
+  }
+
+  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 inventory_eventsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      event_type: item.event_type || null,
+      timestamp: item.timestamp || null,
+      metadata: item.metadata || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const inventory_events = await db.inventory_events.bulkCreate(
+      inventory_eventsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return inventory_events;
+  }
+
+  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 inventory_events = await db.inventory_events.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.event_type !== undefined)
+      updatePayload.event_type = data.event_type;
+
+    if (data.timestamp !== undefined) updatePayload.timestamp = data.timestamp;
+
+    if (data.metadata !== undefined) updatePayload.metadata = data.metadata;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await inventory_events.update(updatePayload, { transaction });
+
+    if (data.device !== undefined) {
+      await inventory_events.setDevice(
+        data.device,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await inventory_events.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return inventory_events;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const inventory_events = await db.inventory_events.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of inventory_events) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of inventory_events) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return inventory_events;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const inventory_events = await db.inventory_events.findByPk(id, options);
+
+    await inventory_events.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await inventory_events.destroy({
+      transaction,
+    });
+
+    return inventory_events;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const inventory_events = await db.inventory_events.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!inventory_events) {
+      return inventory_events;
+    }
+
+    const output = inventory_events.get({ plain: true });
+
+    output.device = await inventory_events.getDevice({
+      transaction,
+    });
+
+    output.organizations = await inventory_events.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.devices,
+        as: 'device',
+
+        where: filter.device
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.device
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  serial: {
+                    [Op.or]: filter.device
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.metadata) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'inventory_events',
+            'metadata',
+            filter.metadata,
+          ),
+        };
+      }
+
+      if (filter.timestampRange) {
+        const [start, end] = filter.timestampRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            timestamp: {
+              ...where.timestamp,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            timestamp: {
+              ...where.timestamp,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.event_type) {
+        where = {
+          ...where,
+          event_type: filter.event_type,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.inventory_events.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('inventory_events', 'event_type', query),
+        ],
+      };
+    }
+
+    const records = await db.inventory_events.findAll({
+      attributes: ['id', 'event_type'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['event_type', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.event_type,
+    }));
+  }
+};
--- a/backend/src/db/api/job_requisitions.js
+++ b/backend/src/db/api/job_requisitions.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 Job_requisitionsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const job_requisitions = await db.job_requisitions.create(
+      {
+        id: data.id || undefined,
+
+        title: data.title || null,
+        employment_type: data.employment_type || null,
+        openings: data.openings || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await job_requisitions.setRecruiter(data.recruiter || null, {
+      transaction,
+    });
+
+    await job_requisitions.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return job_requisitions;
+  }
+
+  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 job_requisitionsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      title: item.title || null,
+      employment_type: item.employment_type || null,
+      openings: item.openings || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const job_requisitions = await db.job_requisitions.bulkCreate(
+      job_requisitionsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return job_requisitions;
+  }
+
+  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 job_requisitions = await db.job_requisitions.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.title !== undefined) updatePayload.title = data.title;
+
+    if (data.employment_type !== undefined)
+      updatePayload.employment_type = data.employment_type;
+
+    if (data.openings !== undefined) updatePayload.openings = data.openings;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await job_requisitions.update(updatePayload, { transaction });
+
+    if (data.recruiter !== undefined) {
+      await job_requisitions.setRecruiter(
+        data.recruiter,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await job_requisitions.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return job_requisitions;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const job_requisitions = await db.job_requisitions.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of job_requisitions) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of job_requisitions) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return job_requisitions;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const job_requisitions = await db.job_requisitions.findByPk(id, options);
+
+    await job_requisitions.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await job_requisitions.destroy({
+      transaction,
+    });
+
+    return job_requisitions;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const job_requisitions = await db.job_requisitions.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!job_requisitions) {
+      return job_requisitions;
+    }
+
+    const output = job_requisitions.get({ plain: true });
+
+    output.applications_requisition =
+      await job_requisitions.getApplications_requisition({
+        transaction,
+      });
+
+    output.recruiter = await job_requisitions.getRecruiter({
+      transaction,
+    });
+
+    output.organizations = await job_requisitions.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'recruiter',
+
+        where: filter.recruiter
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.recruiter
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.recruiter
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.title) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('job_requisitions', 'title', filter.title),
+        };
+      }
+
+      if (filter.openingsRange) {
+        const [start, end] = filter.openingsRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            openings: {
+              ...where.openings,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            openings: {
+              ...where.openings,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.employment_type) {
+        where = {
+          ...where,
+          employment_type: filter.employment_type,
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.job_requisitions.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('job_requisitions', 'title', query),
+        ],
+      };
+    }
+
+    const records = await db.job_requisitions.findAll({
+      attributes: ['id', 'title'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['title', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.title,
+    }));
+  }
+};
--- a/backend/src/db/api/learning_courses.js
+++ b/backend/src/db/api/learning_courses.js
@ -0,0 +1,378 @@
+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 Learning_coursesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const learning_courses = await db.learning_courses.create(
+      {
+        id: data.id || undefined,
+
+        title: data.title || null,
+        provider: data.provider || null,
+        hours: data.hours || null,
+        compliance_tag: data.compliance_tag || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await learning_courses.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return learning_courses;
+  }
+
+  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 learning_coursesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      title: item.title || null,
+      provider: item.provider || null,
+      hours: item.hours || null,
+      compliance_tag: item.compliance_tag || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const learning_courses = await db.learning_courses.bulkCreate(
+      learning_coursesData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return learning_courses;
+  }
+
+  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 learning_courses = await db.learning_courses.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.title !== undefined) updatePayload.title = data.title;
+
+    if (data.provider !== undefined) updatePayload.provider = data.provider;
+
+    if (data.hours !== undefined) updatePayload.hours = data.hours;
+
+    if (data.compliance_tag !== undefined)
+      updatePayload.compliance_tag = data.compliance_tag;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await learning_courses.update(updatePayload, { transaction });
+
+    if (data.organizations !== undefined) {
+      await learning_courses.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return learning_courses;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const learning_courses = await db.learning_courses.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of learning_courses) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of learning_courses) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return learning_courses;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const learning_courses = await db.learning_courses.findByPk(id, options);
+
+    await learning_courses.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await learning_courses.destroy({
+      transaction,
+    });
+
+    return learning_courses;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const learning_courses = await db.learning_courses.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!learning_courses) {
+      return learning_courses;
+    }
+
+    const output = learning_courses.get({ plain: true });
+
+    output.enrollment_learnings_course =
+      await learning_courses.getEnrollment_learnings_course({
+        transaction,
+      });
+
+    output.organizations = await learning_courses.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.title) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('learning_courses', 'title', filter.title),
+        };
+      }
+
+      if (filter.provider) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'learning_courses',
+            'provider',
+            filter.provider,
+          ),
+        };
+      }
+
+      if (filter.compliance_tag) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'learning_courses',
+            'compliance_tag',
+            filter.compliance_tag,
+          ),
+        };
+      }
+
+      if (filter.hoursRange) {
+        const [start, end] = filter.hoursRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            hours: {
+              ...where.hours,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            hours: {
+              ...where.hours,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.learning_courses.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('learning_courses', 'title', query),
+        ],
+      };
+    }
+
+    const records = await db.learning_courses.findAll({
+      attributes: ['id', 'title'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['title', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.title,
+    }));
+  }
+};
--- a/backend/src/db/api/leave_requests.js
+++ b/backend/src/db/api/leave_requests.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 Leave_requestsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const leave_requests = await db.leave_requests.create(
+      {
+        id: data.id || undefined,
+
+        type: data.type || null,
+        start: data.start || null,
+        end: data.end || null,
+        hours: data.hours || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await leave_requests.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await leave_requests.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return leave_requests;
+  }
+
+  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 leave_requestsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      type: item.type || null,
+      start: item.start || null,
+      end: item.end || null,
+      hours: item.hours || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const leave_requests = await db.leave_requests.bulkCreate(
+      leave_requestsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return leave_requests;
+  }
+
+  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 leave_requests = await db.leave_requests.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.type !== undefined) updatePayload.type = data.type;
+
+    if (data.start !== undefined) updatePayload.start = data.start;
+
+    if (data.end !== undefined) updatePayload.end = data.end;
+
+    if (data.hours !== undefined) updatePayload.hours = data.hours;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await leave_requests.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await leave_requests.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await leave_requests.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return leave_requests;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const leave_requests = await db.leave_requests.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of leave_requests) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of leave_requests) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return leave_requests;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const leave_requests = await db.leave_requests.findByPk(id, options);
+
+    await leave_requests.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await leave_requests.destroy({
+      transaction,
+    });
+
+    return leave_requests;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const leave_requests = await db.leave_requests.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!leave_requests) {
+      return leave_requests;
+    }
+
+    const output = leave_requests.get({ plain: true });
+
+    output.employee = await leave_requests.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await leave_requests.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              start: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              end: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.startRange) {
+        const [start, end] = filter.startRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.endRange) {
+        const [start, end] = filter.endRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            end: {
+              ...where.end,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            end: {
+              ...where.end,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.hoursRange) {
+        const [start, end] = filter.hoursRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            hours: {
+              ...where.hours,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            hours: {
+              ...where.hours,
+              [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.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.leave_requests.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('leave_requests', 'type', query),
+        ],
+      };
+    }
+
+    const records = await db.leave_requests.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/offers.js
+++ b/backend/src/db/api/offers.js
@ -0,0 +1,385 @@
+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 OffersDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const offers = await db.offers.create(
+      {
+        id: data.id || undefined,
+
+        comp_package: data.comp_package || null,
+        target_start_date: data.target_start_date || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await offers.setApplication(data.application || null, {
+      transaction,
+    });
+
+    await offers.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return offers;
+  }
+
+  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 offersData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      comp_package: item.comp_package || null,
+      target_start_date: item.target_start_date || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const offers = await db.offers.bulkCreate(offersData, { transaction });
+
+    // For each item created, replace relation files
+
+    return offers;
+  }
+
+  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 offers = await db.offers.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.comp_package !== undefined)
+      updatePayload.comp_package = data.comp_package;
+
+    if (data.target_start_date !== undefined)
+      updatePayload.target_start_date = data.target_start_date;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await offers.update(updatePayload, { transaction });
+
+    if (data.application !== undefined) {
+      await offers.setApplication(
+        data.application,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await offers.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return offers;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const offers = await db.offers.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of offers) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of offers) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return offers;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const offers = await db.offers.findByPk(id, options);
+
+    await offers.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await offers.destroy({
+      transaction,
+    });
+
+    return offers;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const offers = await db.offers.findOne({ where }, { transaction });
+
+    if (!offers) {
+      return offers;
+    }
+
+    const output = offers.get({ plain: true });
+
+    output.application = await offers.getApplication({
+      transaction,
+    });
+
+    output.organizations = await offers.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.applications,
+        as: 'application',
+
+        where: filter.application
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.application
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  status: {
+                    [Op.or]: filter.application
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.comp_package) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('offers', 'comp_package', filter.comp_package),
+        };
+      }
+
+      if (filter.target_start_dateRange) {
+        const [start, end] = filter.target_start_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            target_start_date: {
+              ...where.target_start_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            target_start_date: {
+              ...where.target_start_date,
+              [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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.offers.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('offers', 'comp_package', query),
+        ],
+      };
+    }
+
+    const records = await db.offers.findAll({
+      attributes: ['id', 'comp_package'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['comp_package', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.comp_package,
+    }));
+  }
+};
--- a/backend/src/db/api/organizations.js
+++ b/backend/src/db/api/organizations.js
@ -0,0 +1,478 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class OrganizationsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const organizations = await db.organizations.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    return organizations;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const organizationsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const organizations = await db.organizations.bulkCreate(organizationsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return organizations;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+    const globalAccess = currentUser.app_role?.globalAccess;
+
+    const organizations = await db.organizations.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await organizations.update(updatePayload, { transaction });
+
+    return organizations;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const organizations = await db.organizations.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of organizations) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of organizations) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return organizations;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const organizations = await db.organizations.findByPk(id, options);
+
+    await organizations.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await organizations.destroy({
+      transaction,
+    });
+
+    return organizations;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const organizations = await db.organizations.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!organizations) {
+      return organizations;
+    }
+
+    const output = organizations.get({ plain: true });
+
+    output.users_organizations = await organizations.getUsers_organizations({
+      transaction,
+    });
+
+    output.app_accounts_organizations =
+      await organizations.getApp_accounts_organizations({
+        transaction,
+      });
+
+    output.applications_organizations =
+      await organizations.getApplications_organizations({
+        transaction,
+      });
+
+    output.approvals_organizations =
+      await organizations.getApprovals_organizations({
+        transaction,
+      });
+
+    output.audit_logs_organizations =
+      await organizations.getAudit_logs_organizations({
+        transaction,
+      });
+
+    output.benefit_plans_organizations =
+      await organizations.getBenefit_plans_organizations({
+        transaction,
+      });
+
+    output.bills_organizations = await organizations.getBills_organizations({
+      transaction,
+    });
+
+    output.candidates_organizations =
+      await organizations.getCandidates_organizations({
+        transaction,
+      });
+
+    output.cards_organizations = await organizations.getCards_organizations({
+      transaction,
+    });
+
+    output.compensations_organizations =
+      await organizations.getCompensations_organizations({
+        transaction,
+      });
+
+    output.deductions_organizations =
+      await organizations.getDeductions_organizations({
+        transaction,
+      });
+
+    output.devices_organizations = await organizations.getDevices_organizations(
+      {
+        transaction,
+      },
+    );
+
+    output.documents_organizations =
+      await organizations.getDocuments_organizations({
+        transaction,
+      });
+
+    output.earnings_organizations =
+      await organizations.getEarnings_organizations({
+        transaction,
+      });
+
+    output.employees_organizations =
+      await organizations.getEmployees_organizations({
+        transaction,
+      });
+
+    output.employments_organizations =
+      await organizations.getEmployments_organizations({
+        transaction,
+      });
+
+    output.enrollment_learnings_organizations =
+      await organizations.getEnrollment_learnings_organizations({
+        transaction,
+      });
+
+    output.enrollments_organizations =
+      await organizations.getEnrollments_organizations({
+        transaction,
+      });
+
+    output.expense_lines_organizations =
+      await organizations.getExpense_lines_organizations({
+        transaction,
+      });
+
+    output.expense_reports_organizations =
+      await organizations.getExpense_reports_organizations({
+        transaction,
+      });
+
+    output.goals_organizations = await organizations.getGoals_organizations({
+      transaction,
+    });
+
+    output.identity_accounts_organizations =
+      await organizations.getIdentity_accounts_organizations({
+        transaction,
+      });
+
+    output.interviews_organizations =
+      await organizations.getInterviews_organizations({
+        transaction,
+      });
+
+    output.inventory_events_organizations =
+      await organizations.getInventory_events_organizations({
+        transaction,
+      });
+
+    output.job_requisitions_organizations =
+      await organizations.getJob_requisitions_organizations({
+        transaction,
+      });
+
+    output.learning_courses_organizations =
+      await organizations.getLearning_courses_organizations({
+        transaction,
+      });
+
+    output.leave_requests_organizations =
+      await organizations.getLeave_requests_organizations({
+        transaction,
+      });
+
+    output.offers_organizations = await organizations.getOffers_organizations({
+      transaction,
+    });
+
+    output.payments_organizations =
+      await organizations.getPayments_organizations({
+        transaction,
+      });
+
+    output.payroll_runs_organizations =
+      await organizations.getPayroll_runs_organizations({
+        transaction,
+      });
+
+    output.policies_organizations =
+      await organizations.getPolicies_organizations({
+        transaction,
+      });
+
+    output.positions_organizations =
+      await organizations.getPositions_organizations({
+        transaction,
+      });
+
+    output.review_cycles_organizations =
+      await organizations.getReview_cycles_organizations({
+        transaction,
+      });
+
+    output.reviews_organizations = await organizations.getReviews_organizations(
+      {
+        transaction,
+      },
+    );
+
+    output.schedule_shifts_organizations =
+      await organizations.getSchedule_shifts_organizations({
+        transaction,
+      });
+
+    output.taxes_organizations = await organizations.getTaxes_organizations({
+      transaction,
+    });
+
+    output.time_entries_organizations =
+      await organizations.getTime_entries_organizations({
+        transaction,
+      });
+
+    output.timecards_organizations =
+      await organizations.getTimecards_organizations({
+        transaction,
+      });
+
+    output.travel_bookings_organizations =
+      await organizations.getTravel_bookings_organizations({
+        transaction,
+      });
+
+    output.vendors_organizations = await organizations.getVendors_organizations(
+      {
+        transaction,
+      },
+    );
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('organizations', 'name', filter.name),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.organizations.findAndCountAll(
+        queryOptions,
+      );
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('organizations', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.organizations.findAll({
+      attributes: ['id', 'name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.name,
+    }));
+  }
+};
--- a/backend/src/db/api/payments.js
+++ b/backend/src/db/api/payments.js
@ -0,0 +1,402 @@
+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,
+        paid_at: data.paid_at || null,
+        amount: data.amount || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await payments.setBill(data.bill || null, {
+      transaction,
+    });
+
+    await payments.setOrganizations(data.organizations || 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,
+      paid_at: item.paid_at || null,
+      amount: item.amount || 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.paid_at !== undefined) updatePayload.paid_at = data.paid_at;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await payments.update(updatePayload, { transaction });
+
+    if (data.bill !== undefined) {
+      await payments.setBill(
+        data.bill,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await payments.setOrganizations(
+        data.organizations,
+
+        { 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.bill = await payments.getBill({
+      transaction,
+    });
+
+    output.organizations = await payments.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.bills,
+        as: 'bill',
+
+        where: filter.bill
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.bill
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  invoice_no: {
+                    [Op.or]: filter.bill
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.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.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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.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', 'method', query),
+        ],
+      };
+    }
+
+    const records = await db.payments.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/payroll_runs.js
+++ b/backend/src/db/api/payroll_runs.js
@ -0,0 +1,441 @@
+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 Payroll_runsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const payroll_runs = await db.payroll_runs.create(
+      {
+        id: data.id || undefined,
+
+        country: data.country || null,
+        pay_period_start: data.pay_period_start || null,
+        pay_period_end: data.pay_period_end || null,
+        pay_date: data.pay_date || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await payroll_runs.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return payroll_runs;
+  }
+
+  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 payroll_runsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      country: item.country || null,
+      pay_period_start: item.pay_period_start || null,
+      pay_period_end: item.pay_period_end || null,
+      pay_date: item.pay_date || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const payroll_runs = await db.payroll_runs.bulkCreate(payroll_runsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return payroll_runs;
+  }
+
+  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 payroll_runs = await db.payroll_runs.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.country !== undefined) updatePayload.country = data.country;
+
+    if (data.pay_period_start !== undefined)
+      updatePayload.pay_period_start = data.pay_period_start;
+
+    if (data.pay_period_end !== undefined)
+      updatePayload.pay_period_end = data.pay_period_end;
+
+    if (data.pay_date !== undefined) updatePayload.pay_date = data.pay_date;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await payroll_runs.update(updatePayload, { transaction });
+
+    if (data.organizations !== undefined) {
+      await payroll_runs.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return payroll_runs;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const payroll_runs = await db.payroll_runs.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of payroll_runs) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of payroll_runs) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return payroll_runs;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const payroll_runs = await db.payroll_runs.findByPk(id, options);
+
+    await payroll_runs.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await payroll_runs.destroy({
+      transaction,
+    });
+
+    return payroll_runs;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const payroll_runs = await db.payroll_runs.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!payroll_runs) {
+      return payroll_runs;
+    }
+
+    const output = payroll_runs.get({ plain: true });
+
+    output.deductions_payroll_run =
+      await payroll_runs.getDeductions_payroll_run({
+        transaction,
+      });
+
+    output.earnings_payroll_run = await payroll_runs.getEarnings_payroll_run({
+      transaction,
+    });
+
+    output.taxes_payroll_run = await payroll_runs.getTaxes_payroll_run({
+      transaction,
+    });
+
+    output.organizations = await payroll_runs.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.country) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('payroll_runs', 'country', filter.country),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              pay_period_start: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              pay_period_end: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.pay_period_startRange) {
+        const [start, end] = filter.pay_period_startRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            pay_period_start: {
+              ...where.pay_period_start,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            pay_period_start: {
+              ...where.pay_period_start,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.pay_period_endRange) {
+        const [start, end] = filter.pay_period_endRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            pay_period_end: {
+              ...where.pay_period_end,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            pay_period_end: {
+              ...where.pay_period_end,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.pay_dateRange) {
+        const [start, end] = filter.pay_dateRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            pay_date: {
+              ...where.pay_date,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            pay_date: {
+              ...where.pay_date,
+              [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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.payroll_runs.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('payroll_runs', 'country', query),
+        ],
+      };
+    }
+
+    const records = await db.payroll_runs.findAll({
+      attributes: ['id', 'country'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['country', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.country,
+    }));
+  }
+};
--- 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 userOrganizations = (user && user.organizations?.id) || null;
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('permissions', 'name', filter.name),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.permissions.findAndCountAll(
+        queryOptions,
+      );
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(query, limit, offset) {
+    let where = {};
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('permissions', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.permissions.findAll({
+      attributes: ['id', 'name'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['name', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.name,
+    }));
+  }
+};
--- a/backend/src/db/api/policies.js
+++ b/backend/src/db/api/policies.js
@ -0,0 +1,327 @@
+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 PoliciesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const policies = await db.policies.create(
+      {
+        id: data.id || undefined,
+
+        scope: data.scope || null,
+        rule_logic: data.rule_logic || null,
+        effect: data.effect || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await policies.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return policies;
+  }
+
+  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 policiesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      scope: item.scope || null,
+      rule_logic: item.rule_logic || null,
+      effect: item.effect || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const policies = await db.policies.bulkCreate(policiesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return policies;
+  }
+
+  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 policies = await db.policies.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.scope !== undefined) updatePayload.scope = data.scope;
+
+    if (data.rule_logic !== undefined)
+      updatePayload.rule_logic = data.rule_logic;
+
+    if (data.effect !== undefined) updatePayload.effect = data.effect;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await policies.update(updatePayload, { transaction });
+
+    if (data.organizations !== undefined) {
+      await policies.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return policies;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const policies = await db.policies.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of policies) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of policies) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return policies;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const policies = await db.policies.findByPk(id, options);
+
+    await policies.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await policies.destroy({
+      transaction,
+    });
+
+    return policies;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const policies = await db.policies.findOne({ where }, { transaction });
+
+    if (!policies) {
+      return policies;
+    }
+
+    const output = policies.get({ plain: true });
+
+    output.organizations = await policies.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.scope) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('policies', 'scope', filter.scope),
+        };
+      }
+
+      if (filter.rule_logic) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('policies', 'rule_logic', filter.rule_logic),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.effect) {
+        where = {
+          ...where,
+          effect: filter.effect,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.policies.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('policies', 'scope', query),
+        ],
+      };
+    }
+
+    const records = await db.policies.findAll({
+      attributes: ['id', 'scope'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['scope', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.scope,
+    }));
+  }
+};
--- a/backend/src/db/api/positions.js
+++ b/backend/src/db/api/positions.js
@ -0,0 +1,369 @@
+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 PositionsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const positions = await db.positions.create(
+      {
+        id: data.id || undefined,
+
+        title: data.title || null,
+        job_family: data.job_family || null,
+        level: data.level || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await positions.setManager(data.manager || null, {
+      transaction,
+    });
+
+    await positions.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return positions;
+  }
+
+  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 positionsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      title: item.title || null,
+      job_family: item.job_family || null,
+      level: item.level || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const positions = await db.positions.bulkCreate(positionsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return positions;
+  }
+
+  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 positions = await db.positions.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.title !== undefined) updatePayload.title = data.title;
+
+    if (data.job_family !== undefined)
+      updatePayload.job_family = data.job_family;
+
+    if (data.level !== undefined) updatePayload.level = data.level;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await positions.update(updatePayload, { transaction });
+
+    if (data.manager !== undefined) {
+      await positions.setManager(
+        data.manager,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await positions.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return positions;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const positions = await db.positions.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of positions) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of positions) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return positions;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const positions = await db.positions.findByPk(id, options);
+
+    await positions.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await positions.destroy({
+      transaction,
+    });
+
+    return positions;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const positions = await db.positions.findOne({ where }, { transaction });
+
+    if (!positions) {
+      return positions;
+    }
+
+    const output = positions.get({ plain: true });
+
+    output.manager = await positions.getManager({
+      transaction,
+    });
+
+    output.organizations = await positions.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'manager',
+
+        where: filter.manager
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.manager
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.manager
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.title) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('positions', 'title', filter.title),
+        };
+      }
+
+      if (filter.job_family) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('positions', 'job_family', filter.job_family),
+        };
+      }
+
+      if (filter.level) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('positions', 'level', filter.level),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.positions.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('positions', 'title', query),
+        ],
+      };
+    }
+
+    const records = await db.positions.findAll({
+      attributes: ['id', 'title'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['title', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.title,
+    }));
+  }
+};
--- a/backend/src/db/api/review_cycles.js
+++ b/backend/src/db/api/review_cycles.js
@ -0,0 +1,403 @@
+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 Review_cyclesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const review_cycles = await db.review_cycles.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        cycle_start: data.cycle_start || null,
+        cycle_end: data.cycle_end || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await review_cycles.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return review_cycles;
+  }
+
+  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 review_cyclesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      cycle_start: item.cycle_start || null,
+      cycle_end: item.cycle_end || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const review_cycles = await db.review_cycles.bulkCreate(review_cyclesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return review_cycles;
+  }
+
+  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 review_cycles = await db.review_cycles.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    if (data.cycle_start !== undefined)
+      updatePayload.cycle_start = data.cycle_start;
+
+    if (data.cycle_end !== undefined) updatePayload.cycle_end = data.cycle_end;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await review_cycles.update(updatePayload, { transaction });
+
+    if (data.organizations !== undefined) {
+      await review_cycles.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return review_cycles;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const review_cycles = await db.review_cycles.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of review_cycles) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of review_cycles) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return review_cycles;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const review_cycles = await db.review_cycles.findByPk(id, options);
+
+    await review_cycles.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await review_cycles.destroy({
+      transaction,
+    });
+
+    return review_cycles;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const review_cycles = await db.review_cycles.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!review_cycles) {
+      return review_cycles;
+    }
+
+    const output = review_cycles.get({ plain: true });
+
+    output.reviews_review_cycle = await review_cycles.getReviews_review_cycle({
+      transaction,
+    });
+
+    output.organizations = await review_cycles.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('review_cycles', 'name', filter.name),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              cycle_start: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              cycle_end: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.cycle_startRange) {
+        const [start, end] = filter.cycle_startRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            cycle_start: {
+              ...where.cycle_start,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            cycle_start: {
+              ...where.cycle_start,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.cycle_endRange) {
+        const [start, end] = filter.cycle_endRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            cycle_end: {
+              ...where.cycle_end,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            cycle_end: {
+              ...where.cycle_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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.review_cycles.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('review_cycles', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.review_cycles.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/reviews.js
+++ b/backend/src/db/api/reviews.js
@ -0,0 +1,428 @@
+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 ReviewsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const reviews = await db.reviews.create(
+      {
+        id: data.id || undefined,
+
+        comments: data.comments || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await reviews.setReview_cycle(data.review_cycle || null, {
+      transaction,
+    });
+
+    await reviews.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await reviews.setReviewer(data.reviewer || null, {
+      transaction,
+    });
+
+    await reviews.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return reviews;
+  }
+
+  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 reviewsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      comments: item.comments || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const reviews = await db.reviews.bulkCreate(reviewsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return reviews;
+  }
+
+  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 reviews = await db.reviews.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.comments !== undefined) updatePayload.comments = data.comments;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await reviews.update(updatePayload, { transaction });
+
+    if (data.review_cycle !== undefined) {
+      await reviews.setReview_cycle(
+        data.review_cycle,
+
+        { transaction },
+      );
+    }
+
+    if (data.employee !== undefined) {
+      await reviews.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.reviewer !== undefined) {
+      await reviews.setReviewer(
+        data.reviewer,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await reviews.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return reviews;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const reviews = await db.reviews.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of reviews) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of reviews) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return reviews;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const reviews = await db.reviews.findByPk(id, options);
+
+    await reviews.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await reviews.destroy({
+      transaction,
+    });
+
+    return reviews;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const reviews = await db.reviews.findOne({ where }, { transaction });
+
+    if (!reviews) {
+      return reviews;
+    }
+
+    const output = reviews.get({ plain: true });
+
+    output.review_cycle = await reviews.getReview_cycle({
+      transaction,
+    });
+
+    output.employee = await reviews.getEmployee({
+      transaction,
+    });
+
+    output.reviewer = await reviews.getReviewer({
+      transaction,
+    });
+
+    output.organizations = await reviews.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.review_cycles,
+        as: 'review_cycle',
+
+        where: filter.review_cycle
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.review_cycle
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.review_cycle
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.employees,
+        as: 'reviewer',
+
+        where: filter.reviewer
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.reviewer
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.reviewer
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.comments) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('reviews', 'comments', filter.comments),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.reviews.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('reviews', 'review_cycle', query),
+        ],
+      };
+    }
+
+    const records = await db.reviews.findAll({
+      attributes: ['id', 'review_cycle'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['review_cycle', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.review_cycle,
+    }));
+  }
+};
--- 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 userOrganizations = (user && user.organizations?.id) || null;
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.permissions,
+        as: 'permissions',
+        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/schedule_shifts.js
+++ b/backend/src/db/api/schedule_shifts.js
@ -0,0 +1,458 @@
+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 Schedule_shiftsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const schedule_shifts = await db.schedule_shifts.create(
+      {
+        id: data.id || undefined,
+
+        date: data.date || null,
+        start: data.start || null,
+        end: data.end || null,
+        role: data.role || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await schedule_shifts.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await schedule_shifts.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return schedule_shifts;
+  }
+
+  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 schedule_shiftsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      date: item.date || null,
+      start: item.start || null,
+      end: item.end || null,
+      role: item.role || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const schedule_shifts = await db.schedule_shifts.bulkCreate(
+      schedule_shiftsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return schedule_shifts;
+  }
+
+  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 schedule_shifts = await db.schedule_shifts.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.date !== undefined) updatePayload.date = data.date;
+
+    if (data.start !== undefined) updatePayload.start = data.start;
+
+    if (data.end !== undefined) updatePayload.end = data.end;
+
+    if (data.role !== undefined) updatePayload.role = data.role;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await schedule_shifts.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await schedule_shifts.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await schedule_shifts.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return schedule_shifts;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const schedule_shifts = await db.schedule_shifts.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of schedule_shifts) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of schedule_shifts) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return schedule_shifts;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const schedule_shifts = await db.schedule_shifts.findByPk(id, options);
+
+    await schedule_shifts.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await schedule_shifts.destroy({
+      transaction,
+    });
+
+    return schedule_shifts;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const schedule_shifts = await db.schedule_shifts.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!schedule_shifts) {
+      return schedule_shifts;
+    }
+
+    const output = schedule_shifts.get({ plain: true });
+
+    output.employee = await schedule_shifts.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await schedule_shifts.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.role) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('schedule_shifts', 'role', filter.role),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              start: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              end: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      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.startRange) {
+        const [start, end] = filter.startRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.endRange) {
+        const [start, end] = filter.endRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            end: {
+              ...where.end,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            end: {
+              ...where.end,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.schedule_shifts.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('schedule_shifts', 'role', query),
+        ],
+      };
+    }
+
+    const records = await db.schedule_shifts.findAll({
+      attributes: ['id', 'role'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['role', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.role,
+    }));
+  }
+};
--- a/backend/src/db/api/taxes.js
+++ b/backend/src/db/api/taxes.js
@ -0,0 +1,415 @@
+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 TaxesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const taxes = await db.taxes.create(
+      {
+        id: data.id || undefined,
+
+        jurisdiction: data.jurisdiction || null,
+        amount: data.amount || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await taxes.setPayroll_run(data.payroll_run || null, {
+      transaction,
+    });
+
+    await taxes.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await taxes.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return taxes;
+  }
+
+  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 taxesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      jurisdiction: item.jurisdiction || null,
+      amount: item.amount || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const taxes = await db.taxes.bulkCreate(taxesData, { transaction });
+
+    // For each item created, replace relation files
+
+    return taxes;
+  }
+
+  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 taxes = await db.taxes.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.jurisdiction !== undefined)
+      updatePayload.jurisdiction = data.jurisdiction;
+
+    if (data.amount !== undefined) updatePayload.amount = data.amount;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await taxes.update(updatePayload, { transaction });
+
+    if (data.payroll_run !== undefined) {
+      await taxes.setPayroll_run(
+        data.payroll_run,
+
+        { transaction },
+      );
+    }
+
+    if (data.employee !== undefined) {
+      await taxes.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await taxes.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return taxes;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const taxes = await db.taxes.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of taxes) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of taxes) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return taxes;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const taxes = await db.taxes.findByPk(id, options);
+
+    await taxes.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await taxes.destroy({
+      transaction,
+    });
+
+    return taxes;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const taxes = await db.taxes.findOne({ where }, { transaction });
+
+    if (!taxes) {
+      return taxes;
+    }
+
+    const output = taxes.get({ plain: true });
+
+    output.payroll_run = await taxes.getPayroll_run({
+      transaction,
+    });
+
+    output.employee = await taxes.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await taxes.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.payroll_runs,
+        as: 'payroll_run',
+
+        where: filter.payroll_run
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.payroll_run
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  country: {
+                    [Op.or]: filter.payroll_run
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.jurisdiction) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('taxes', 'jurisdiction', filter.jurisdiction),
+        };
+      }
+
+      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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.taxes.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('taxes', 'jurisdiction', query),
+        ],
+      };
+    }
+
+    const records = await db.taxes.findAll({
+      attributes: ['id', 'jurisdiction'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['jurisdiction', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.jurisdiction,
+    }));
+  }
+};
--- a/backend/src/db/api/time_entries.js
+++ b/backend/src/db/api/time_entries.js
@ -0,0 +1,486 @@
+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 Time_entriesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const time_entries = await db.time_entries.create(
+      {
+        id: data.id || undefined,
+
+        date: data.date || null,
+        start: data.start || null,
+        end: data.end || null,
+        break_minutes: data.break_minutes || null,
+        job_code: data.job_code || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await time_entries.setTimecard(data.timecard || null, {
+      transaction,
+    });
+
+    await time_entries.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return time_entries;
+  }
+
+  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 time_entriesData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      date: item.date || null,
+      start: item.start || null,
+      end: item.end || null,
+      break_minutes: item.break_minutes || null,
+      job_code: item.job_code || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const time_entries = await db.time_entries.bulkCreate(time_entriesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return time_entries;
+  }
+
+  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 time_entries = await db.time_entries.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.date !== undefined) updatePayload.date = data.date;
+
+    if (data.start !== undefined) updatePayload.start = data.start;
+
+    if (data.end !== undefined) updatePayload.end = data.end;
+
+    if (data.break_minutes !== undefined)
+      updatePayload.break_minutes = data.break_minutes;
+
+    if (data.job_code !== undefined) updatePayload.job_code = data.job_code;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await time_entries.update(updatePayload, { transaction });
+
+    if (data.timecard !== undefined) {
+      await time_entries.setTimecard(
+        data.timecard,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await time_entries.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return time_entries;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const time_entries = await db.time_entries.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of time_entries) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of time_entries) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return time_entries;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const time_entries = await db.time_entries.findByPk(id, options);
+
+    await time_entries.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await time_entries.destroy({
+      transaction,
+    });
+
+    return time_entries;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const time_entries = await db.time_entries.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!time_entries) {
+      return time_entries;
+    }
+
+    const output = time_entries.get({ plain: true });
+
+    output.timecard = await time_entries.getTimecard({
+      transaction,
+    });
+
+    output.organizations = await time_entries.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.timecards,
+        as: 'timecard',
+
+        where: filter.timecard
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.timecard
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  period: {
+                    [Op.or]: filter.timecard
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.job_code) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('time_entries', 'job_code', filter.job_code),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              start: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              end: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      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.startRange) {
+        const [start, end] = filter.startRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.endRange) {
+        const [start, end] = filter.endRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            end: {
+              ...where.end,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            end: {
+              ...where.end,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.break_minutesRange) {
+        const [start, end] = filter.break_minutesRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            break_minutes: {
+              ...where.break_minutes,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            break_minutes: {
+              ...where.break_minutes,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.time_entries.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('time_entries', 'job_code', query),
+        ],
+      };
+    }
+
+    const records = await db.time_entries.findAll({
+      attributes: ['id', 'job_code'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['job_code', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.job_code,
+    }));
+  }
+};
--- a/backend/src/db/api/timecards.js
+++ b/backend/src/db/api/timecards.js
@ -0,0 +1,361 @@
+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 TimecardsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const timecards = await db.timecards.create(
+      {
+        id: data.id || undefined,
+
+        period: data.period || null,
+        status: data.status || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await timecards.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await timecards.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return timecards;
+  }
+
+  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 timecardsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      period: item.period || null,
+      status: item.status || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const timecards = await db.timecards.bulkCreate(timecardsData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return timecards;
+  }
+
+  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 timecards = await db.timecards.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.period !== undefined) updatePayload.period = data.period;
+
+    if (data.status !== undefined) updatePayload.status = data.status;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await timecards.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await timecards.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await timecards.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return timecards;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const timecards = await db.timecards.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of timecards) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of timecards) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return timecards;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const timecards = await db.timecards.findByPk(id, options);
+
+    await timecards.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await timecards.destroy({
+      transaction,
+    });
+
+    return timecards;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const timecards = await db.timecards.findOne({ where }, { transaction });
+
+    if (!timecards) {
+      return timecards;
+    }
+
+    const output = timecards.get({ plain: true });
+
+    output.time_entries_timecard = await timecards.getTime_entries_timecard({
+      transaction,
+    });
+
+    output.employee = await timecards.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await timecards.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.period) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('timecards', 'period', filter.period),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.status) {
+        where = {
+          ...where,
+          status: filter.status,
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.timecards.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('timecards', 'period', query),
+        ],
+      };
+    }
+
+    const records = await db.timecards.findAll({
+      attributes: ['id', 'period'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['period', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.period,
+    }));
+  }
+};
--- a/backend/src/db/api/travel_bookings.js
+++ b/backend/src/db/api/travel_bookings.js
@ -0,0 +1,485 @@
+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 Travel_bookingsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const travel_bookings = await db.travel_bookings.create(
+      {
+        id: data.id || undefined,
+
+        type: data.type || null,
+        provider: data.provider || null,
+        start: data.start || null,
+        end: data.end || null,
+        cost: data.cost || null,
+        policy_result: data.policy_result || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await travel_bookings.setEmployee(data.employee || null, {
+      transaction,
+    });
+
+    await travel_bookings.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return travel_bookings;
+  }
+
+  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 travel_bookingsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      type: item.type || null,
+      provider: item.provider || null,
+      start: item.start || null,
+      end: item.end || null,
+      cost: item.cost || null,
+      policy_result: item.policy_result || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const travel_bookings = await db.travel_bookings.bulkCreate(
+      travel_bookingsData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return travel_bookings;
+  }
+
+  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 travel_bookings = await db.travel_bookings.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.type !== undefined) updatePayload.type = data.type;
+
+    if (data.provider !== undefined) updatePayload.provider = data.provider;
+
+    if (data.start !== undefined) updatePayload.start = data.start;
+
+    if (data.end !== undefined) updatePayload.end = data.end;
+
+    if (data.cost !== undefined) updatePayload.cost = data.cost;
+
+    if (data.policy_result !== undefined)
+      updatePayload.policy_result = data.policy_result;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await travel_bookings.update(updatePayload, { transaction });
+
+    if (data.employee !== undefined) {
+      await travel_bookings.setEmployee(
+        data.employee,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await travel_bookings.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return travel_bookings;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const travel_bookings = await db.travel_bookings.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of travel_bookings) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of travel_bookings) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return travel_bookings;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const travel_bookings = await db.travel_bookings.findByPk(id, options);
+
+    await travel_bookings.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await travel_bookings.destroy({
+      transaction,
+    });
+
+    return travel_bookings;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const travel_bookings = await db.travel_bookings.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!travel_bookings) {
+      return travel_bookings;
+    }
+
+    const output = travel_bookings.get({ plain: true });
+
+    output.employee = await travel_bookings.getEmployee({
+      transaction,
+    });
+
+    output.organizations = await travel_bookings.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.employees,
+        as: 'employee',
+
+        where: filter.employee
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.employee
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  user: {
+                    [Op.or]: filter.employee
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.provider) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('travel_bookings', 'provider', filter.provider),
+        };
+      }
+
+      if (filter.policy_result) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'travel_bookings',
+            'policy_result',
+            filter.policy_result,
+          ),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              start: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              end: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.startRange) {
+        const [start, end] = filter.startRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            start: {
+              ...where.start,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.endRange) {
+        const [start, end] = filter.endRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            end: {
+              ...where.end,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            end: {
+              ...where.end,
+              [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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.travel_bookings.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('travel_bookings', 'provider', query),
+        ],
+      };
+    }
+
+    const records = await db.travel_bookings.findAll({
+      attributes: ['id', 'provider'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['provider', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.provider,
+    }));
+  }
+};
--- a/backend/src/db/api/users.js
+++ b/backend/src/db/api/users.js
@ -0,0 +1,804 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const bcrypt = require('bcrypt');
+const config = require('../../config');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class UsersDBApi {
+  static async create(data, globalAccess, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.create(
+      {
+        id: data.data.id || undefined,
+
+        firstName: data.data.firstName || null,
+        lastName: data.data.lastName || null,
+        phoneNumber: data.data.phoneNumber || null,
+        email: data.data.email || null,
+        disabled: data.data.disabled || false,
+
+        password: data.data.password || null,
+        emailVerified: data.data.emailVerified || true,
+
+        emailVerificationToken: data.data.emailVerificationToken || null,
+        emailVerificationTokenExpiresAt:
+          data.data.emailVerificationTokenExpiresAt || null,
+        passwordResetToken: data.data.passwordResetToken || null,
+        passwordResetTokenExpiresAt:
+          data.data.passwordResetTokenExpiresAt || null,
+        provider: data.data.provider || null,
+        importHash: data.data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    if (!data.data.app_role) {
+      const role = await db.roles.findOne({
+        where: { name: 'User' },
+      });
+      if (role) {
+        await users.setApp_role(role, {
+          transaction,
+        });
+      }
+    } else {
+      await users.setApp_role(data.data.app_role || null, {
+        transaction,
+      });
+    }
+
+    await users.setOrganizations(data.data.organizations || null, {
+      transaction,
+    });
+
+    await users.setCustom_permissions(data.data.custom_permissions || [], {
+      transaction,
+    });
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.users.getTableName(),
+        belongsToColumn: 'avatar',
+        belongsToId: users.id,
+      },
+      data.data.avatar,
+      options,
+    );
+
+    return users;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    // Prepare data - wrapping individual data transformations in a map() method
+    const usersData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      firstName: item.firstName || null,
+      lastName: item.lastName || null,
+      phoneNumber: item.phoneNumber || null,
+      email: item.email || null,
+      disabled: item.disabled || false,
+
+      password: item.password || null,
+      emailVerified: item.emailVerified || false,
+
+      emailVerificationToken: item.emailVerificationToken || null,
+      emailVerificationTokenExpiresAt:
+        item.emailVerificationTokenExpiresAt || null,
+      passwordResetToken: item.passwordResetToken || null,
+      passwordResetTokenExpiresAt: item.passwordResetTokenExpiresAt || null,
+      provider: item.provider || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const users = await db.users.bulkCreate(usersData, { transaction });
+
+    // For each item created, replace relation files
+
+    for (let i = 0; i < users.length; i++) {
+      await FileDBApi.replaceRelationFiles(
+        {
+          belongsTo: db.users.getTableName(),
+          belongsToColumn: 'avatar',
+          belongsToId: users[i].id,
+        },
+        data[i].avatar,
+        options,
+      );
+    }
+
+    return users;
+  }
+
+  static async update(id, data, globalAccess, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findByPk(id, {}, { transaction });
+
+    if (!data?.app_role) {
+      data.app_role = users?.app_role?.id;
+    }
+    if (!data?.custom_permissions) {
+      data.custom_permissions = users?.custom_permissions?.map(
+        (item) => item.id,
+      );
+    }
+
+    if (data.password) {
+      data.password = bcrypt.hashSync(data.password, config.bcrypt.saltRounds);
+    } else {
+      data.password = users.password;
+    }
+
+    const updatePayload = {};
+
+    if (data.firstName !== undefined) updatePayload.firstName = data.firstName;
+
+    if (data.lastName !== undefined) updatePayload.lastName = data.lastName;
+
+    if (data.phoneNumber !== undefined)
+      updatePayload.phoneNumber = data.phoneNumber;
+
+    if (data.email !== undefined) updatePayload.email = data.email;
+
+    if (data.disabled !== undefined) updatePayload.disabled = data.disabled;
+
+    if (data.password !== undefined) updatePayload.password = data.password;
+
+    if (data.emailVerified !== undefined)
+      updatePayload.emailVerified = data.emailVerified;
+    else updatePayload.emailVerified = true;
+
+    if (data.emailVerificationToken !== undefined)
+      updatePayload.emailVerificationToken = data.emailVerificationToken;
+
+    if (data.emailVerificationTokenExpiresAt !== undefined)
+      updatePayload.emailVerificationTokenExpiresAt =
+        data.emailVerificationTokenExpiresAt;
+
+    if (data.passwordResetToken !== undefined)
+      updatePayload.passwordResetToken = data.passwordResetToken;
+
+    if (data.passwordResetTokenExpiresAt !== undefined)
+      updatePayload.passwordResetTokenExpiresAt =
+        data.passwordResetTokenExpiresAt;
+
+    if (data.provider !== undefined) updatePayload.provider = data.provider;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await users.update(updatePayload, { transaction });
+
+    if (data.app_role !== undefined) {
+      await users.setApp_role(
+        data.app_role,
+
+        { transaction },
+      );
+    }
+
+    if (data.organizations !== undefined) {
+      await users.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    if (data.custom_permissions !== undefined) {
+      await users.setCustom_permissions(data.custom_permissions, {
+        transaction,
+      });
+    }
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.users.getTableName(),
+        belongsToColumn: 'avatar',
+        belongsToId: users.id,
+      },
+      data.avatar,
+      options,
+    );
+
+    return users;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of users) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of users) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return users;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findByPk(id, options);
+
+    await users.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await users.destroy({
+      transaction,
+    });
+
+    return users;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findOne({ where }, { transaction });
+
+    if (!users) {
+      return users;
+    }
+
+    const output = users.get({ plain: true });
+
+    output.employees_user = await users.getEmployees_user({
+      transaction,
+    });
+
+    output.avatar = await users.getAvatar({
+      transaction,
+    });
+
+    output.app_role = await users.getApp_role({
+      transaction,
+    });
+
+    if (output.app_role) {
+      output.app_role_permissions = await output.app_role.getPermissions({
+        transaction,
+      });
+    }
+
+    output.custom_permissions = await users.getCustom_permissions({
+      transaction,
+    });
+
+    output.organizations = await users.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.roles,
+        as: 'app_role',
+
+        where: filter.app_role
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.app_role
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.app_role
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+
+      {
+        model: db.permissions,
+        as: 'custom_permissions',
+        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.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.custom_permissions) {
+        const searchTerms = filter.custom_permissions.split('|');
+
+        include = [
+          {
+            model: db.permissions,
+            as: 'custom_permissions_filter',
+            required: searchTerms.length > 0,
+            where:
+              searchTerms.length > 0
+                ? {
+                    [Op.or]: [
+                      {
+                        id: {
+                          [Op.in]: searchTerms.map((term) => Utils.uuid(term)),
+                        },
+                      },
+                      {
+                        name: {
+                          [Op.or]: searchTerms.map((term) => ({
+                            [Op.iLike]: `%${term}%`,
+                          })),
+                        },
+                      },
+                    ],
+                  }
+                : undefined,
+          },
+          ...include,
+        ];
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.users.findAndCountAll(queryOptions);
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(
+    query,
+    limit,
+    offset,
+    globalAccess,
+    organizationId,
+  ) {
+    let where = {};
+
+    if (!globalAccess && organizationId) {
+      where.organizationId = organizationId;
+    }
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('users', 'firstName', query),
+        ],
+      };
+    }
+
+    const records = await db.users.findAll({
+      attributes: ['id', 'firstName'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['firstName', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.firstName,
+    }));
+  }
+
+  static async createFromAuth(data, options) {
+    const transaction = (options && options.transaction) || undefined;
+    const users = await db.users.create(
+      {
+        email: data.email,
+        firstName: data.firstName,
+        authenticationUid: data.authenticationUid,
+        password: data.password,
+
+        organizationId: data.organizationId,
+      },
+      { transaction },
+    );
+
+    const app_role = await db.roles.findOne({
+      where: { name: 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/vendors.js
+++ b/backend/src/db/api/vendors.js
@ -0,0 +1,339 @@
+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 VendorsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const vendors = await db.vendors.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        tax_id: data.tax_id || null,
+        country: data.country || null,
+        currency: data.currency || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await vendors.setOrganizations(data.organizations || null, {
+      transaction,
+    });
+
+    return vendors;
+  }
+
+  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 vendorsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      name: item.name || null,
+      tax_id: item.tax_id || null,
+      country: item.country || null,
+      currency: item.currency || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const vendors = await db.vendors.bulkCreate(vendorsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return vendors;
+  }
+
+  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 vendors = await db.vendors.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    if (data.tax_id !== undefined) updatePayload.tax_id = data.tax_id;
+
+    if (data.country !== undefined) updatePayload.country = data.country;
+
+    if (data.currency !== undefined) updatePayload.currency = data.currency;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await vendors.update(updatePayload, { transaction });
+
+    if (data.organizations !== undefined) {
+      await vendors.setOrganizations(
+        data.organizations,
+
+        { transaction },
+      );
+    }
+
+    return vendors;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const vendors = await db.vendors.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of vendors) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of vendors) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return vendors;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const vendors = await db.vendors.findByPk(id, options);
+
+    await vendors.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await vendors.destroy({
+      transaction,
+    });
+
+    return vendors;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const vendors = await db.vendors.findOne({ where }, { transaction });
+
+    if (!vendors) {
+      return vendors;
+    }
+
+    const output = vendors.get({ plain: true });
+
+    output.bills_vendor = await vendors.getBills_vendor({
+      transaction,
+    });
+
+    output.organizations = await vendors.getOrganizations({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, globalAccess, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    const user = (options && options.currentUser) || null;
+    const userOrganizations = (user && user.organizations?.id) || null;
+
+    if (userOrganizations) {
+      if (options?.currentUser?.organizationsId) {
+        where.organizationsId = options.currentUser.organizationsId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.organizations,
+        as: 'organizations',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.name) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vendors', 'name', filter.name),
+        };
+      }
+
+      if (filter.tax_id) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vendors', 'tax_id', filter.tax_id),
+        };
+      }
+
+      if (filter.country) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vendors', 'country', filter.country),
+        };
+      }
+
+      if (filter.currency) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('vendors', 'currency', filter.currency),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.organizations) {
+        const listItems = filter.organizations.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          organizationsId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    if (globalAccess) {
+      delete where.organizationsId;
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.vendors.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('vendors', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.vendors.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/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_ctplerp',
+    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/1756791420722.js
+++ b/backend/src/db/migrations/1756791420722.js
--- a/backend/src/db/models/app_accounts.js
+++ b/backend/src/db/models/app_accounts.js
@ -0,0 +1,73 @@
+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 app_accounts = sequelize.define(
+    'app_accounts',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      role: {
+        type: DataTypes.ENUM,
+
+        values: ['User', 'Admin', 'SuperAdmin'],
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Active', 'Inactive'],
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  app_accounts.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.app_accounts.belongsTo(db.employees, {
+      as: 'employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.app_accounts.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.app_accounts.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.app_accounts.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return app_accounts;
+};
--- a/backend/src/db/models/applications.js
+++ b/backend/src/db/models/applications.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 applications = sequelize.define(
+    'applications',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      submitted_at: {
+        type: DataTypes.DATE,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Pending', 'Reviewed', 'Rejected'],
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  applications.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.applications.hasMany(db.interviews, {
+      as: 'interviews_application',
+      foreignKey: {
+        name: 'applicationId',
+      },
+      constraints: false,
+    });
+
+    db.applications.hasMany(db.offers, {
+      as: 'offers_application',
+      foreignKey: {
+        name: 'applicationId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.applications.belongsTo(db.candidates, {
+      as: 'candidate',
+      foreignKey: {
+        name: 'candidateId',
+      },
+      constraints: false,
+    });
+
+    db.applications.belongsTo(db.job_requisitions, {
+      as: 'requisition',
+      foreignKey: {
+        name: 'requisitionId',
+      },
+      constraints: false,
+    });
+
+    db.applications.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.applications.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.applications.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return applications;
+};
--- a/backend/src/db/models/approvals.js
+++ b/backend/src/db/models/approvals.js
@ -0,0 +1,83 @@
+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 approvals = sequelize.define(
+    'approvals',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      object_type: {
+        type: DataTypes.TEXT,
+      },
+
+      object_id: {
+        type: DataTypes.INTEGER,
+      },
+
+      step: {
+        type: DataTypes.INTEGER,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Pending', 'Approved', 'Rejected'],
+      },
+
+      timestamp: {
+        type: DataTypes.DATE,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  approvals.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.approvals.belongsTo(db.employees, {
+      as: 'approver',
+      foreignKey: {
+        name: 'approverId',
+      },
+      constraints: false,
+    });
+
+    db.approvals.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.approvals.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.approvals.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return approvals;
+};
--- a/backend/src/db/models/audit_logs.js
+++ b/backend/src/db/models/audit_logs.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 audit_logs = sequelize.define(
+    'audit_logs',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      actor: {
+        type: DataTypes.TEXT,
+      },
+
+      action: {
+        type: DataTypes.TEXT,
+      },
+
+      object_type: {
+        type: DataTypes.TEXT,
+      },
+
+      object_id: {
+        type: DataTypes.INTEGER,
+      },
+
+      timestamp: {
+        type: DataTypes.DATE,
+      },
+
+      diff: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  audit_logs.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.audit_logs.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.audit_logs.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.audit_logs.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return audit_logs;
+};
--- a/backend/src/db/models/benefit_plans.js
+++ b/backend/src/db/models/benefit_plans.js
@ -0,0 +1,79 @@
+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 benefit_plans = sequelize.define(
+    'benefit_plans',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      carrier: {
+        type: DataTypes.TEXT,
+      },
+
+      plan_type: {
+        type: DataTypes.ENUM,
+
+        values: ['Medical', 'Dental', 'Vision'],
+      },
+
+      country: {
+        type: DataTypes.TEXT,
+      },
+
+      currency: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  benefit_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.benefit_plans.hasMany(db.enrollments, {
+      as: 'enrollments_plan',
+      foreignKey: {
+        name: 'planId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.benefit_plans.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.benefit_plans.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.benefit_plans.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return benefit_plans;
+};
--- a/backend/src/db/models/bills.js
+++ b/backend/src/db/models/bills.js
@ -0,0 +1,99 @@
+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 bills = sequelize.define(
+    'bills',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      invoice_no: {
+        type: DataTypes.TEXT,
+      },
+
+      invoice_date: {
+        type: DataTypes.DATE,
+      },
+
+      due_date: {
+        type: DataTypes.DATE,
+      },
+
+      amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      currency: {
+        type: DataTypes.TEXT,
+      },
+
+      category: {
+        type: DataTypes.TEXT,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Pending', 'Paid', 'Overdue'],
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  bills.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.bills.hasMany(db.payments, {
+      as: 'payments_bill',
+      foreignKey: {
+        name: 'billId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.bills.belongsTo(db.vendors, {
+      as: 'vendor',
+      foreignKey: {
+        name: 'vendorId',
+      },
+      constraints: false,
+    });
+
+    db.bills.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.bills.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.bills.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return bills;
+};
--- a/backend/src/db/models/candidates.js
+++ b/backend/src/db/models/candidates.js
@ -0,0 +1,83 @@
+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 candidates = sequelize.define(
+    'candidates',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      email: {
+        type: DataTypes.TEXT,
+      },
+
+      phone: {
+        type: DataTypes.TEXT,
+      },
+
+      source: {
+        type: DataTypes.TEXT,
+      },
+
+      current_stage: {
+        type: DataTypes.ENUM,
+
+        values: ['Applied', 'Interviewing', 'Offered', 'Hired'],
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  candidates.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.candidates.hasMany(db.applications, {
+      as: 'applications_candidate',
+      foreignKey: {
+        name: 'candidateId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.candidates.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.candidates.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.candidates.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return candidates;
+};
--- a/backend/src/db/models/cards.js
+++ b/backend/src/db/models/cards.js
@ -0,0 +1,81 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const cards = sequelize.define(
+    'cards',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      type: {
+        type: DataTypes.ENUM,
+
+        values: ['Virtual', 'Physical'],
+      },
+
+      last4: {
+        type: DataTypes.TEXT,
+      },
+
+      limit: {
+        type: DataTypes.DECIMAL,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Active', 'Inactive'],
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  cards.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.cards.belongsTo(db.employees, {
+      as: 'employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.cards.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.cards.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.cards.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return cards;
+};
--- a/backend/src/db/models/compensations.js
+++ b/backend/src/db/models/compensations.js
@ -0,0 +1,85 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const compensations = sequelize.define(
+    'compensations',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      base_pay: {
+        type: DataTypes.DECIMAL,
+      },
+
+      pay_type: {
+        type: DataTypes.ENUM,
+
+        values: ['Hourly', 'Salary'],
+      },
+
+      pay_frequency: {
+        type: DataTypes.ENUM,
+
+        values: ['Weekly', 'Bi-weekly', 'Monthly'],
+      },
+
+      currency: {
+        type: DataTypes.TEXT,
+      },
+
+      effective_date: {
+        type: DataTypes.DATE,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  compensations.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.compensations.belongsTo(db.employees, {
+      as: 'employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.compensations.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.compensations.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.compensations.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return compensations;
+};
--- a/backend/src/db/models/deductions.js
+++ b/backend/src/db/models/deductions.js
@ -0,0 +1,79 @@
+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 deductions = sequelize.define(
+    'deductions',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      type: {
+        type: DataTypes.ENUM,
+
+        values: ['Tax', 'Insurance', 'Other'],
+      },
+
+      amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  deductions.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.deductions.belongsTo(db.payroll_runs, {
+      as: 'payroll_run',
+      foreignKey: {
+        name: 'payroll_runId',
+      },
+      constraints: false,
+    });
+
+    db.deductions.belongsTo(db.employees, {
+      as: 'employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.deductions.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.deductions.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.deductions.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return deductions;
+};
--- a/backend/src/db/models/devices.js
+++ b/backend/src/db/models/devices.js
@ -0,0 +1,106 @@
+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 devices = sequelize.define(
+    'devices',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      type: {
+        type: DataTypes.ENUM,
+
+        values: ['Laptop', 'Desktop', 'Tablet'],
+      },
+
+      platform: {
+        type: DataTypes.ENUM,
+
+        values: ['Windows', 'MacOS', 'Linux'],
+      },
+
+      serial: {
+        type: DataTypes.TEXT,
+      },
+
+      asset_tag: {
+        type: DataTypes.TEXT,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Assigned', 'InStock', 'Retired'],
+      },
+
+      encryption: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      os_version: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  devices.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.devices.hasMany(db.inventory_events, {
+      as: 'inventory_events_device',
+      foreignKey: {
+        name: 'deviceId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.devices.belongsTo(db.employees, {
+      as: 'owner',
+      foreignKey: {
+        name: 'ownerId',
+      },
+      constraints: false,
+    });
+
+    db.devices.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.devices.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.devices.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return devices;
+};
--- a/backend/src/db/models/documents.js
+++ b/backend/src/db/models/documents.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 documents = sequelize.define(
+    'documents',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      doc_type: {
+        type: DataTypes.ENUM,
+
+        values: ['Contract', 'ID', 'Certificate'],
+      },
+
+      country: {
+        type: DataTypes.TEXT,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Pending', 'Signed', 'Expired'],
+      },
+
+      signed_at: {
+        type: DataTypes.DATE,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  documents.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.documents.belongsTo(db.employees, {
+      as: 'owner',
+      foreignKey: {
+        name: 'ownerId',
+      },
+      constraints: false,
+    });
+
+    db.documents.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.documents.hasMany(db.file, {
+      as: 'file_ref',
+      foreignKey: 'belongsToId',
+      constraints: false,
+      scope: {
+        belongsTo: db.documents.getTableName(),
+        belongsToColumn: 'file_ref',
+      },
+    });
+
+    db.documents.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.documents.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return documents;
+};
--- a/backend/src/db/models/earnings.js
+++ b/backend/src/db/models/earnings.js
@ -0,0 +1,96 @@
+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 earnings = sequelize.define(
+    'earnings',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      component: {
+        type: DataTypes.TEXT,
+      },
+
+      units: {
+        type: DataTypes.DECIMAL,
+      },
+
+      rate: {
+        type: DataTypes.DECIMAL,
+      },
+
+      amount: {
+        type: DataTypes.DECIMAL,
+      },
+
+      currency: {
+        type: DataTypes.TEXT,
+      },
+
+      taxable: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  earnings.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.earnings.belongsTo(db.payroll_runs, {
+      as: 'payroll_run',
+      foreignKey: {
+        name: 'payroll_runId',
+      },
+      constraints: false,
+    });
+
+    db.earnings.belongsTo(db.employees, {
+      as: 'employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.earnings.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.earnings.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.earnings.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return earnings;
+};
--- a/backend/src/db/models/employees.js
+++ b/backend/src/db/models/employees.js
@ -0,0 +1,333 @@
+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 employees = sequelize.define(
+    'employees',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  employees.associate = (db) => {
+    db.employees.belongsToMany(db.employments, {
+      as: 'employments',
+      foreignKey: {
+        name: 'employees_employmentsId',
+      },
+      constraints: false,
+      through: 'employeesEmploymentsEmployments',
+    });
+
+    db.employees.belongsToMany(db.employments, {
+      as: 'employments_filter',
+      foreignKey: {
+        name: 'employees_employmentsId',
+      },
+      constraints: false,
+      through: 'employeesEmploymentsEmployments',
+    });
+
+    db.employees.belongsToMany(db.positions, {
+      as: 'positions',
+      foreignKey: {
+        name: 'employees_positionsId',
+      },
+      constraints: false,
+      through: 'employeesPositionsPositions',
+    });
+
+    db.employees.belongsToMany(db.positions, {
+      as: 'positions_filter',
+      foreignKey: {
+        name: 'employees_positionsId',
+      },
+      constraints: false,
+      through: 'employeesPositionsPositions',
+    });
+
+    db.employees.belongsToMany(db.compensations, {
+      as: 'compensations',
+      foreignKey: {
+        name: 'employees_compensationsId',
+      },
+      constraints: false,
+      through: 'employeesCompensationsCompensations',
+    });
+
+    db.employees.belongsToMany(db.compensations, {
+      as: 'compensations_filter',
+      foreignKey: {
+        name: 'employees_compensationsId',
+      },
+      constraints: false,
+      through: 'employeesCompensationsCompensations',
+    });
+
+    db.employees.belongsToMany(db.documents, {
+      as: 'documents',
+      foreignKey: {
+        name: 'employees_documentsId',
+      },
+      constraints: false,
+      through: 'employeesDocumentsDocuments',
+    });
+
+    db.employees.belongsToMany(db.documents, {
+      as: 'documents_filter',
+      foreignKey: {
+        name: 'employees_documentsId',
+      },
+      constraints: false,
+      through: 'employeesDocumentsDocuments',
+    });
+
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.employees.hasMany(db.app_accounts, {
+      as: 'app_accounts_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.approvals, {
+      as: 'approvals_approver',
+      foreignKey: {
+        name: 'approverId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.cards, {
+      as: 'cards_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.compensations, {
+      as: 'compensations_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.deductions, {
+      as: 'deductions_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.devices, {
+      as: 'devices_owner',
+      foreignKey: {
+        name: 'ownerId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.documents, {
+      as: 'documents_owner',
+      foreignKey: {
+        name: 'ownerId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.earnings, {
+      as: 'earnings_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.employments, {
+      as: 'employments_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.enrollment_learnings, {
+      as: 'enrollment_learnings_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.enrollment_learnings, {
+      as: 'enrollment_learnings_assigned_by',
+      foreignKey: {
+        name: 'assigned_byId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.enrollments, {
+      as: 'enrollments_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.expense_reports, {
+      as: 'expense_reports_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.goals, {
+      as: 'goals_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.identity_accounts, {
+      as: 'identity_accounts_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.interviews, {
+      as: 'interviews_interviewer',
+      foreignKey: {
+        name: 'interviewerId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.job_requisitions, {
+      as: 'job_requisitions_recruiter',
+      foreignKey: {
+        name: 'recruiterId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.leave_requests, {
+      as: 'leave_requests_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.positions, {
+      as: 'positions_manager',
+      foreignKey: {
+        name: 'managerId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.reviews, {
+      as: 'reviews_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.reviews, {
+      as: 'reviews_reviewer',
+      foreignKey: {
+        name: 'reviewerId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.schedule_shifts, {
+      as: 'schedule_shifts_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.taxes, {
+      as: 'taxes_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.timecards, {
+      as: 'timecards_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employees.hasMany(db.travel_bookings, {
+      as: 'travel_bookings_employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.employees.belongsTo(db.users, {
+      as: 'user',
+      foreignKey: {
+        name: 'userId',
+      },
+      constraints: false,
+    });
+
+    db.employees.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.employees.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.employees.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return employees;
+};
--- a/backend/src/db/models/employments.js
+++ b/backend/src/db/models/employments.js
@ -0,0 +1,85 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const employments = sequelize.define(
+    'employments',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      employment_type: {
+        type: DataTypes.ENUM,
+
+        values: ['Full-time', 'Part-time', 'Contractor'],
+      },
+
+      start_date: {
+        type: DataTypes.DATE,
+      },
+
+      end_date: {
+        type: DataTypes.DATE,
+      },
+
+      fte: {
+        type: DataTypes.DECIMAL,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Active', 'Inactive', 'Terminated'],
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  employments.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.employments.belongsTo(db.employees, {
+      as: 'employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.employments.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.employments.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.employments.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return employments;
+};
--- a/backend/src/db/models/enrollment_learnings.js
+++ b/backend/src/db/models/enrollment_learnings.js
@ -0,0 +1,87 @@
+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 enrollment_learnings = sequelize.define(
+    'enrollment_learnings',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      due_date: {
+        type: DataTypes.DATE,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Assigned', 'Completed', 'Overdue'],
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  enrollment_learnings.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.enrollment_learnings.belongsTo(db.employees, {
+      as: 'employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.enrollment_learnings.belongsTo(db.learning_courses, {
+      as: 'course',
+      foreignKey: {
+        name: 'courseId',
+      },
+      constraints: false,
+    });
+
+    db.enrollment_learnings.belongsTo(db.employees, {
+      as: 'assigned_by',
+      foreignKey: {
+        name: 'assigned_byId',
+      },
+      constraints: false,
+    });
+
+    db.enrollment_learnings.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.enrollment_learnings.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.enrollment_learnings.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return enrollment_learnings;
+};
--- a/backend/src/db/models/enrollments.js
+++ b/backend/src/db/models/enrollments.js
@ -0,0 +1,87 @@
+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 enrollments = sequelize.define(
+    'enrollments',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      effective_date: {
+        type: DataTypes.DATE,
+      },
+
+      premium_employee: {
+        type: DataTypes.DECIMAL,
+      },
+
+      premium_employer: {
+        type: DataTypes.DECIMAL,
+      },
+
+      status: {
+        type: DataTypes.ENUM,
+
+        values: ['Active', 'Inactive'],
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  enrollments.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.enrollments.belongsTo(db.employees, {
+      as: 'employee',
+      foreignKey: {
+        name: 'employeeId',
+      },
+      constraints: false,
+    });
+
+    db.enrollments.belongsTo(db.benefit_plans, {
+      as: 'plan',
+      foreignKey: {
+        name: 'planId',
+      },
+      constraints: false,
+    });
+
+    db.enrollments.belongsTo(db.organizations, {
+      as: 'organizations',
+      foreignKey: {
+        name: 'organizationsId',
+      },
+      constraints: false,
+    });
+
+    db.enrollments.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.enrollments.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return enrollments;
+};
--- a/Show More
+++ b/Show More