Initial version

2025-10-24 09:54:37 +00:00 · 2025-10-24 09:54:37 +00:00 · de943f1a4f
commit de943f1a4f
742 changed files with 151561 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>Gerenciador e Fiscalizador de Obras Copasa</h2>
+            <p>Web system for managing and inspecting public sanitation works by COPASA.</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 @@
+
+
+# Gerenciador e Fiscalizador de Obras Copasa
+
+## 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: "e64ad93f",
+  admin_email: "admin@flatlogic.com",
+  schema_encryption_key: process.env.SCHEMA_ENCRYPTION_KEY || '',
+
+  project_uuid: 'e64ad93f-5f26-4622-bc11-6b4b199ed480',
+  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 = '35175';
+    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 @@
+#Gerenciador e Fiscalizador de Obras Copasa - 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_gerenciador_e_fiscalizador_de_obras_copasa;`
+
+- Then give that new user privileges to the new database then quit the `psql`.
+  - `postgres=> GRANT ALL PRIVILEGES ON DATABASE db_gerenciador_e_fiscalizador_de_obras_copasa 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": "gerenciadorefiscalizadordeobrascopasa",
+  "description": "Gerenciador e Fiscalizador de Obras Copasa - 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: 'ceb20b4bddfee9c660023c76b30ac778',
+  },
+  bcrypt: {
+    saltRounds: 12,
+  },
+  admin_pass: 'e64ad93f',
+  user_pass: '6b4b199ed480',
+  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: 'Gerenciador e Fiscalizador de Obras Copasa <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: 'Data Analyst',
+  },
+
+  project_uuid: 'e64ad93f-5f26-4622-bc11-6b4b199ed480',
+  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 = 'Drone overseeing construction site';
+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/cameras_ptz.js
+++ b/backend/src/db/api/cameras_ptz.js
@ -0,0 +1,554 @@
+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 Cameras_ptzDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const cameras_ptz = await db.cameras_ptz.create(
+      {
+        id: data.id || undefined,
+
+        modelo: data.modelo || null,
+        fabricante: data.fabricante || null,
+        local_instalacao: data.local_instalacao || null,
+        coordenada_lat: data.coordenada_lat || null,
+        coordenada_lon: data.coordenada_lon || null,
+        altura_instalacao_m: data.altura_instalacao_m || null,
+        angulo_focal: data.angulo_focal || null,
+        ip_acesso: data.ip_acesso || null,
+        status_operacional: data.status_operacional || null,
+        data_instalacao: data.data_instalacao || null,
+        observacoes: data.observacoes || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await cameras_ptz.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await cameras_ptz.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return cameras_ptz;
+  }
+
+  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 cameras_ptzData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      modelo: item.modelo || null,
+      fabricante: item.fabricante || null,
+      local_instalacao: item.local_instalacao || null,
+      coordenada_lat: item.coordenada_lat || null,
+      coordenada_lon: item.coordenada_lon || null,
+      altura_instalacao_m: item.altura_instalacao_m || null,
+      angulo_focal: item.angulo_focal || null,
+      ip_acesso: item.ip_acesso || null,
+      status_operacional: item.status_operacional || null,
+      data_instalacao: item.data_instalacao || null,
+      observacoes: item.observacoes || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const cameras_ptz = await db.cameras_ptz.bulkCreate(cameras_ptzData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return cameras_ptz;
+  }
+
+  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 cameras_ptz = await db.cameras_ptz.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.modelo !== undefined) updatePayload.modelo = data.modelo;
+
+    if (data.fabricante !== undefined)
+      updatePayload.fabricante = data.fabricante;
+
+    if (data.local_instalacao !== undefined)
+      updatePayload.local_instalacao = data.local_instalacao;
+
+    if (data.coordenada_lat !== undefined)
+      updatePayload.coordenada_lat = data.coordenada_lat;
+
+    if (data.coordenada_lon !== undefined)
+      updatePayload.coordenada_lon = data.coordenada_lon;
+
+    if (data.altura_instalacao_m !== undefined)
+      updatePayload.altura_instalacao_m = data.altura_instalacao_m;
+
+    if (data.angulo_focal !== undefined)
+      updatePayload.angulo_focal = data.angulo_focal;
+
+    if (data.ip_acesso !== undefined) updatePayload.ip_acesso = data.ip_acesso;
+
+    if (data.status_operacional !== undefined)
+      updatePayload.status_operacional = data.status_operacional;
+
+    if (data.data_instalacao !== undefined)
+      updatePayload.data_instalacao = data.data_instalacao;
+
+    if (data.observacoes !== undefined)
+      updatePayload.observacoes = data.observacoes;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await cameras_ptz.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await cameras_ptz.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await cameras_ptz.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return cameras_ptz;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const cameras_ptz = await db.cameras_ptz.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of cameras_ptz) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of cameras_ptz) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return cameras_ptz;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const cameras_ptz = await db.cameras_ptz.findByPk(id, options);
+
+    await cameras_ptz.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await cameras_ptz.destroy({
+      transaction,
+    });
+
+    return cameras_ptz;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const cameras_ptz = await db.cameras_ptz.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!cameras_ptz) {
+      return cameras_ptz;
+    }
+
+    const output = cameras_ptz.get({ plain: true });
+
+    output.obra = await cameras_ptz.getObra({
+      transaction,
+    });
+
+    output.clientes = await cameras_ptz.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.modelo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('cameras_ptz', 'modelo', filter.modelo),
+        };
+      }
+
+      if (filter.fabricante) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('cameras_ptz', 'fabricante', filter.fabricante),
+        };
+      }
+
+      if (filter.local_instalacao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'cameras_ptz',
+            'local_instalacao',
+            filter.local_instalacao,
+          ),
+        };
+      }
+
+      if (filter.angulo_focal) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'cameras_ptz',
+            'angulo_focal',
+            filter.angulo_focal,
+          ),
+        };
+      }
+
+      if (filter.ip_acesso) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('cameras_ptz', 'ip_acesso', filter.ip_acesso),
+        };
+      }
+
+      if (filter.status_operacional) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'cameras_ptz',
+            'status_operacional',
+            filter.status_operacional,
+          ),
+        };
+      }
+
+      if (filter.observacoes) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'cameras_ptz',
+            'observacoes',
+            filter.observacoes,
+          ),
+        };
+      }
+
+      if (filter.coordenada_latRange) {
+        const [start, end] = filter.coordenada_latRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            coordenada_lat: {
+              ...where.coordenada_lat,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            coordenada_lat: {
+              ...where.coordenada_lat,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.coordenada_lonRange) {
+        const [start, end] = filter.coordenada_lonRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            coordenada_lon: {
+              ...where.coordenada_lon,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            coordenada_lon: {
+              ...where.coordenada_lon,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.altura_instalacao_mRange) {
+        const [start, end] = filter.altura_instalacao_mRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            altura_instalacao_m: {
+              ...where.altura_instalacao_m,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            altura_instalacao_m: {
+              ...where.altura_instalacao_m,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.data_instalacaoRange) {
+        const [start, end] = filter.data_instalacaoRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_instalacao: {
+              ...where.data_instalacao,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_instalacao: {
+              ...where.data_instalacao,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.cameras_ptz.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('cameras_ptz', 'modelo', query),
+        ],
+      };
+    }
+
+    const records = await db.cameras_ptz.findAll({
+      attributes: ['id', 'modelo'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['modelo', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.modelo,
+    }));
+  }
+};
--- a/backend/src/db/api/clientes.js
+++ b/backend/src/db/api/clientes.js
@ -0,0 +1,409 @@
+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 ClientesDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const clientes = await db.clientes.create(
+      {
+        id: data.id || undefined,
+
+        name: data.name || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    return clientes;
+  }
+
+  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 clientesData = 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 clientes = await db.clientes.bulkCreate(clientesData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return clientes;
+  }
+
+  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 clientes = await db.clientes.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.name !== undefined) updatePayload.name = data.name;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await clientes.update(updatePayload, { transaction });
+
+    return clientes;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const clientes = await db.clientes.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of clientes) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of clientes) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return clientes;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const clientes = await db.clientes.findByPk(id, options);
+
+    await clientes.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await clientes.destroy({
+      transaction,
+    });
+
+    return clientes;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const clientes = await db.clientes.findOne({ where }, { transaction });
+
+    if (!clientes) {
+      return clientes;
+    }
+
+    const output = clientes.get({ plain: true });
+
+    output.users_clientes = await clientes.getUsers_clientes({
+      transaction,
+    });
+
+    output.cameras_ptz_clientes = await clientes.getCameras_ptz_clientes({
+      transaction,
+    });
+
+    output.epcs_clientes = await clientes.getEpcs_clientes({
+      transaction,
+    });
+
+    output.epis_clientes = await clientes.getEpis_clientes({
+      transaction,
+    });
+
+    output.equipes_trabalho_clientes =
+      await clientes.getEquipes_trabalho_clientes({
+        transaction,
+      });
+
+    output.estrutura_projeto_clientes =
+      await clientes.getEstrutura_projeto_clientes({
+        transaction,
+      });
+
+    output.etapas_ou_trechos_clientes =
+      await clientes.getEtapas_ou_trechos_clientes({
+        transaction,
+      });
+
+    output.frames_imagem_clientes = await clientes.getFrames_imagem_clientes({
+      transaction,
+    });
+
+    output.gemeos_digitais_clientes =
+      await clientes.getGemeos_digitais_clientes({
+        transaction,
+      });
+
+    output.historico_alteracoes_projeto_clientes =
+      await clientes.getHistorico_alteracoes_projeto_clientes({
+        transaction,
+      });
+
+    output.inspecao_aerea_clientes = await clientes.getInspecao_aerea_clientes({
+      transaction,
+    });
+
+    output.maquinas_atividade_clientes =
+      await clientes.getMaquinas_atividade_clientes({
+        transaction,
+      });
+
+    output.materiais_atividade_clientes =
+      await clientes.getMateriais_atividade_clientes({
+        transaction,
+      });
+
+    output.membros_equipe_clientes = await clientes.getMembros_equipe_clientes({
+      transaction,
+    });
+
+    output.memoriais_descritivos_asbuilt_clientes =
+      await clientes.getMemoriais_descritivos_asbuilt_clientes({
+        transaction,
+      });
+
+    output.modelos_bim_asbuilt_clientes =
+      await clientes.getModelos_bim_asbuilt_clientes({
+        transaction,
+      });
+
+    output.obras_cliente = await clientes.getObras_cliente({
+      transaction,
+    });
+
+    output.obras_clientes = await clientes.getObras_clientes({
+      transaction,
+    });
+
+    output.permissoes_modulo_clientes =
+      await clientes.getPermissoes_modulo_clientes({
+        transaction,
+      });
+
+    output.pessoas_atividade_clientes =
+      await clientes.getPessoas_atividade_clientes({
+        transaction,
+      });
+
+    output.pessoas_frame_clientes = await clientes.getPessoas_frame_clientes({
+      transaction,
+    });
+
+    output.plantas_asbuilt_2d_clientes =
+      await clientes.getPlantas_asbuilt_2d_clientes({
+        transaction,
+      });
+
+    output.relatorio_andamento_atual_clientes =
+      await clientes.getRelatorio_andamento_atual_clientes({
+        transaction,
+      });
+
+    output.relatorios_analiticos_video_clientes =
+      await clientes.getRelatorios_analiticos_video_clientes({
+        transaction,
+      });
+
+    output.relatorios_diarios_clientes =
+      await clientes.getRelatorios_diarios_clientes({
+        transaction,
+      });
+
+    output.relatorios_mensais_clientes =
+      await clientes.getRelatorios_mensais_clientes({
+        transaction,
+      });
+
+    output.relatorios_semanais_clientes =
+      await clientes.getRelatorios_semanais_clientes({
+        transaction,
+      });
+
+    output.subcontratadas_clientes = await clientes.getSubcontratadas_clientes({
+      transaction,
+    });
+
+    output.usuarios_cliente = await clientes.getUsuarios_cliente({
+      transaction,
+    });
+
+    output.usuarios_clientes = await clientes.getUsuarios_clientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    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('clientes', '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.clientesId;
+    }
+
+    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.clientes.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('clientes', 'name', query),
+        ],
+      };
+    }
+
+    const records = await db.clientes.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/epcs.js
+++ b/backend/src/db/api/epcs.js
@ -0,0 +1,313 @@
+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 EpcsDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const epcs = await db.epcs.create(
+      {
+        id: data.id || undefined,
+
+        nome_epc: data.nome_epc || null,
+        descricao: data.descricao || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await epcs.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return epcs;
+  }
+
+  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 epcsData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      nome_epc: item.nome_epc || null,
+      descricao: item.descricao || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const epcs = await db.epcs.bulkCreate(epcsData, { transaction });
+
+    // For each item created, replace relation files
+
+    return epcs;
+  }
+
+  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 epcs = await db.epcs.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.nome_epc !== undefined) updatePayload.nome_epc = data.nome_epc;
+
+    if (data.descricao !== undefined) updatePayload.descricao = data.descricao;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await epcs.update(updatePayload, { transaction });
+
+    if (data.clientes !== undefined) {
+      await epcs.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return epcs;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const epcs = await db.epcs.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of epcs) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of epcs) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return epcs;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const epcs = await db.epcs.findByPk(id, options);
+
+    await epcs.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await epcs.destroy({
+      transaction,
+    });
+
+    return epcs;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const epcs = await db.epcs.findOne({ where }, { transaction });
+
+    if (!epcs) {
+      return epcs;
+    }
+
+    const output = epcs.get({ plain: true });
+
+    output.clientes = await epcs.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.nome_epc) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('epcs', 'nome_epc', filter.nome_epc),
+        };
+      }
+
+      if (filter.descricao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('epcs', 'descricao', filter.descricao),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.epcs.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('epcs', 'nome_epc', query),
+        ],
+      };
+    }
+
+    const records = await db.epcs.findAll({
+      attributes: ['id', 'nome_epc'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome_epc', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome_epc,
+    }));
+  }
+};
--- a/backend/src/db/api/epis.js
+++ b/backend/src/db/api/epis.js
@ -0,0 +1,313 @@
+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 EpisDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const epis = await db.epis.create(
+      {
+        id: data.id || undefined,
+
+        nome_epi: data.nome_epi || null,
+        descricao: data.descricao || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await epis.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return epis;
+  }
+
+  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 episData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      nome_epi: item.nome_epi || null,
+      descricao: item.descricao || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const epis = await db.epis.bulkCreate(episData, { transaction });
+
+    // For each item created, replace relation files
+
+    return epis;
+  }
+
+  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 epis = await db.epis.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.nome_epi !== undefined) updatePayload.nome_epi = data.nome_epi;
+
+    if (data.descricao !== undefined) updatePayload.descricao = data.descricao;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await epis.update(updatePayload, { transaction });
+
+    if (data.clientes !== undefined) {
+      await epis.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return epis;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const epis = await db.epis.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of epis) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of epis) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return epis;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const epis = await db.epis.findByPk(id, options);
+
+    await epis.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await epis.destroy({
+      transaction,
+    });
+
+    return epis;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const epis = await db.epis.findOne({ where }, { transaction });
+
+    if (!epis) {
+      return epis;
+    }
+
+    const output = epis.get({ plain: true });
+
+    output.clientes = await epis.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.nome_epi) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('epis', 'nome_epi', filter.nome_epi),
+        };
+      }
+
+      if (filter.descricao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('epis', 'descricao', filter.descricao),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.epis.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('epis', 'nome_epi', query),
+        ],
+      };
+    }
+
+    const records = await db.epis.findAll({
+      attributes: ['id', 'nome_epi'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome_epi', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome_epi,
+    }));
+  }
+};
--- a/backend/src/db/api/equipes_trabalho.js
+++ b/backend/src/db/api/equipes_trabalho.js
@ -0,0 +1,377 @@
+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 Equipes_trabalhoDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const equipes_trabalho = await db.equipes_trabalho.create(
+      {
+        id: data.id || undefined,
+
+        nome_equipe: data.nome_equipe || null,
+        tipo: data.tipo || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await equipes_trabalho.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await equipes_trabalho.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return equipes_trabalho;
+  }
+
+  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 equipes_trabalhoData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      nome_equipe: item.nome_equipe || null,
+      tipo: item.tipo || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const equipes_trabalho = await db.equipes_trabalho.bulkCreate(
+      equipes_trabalhoData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return equipes_trabalho;
+  }
+
+  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 equipes_trabalho = await db.equipes_trabalho.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.nome_equipe !== undefined)
+      updatePayload.nome_equipe = data.nome_equipe;
+
+    if (data.tipo !== undefined) updatePayload.tipo = data.tipo;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await equipes_trabalho.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await equipes_trabalho.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await equipes_trabalho.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return equipes_trabalho;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const equipes_trabalho = await db.equipes_trabalho.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of equipes_trabalho) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of equipes_trabalho) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return equipes_trabalho;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const equipes_trabalho = await db.equipes_trabalho.findByPk(id, options);
+
+    await equipes_trabalho.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await equipes_trabalho.destroy({
+      transaction,
+    });
+
+    return equipes_trabalho;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const equipes_trabalho = await db.equipes_trabalho.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!equipes_trabalho) {
+      return equipes_trabalho;
+    }
+
+    const output = equipes_trabalho.get({ plain: true });
+
+    output.membros_equipe_equipe =
+      await equipes_trabalho.getMembros_equipe_equipe({
+        transaction,
+      });
+
+    output.obra = await equipes_trabalho.getObra({
+      transaction,
+    });
+
+    output.clientes = await equipes_trabalho.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.nome_equipe) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'equipes_trabalho',
+            'nome_equipe',
+            filter.nome_equipe,
+          ),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.tipo) {
+        where = {
+          ...where,
+          tipo: filter.tipo,
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.equipes_trabalho.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('equipes_trabalho', 'nome_equipe', query),
+        ],
+      };
+    }
+
+    const records = await db.equipes_trabalho.findAll({
+      attributes: ['id', 'nome_equipe'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome_equipe', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome_equipe,
+    }));
+  }
+};
--- a/backend/src/db/api/estrutura_projeto.js
+++ b/backend/src/db/api/estrutura_projeto.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 Estrutura_projetoDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const estrutura_projeto = await db.estrutura_projeto.create(
+      {
+        id: data.id || undefined,
+
+        etapa: data.etapa || null,
+        atividade: data.atividade || null,
+        descricao: data.descricao || null,
+        prazo_estimado_dias: data.prazo_estimado_dias || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await estrutura_projeto.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await estrutura_projeto.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return estrutura_projeto;
+  }
+
+  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 estrutura_projetoData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      etapa: item.etapa || null,
+      atividade: item.atividade || null,
+      descricao: item.descricao || null,
+      prazo_estimado_dias: item.prazo_estimado_dias || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const estrutura_projeto = await db.estrutura_projeto.bulkCreate(
+      estrutura_projetoData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return estrutura_projeto;
+  }
+
+  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 estrutura_projeto = await db.estrutura_projeto.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.etapa !== undefined) updatePayload.etapa = data.etapa;
+
+    if (data.atividade !== undefined) updatePayload.atividade = data.atividade;
+
+    if (data.descricao !== undefined) updatePayload.descricao = data.descricao;
+
+    if (data.prazo_estimado_dias !== undefined)
+      updatePayload.prazo_estimado_dias = data.prazo_estimado_dias;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await estrutura_projeto.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await estrutura_projeto.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await estrutura_projeto.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return estrutura_projeto;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const estrutura_projeto = await db.estrutura_projeto.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of estrutura_projeto) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of estrutura_projeto) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return estrutura_projeto;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const estrutura_projeto = await db.estrutura_projeto.findByPk(id, options);
+
+    await estrutura_projeto.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await estrutura_projeto.destroy({
+      transaction,
+    });
+
+    return estrutura_projeto;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const estrutura_projeto = await db.estrutura_projeto.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!estrutura_projeto) {
+      return estrutura_projeto;
+    }
+
+    const output = estrutura_projeto.get({ plain: true });
+
+    output.historico_alteracoes_projeto_estrutura =
+      await estrutura_projeto.getHistorico_alteracoes_projeto_estrutura({
+        transaction,
+      });
+
+    output.maquinas_atividade_estrutura =
+      await estrutura_projeto.getMaquinas_atividade_estrutura({
+        transaction,
+      });
+
+    output.materiais_atividade_estrutura =
+      await estrutura_projeto.getMateriais_atividade_estrutura({
+        transaction,
+      });
+
+    output.pessoas_atividade_estrutura =
+      await estrutura_projeto.getPessoas_atividade_estrutura({
+        transaction,
+      });
+
+    output.obra = await estrutura_projeto.getObra({
+      transaction,
+    });
+
+    output.clientes = await estrutura_projeto.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.etapa) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('estrutura_projeto', 'etapa', filter.etapa),
+        };
+      }
+
+      if (filter.atividade) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'estrutura_projeto',
+            'atividade',
+            filter.atividade,
+          ),
+        };
+      }
+
+      if (filter.descricao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'estrutura_projeto',
+            'descricao',
+            filter.descricao,
+          ),
+        };
+      }
+
+      if (filter.prazo_estimado_diasRange) {
+        const [start, end] = filter.prazo_estimado_diasRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            prazo_estimado_dias: {
+              ...where.prazo_estimado_dias,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            prazo_estimado_dias: {
+              ...where.prazo_estimado_dias,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.estrutura_projeto.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('estrutura_projeto', 'etapa', query),
+        ],
+      };
+    }
+
+    const records = await db.estrutura_projeto.findAll({
+      attributes: ['id', 'etapa'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['etapa', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.etapa,
+    }));
+  }
+};
--- a/backend/src/db/api/etapas_ou_trechos.js
+++ b/backend/src/db/api/etapas_ou_trechos.js
@ -0,0 +1,382 @@
+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 Etapas_ou_trechosDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const etapas_ou_trechos = await db.etapas_ou_trechos.create(
+      {
+        id: data.id || undefined,
+
+        tipo: data.tipo || null,
+        nome: data.nome || null,
+        descricao: data.descricao || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await etapas_ou_trechos.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await etapas_ou_trechos.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return etapas_ou_trechos;
+  }
+
+  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 etapas_ou_trechosData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      tipo: item.tipo || null,
+      nome: item.nome || null,
+      descricao: item.descricao || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const etapas_ou_trechos = await db.etapas_ou_trechos.bulkCreate(
+      etapas_ou_trechosData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return etapas_ou_trechos;
+  }
+
+  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 etapas_ou_trechos = await db.etapas_ou_trechos.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.tipo !== undefined) updatePayload.tipo = data.tipo;
+
+    if (data.nome !== undefined) updatePayload.nome = data.nome;
+
+    if (data.descricao !== undefined) updatePayload.descricao = data.descricao;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await etapas_ou_trechos.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await etapas_ou_trechos.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await etapas_ou_trechos.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return etapas_ou_trechos;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const etapas_ou_trechos = await db.etapas_ou_trechos.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of etapas_ou_trechos) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of etapas_ou_trechos) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return etapas_ou_trechos;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const etapas_ou_trechos = await db.etapas_ou_trechos.findByPk(id, options);
+
+    await etapas_ou_trechos.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await etapas_ou_trechos.destroy({
+      transaction,
+    });
+
+    return etapas_ou_trechos;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const etapas_ou_trechos = await db.etapas_ou_trechos.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!etapas_ou_trechos) {
+      return etapas_ou_trechos;
+    }
+
+    const output = etapas_ou_trechos.get({ plain: true });
+
+    output.obra = await etapas_ou_trechos.getObra({
+      transaction,
+    });
+
+    output.clientes = await etapas_ou_trechos.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.tipo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('etapas_ou_trechos', 'tipo', filter.tipo),
+        };
+      }
+
+      if (filter.nome) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('etapas_ou_trechos', 'nome', filter.nome),
+        };
+      }
+
+      if (filter.descricao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'etapas_ou_trechos',
+            'descricao',
+            filter.descricao,
+          ),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.etapas_ou_trechos.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('etapas_ou_trechos', 'nome', query),
+        ],
+      };
+    }
+
+    const records = await db.etapas_ou_trechos.findAll({
+      attributes: ['id', 'nome'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome,
+    }));
+  }
+};
--- 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/frames_imagem.js
+++ b/backend/src/db/api/frames_imagem.js
@ -0,0 +1,420 @@
+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 Frames_imagemDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const frames_imagem = await db.frames_imagem.create(
+      {
+        id: data.id || undefined,
+
+        origem: data.origem || null,
+        imagem_url: data.imagem_url || null,
+        timestamp_frame: data.timestamp_frame || null,
+        observacoes: data.observacoes || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await frames_imagem.setInspecao(data.inspecao || null, {
+      transaction,
+    });
+
+    await frames_imagem.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return frames_imagem;
+  }
+
+  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 frames_imagemData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      origem: item.origem || null,
+      imagem_url: item.imagem_url || null,
+      timestamp_frame: item.timestamp_frame || null,
+      observacoes: item.observacoes || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const frames_imagem = await db.frames_imagem.bulkCreate(frames_imagemData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return frames_imagem;
+  }
+
+  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 frames_imagem = await db.frames_imagem.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.origem !== undefined) updatePayload.origem = data.origem;
+
+    if (data.imagem_url !== undefined)
+      updatePayload.imagem_url = data.imagem_url;
+
+    if (data.timestamp_frame !== undefined)
+      updatePayload.timestamp_frame = data.timestamp_frame;
+
+    if (data.observacoes !== undefined)
+      updatePayload.observacoes = data.observacoes;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await frames_imagem.update(updatePayload, { transaction });
+
+    if (data.inspecao !== undefined) {
+      await frames_imagem.setInspecao(
+        data.inspecao,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await frames_imagem.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return frames_imagem;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const frames_imagem = await db.frames_imagem.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of frames_imagem) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of frames_imagem) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return frames_imagem;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const frames_imagem = await db.frames_imagem.findByPk(id, options);
+
+    await frames_imagem.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await frames_imagem.destroy({
+      transaction,
+    });
+
+    return frames_imagem;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const frames_imagem = await db.frames_imagem.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!frames_imagem) {
+      return frames_imagem;
+    }
+
+    const output = frames_imagem.get({ plain: true });
+
+    output.pessoas_frame_frame = await frames_imagem.getPessoas_frame_frame({
+      transaction,
+    });
+
+    output.inspecao = await frames_imagem.getInspecao({
+      transaction,
+    });
+
+    output.clientes = await frames_imagem.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.inspecao_aerea,
+        as: 'inspecao',
+
+        where: filter.inspecao
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.inspecao
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  tipo_inspecao: {
+                    [Op.or]: filter.inspecao
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.imagem_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'frames_imagem',
+            'imagem_url',
+            filter.imagem_url,
+          ),
+        };
+      }
+
+      if (filter.observacoes) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'frames_imagem',
+            'observacoes',
+            filter.observacoes,
+          ),
+        };
+      }
+
+      if (filter.timestamp_frameRange) {
+        const [start, end] = filter.timestamp_frameRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            timestamp_frame: {
+              ...where.timestamp_frame,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            timestamp_frame: {
+              ...where.timestamp_frame,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.origem) {
+        where = {
+          ...where,
+          origem: filter.origem,
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.frames_imagem.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('frames_imagem', 'imagem_url', query),
+        ],
+      };
+    }
+
+    const records = await db.frames_imagem.findAll({
+      attributes: ['id', 'imagem_url'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['imagem_url', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.imagem_url,
+    }));
+  }
+};
--- a/backend/src/db/api/gemeos_digitais.js
+++ b/backend/src/db/api/gemeos_digitais.js
@ -0,0 +1,387 @@
+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 Gemeos_digitaisDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const gemeos_digitais = await db.gemeos_digitais.create(
+      {
+        id: data.id || undefined,
+
+        tipo: data.tipo || null,
+        arquivo_url: data.arquivo_url || null,
+        descricao: data.descricao || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await gemeos_digitais.setInspecao(data.inspecao || null, {
+      transaction,
+    });
+
+    await gemeos_digitais.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return gemeos_digitais;
+  }
+
+  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 gemeos_digitaisData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      tipo: item.tipo || null,
+      arquivo_url: item.arquivo_url || null,
+      descricao: item.descricao || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const gemeos_digitais = await db.gemeos_digitais.bulkCreate(
+      gemeos_digitaisData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return gemeos_digitais;
+  }
+
+  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 gemeos_digitais = await db.gemeos_digitais.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.tipo !== undefined) updatePayload.tipo = data.tipo;
+
+    if (data.arquivo_url !== undefined)
+      updatePayload.arquivo_url = data.arquivo_url;
+
+    if (data.descricao !== undefined) updatePayload.descricao = data.descricao;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await gemeos_digitais.update(updatePayload, { transaction });
+
+    if (data.inspecao !== undefined) {
+      await gemeos_digitais.setInspecao(
+        data.inspecao,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await gemeos_digitais.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return gemeos_digitais;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const gemeos_digitais = await db.gemeos_digitais.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of gemeos_digitais) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of gemeos_digitais) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return gemeos_digitais;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const gemeos_digitais = await db.gemeos_digitais.findByPk(id, options);
+
+    await gemeos_digitais.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await gemeos_digitais.destroy({
+      transaction,
+    });
+
+    return gemeos_digitais;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const gemeos_digitais = await db.gemeos_digitais.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!gemeos_digitais) {
+      return gemeos_digitais;
+    }
+
+    const output = gemeos_digitais.get({ plain: true });
+
+    output.inspecao = await gemeos_digitais.getInspecao({
+      transaction,
+    });
+
+    output.clientes = await gemeos_digitais.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.inspecao_aerea,
+        as: 'inspecao',
+
+        where: filter.inspecao
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.inspecao
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  tipo_inspecao: {
+                    [Op.or]: filter.inspecao
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.tipo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('gemeos_digitais', 'tipo', filter.tipo),
+        };
+      }
+
+      if (filter.arquivo_url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'gemeos_digitais',
+            'arquivo_url',
+            filter.arquivo_url,
+          ),
+        };
+      }
+
+      if (filter.descricao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'gemeos_digitais',
+            'descricao',
+            filter.descricao,
+          ),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.gemeos_digitais.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('gemeos_digitais', 'tipo', query),
+        ],
+      };
+    }
+
+    const records = await db.gemeos_digitais.findAll({
+      attributes: ['id', 'tipo'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['tipo', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.tipo,
+    }));
+  }
+};
--- a/backend/src/db/api/historico_alteracoes_projeto.js
+++ b/backend/src/db/api/historico_alteracoes_projeto.js
@ -0,0 +1,468 @@
+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 Historico_alteracoes_projetoDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const historico_alteracoes_projeto =
+      await db.historico_alteracoes_projeto.create(
+        {
+          id: data.id || undefined,
+
+          data_alteracao: data.data_alteracao || null,
+          tipo_alteracao: data.tipo_alteracao || null,
+          descricao_anterior: data.descricao_anterior || null,
+          descricao_nova: data.descricao_nova || null,
+          motivo_alteracao: data.motivo_alteracao || null,
+          responsavel_alteracao: data.responsavel_alteracao || null,
+          comentarios: data.comentarios || null,
+          importHash: data.importHash || null,
+          createdById: currentUser.id,
+          updatedById: currentUser.id,
+        },
+        { transaction },
+      );
+
+    await historico_alteracoes_projeto.setEstrutura(data.estrutura || null, {
+      transaction,
+    });
+
+    await historico_alteracoes_projeto.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return historico_alteracoes_projeto;
+  }
+
+  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 historico_alteracoes_projetoData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      data_alteracao: item.data_alteracao || null,
+      tipo_alteracao: item.tipo_alteracao || null,
+      descricao_anterior: item.descricao_anterior || null,
+      descricao_nova: item.descricao_nova || null,
+      motivo_alteracao: item.motivo_alteracao || null,
+      responsavel_alteracao: item.responsavel_alteracao || null,
+      comentarios: item.comentarios || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const historico_alteracoes_projeto =
+      await db.historico_alteracoes_projeto.bulkCreate(
+        historico_alteracoes_projetoData,
+        { transaction },
+      );
+
+    // For each item created, replace relation files
+
+    return historico_alteracoes_projeto;
+  }
+
+  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 historico_alteracoes_projeto =
+      await db.historico_alteracoes_projeto.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.data_alteracao !== undefined)
+      updatePayload.data_alteracao = data.data_alteracao;
+
+    if (data.tipo_alteracao !== undefined)
+      updatePayload.tipo_alteracao = data.tipo_alteracao;
+
+    if (data.descricao_anterior !== undefined)
+      updatePayload.descricao_anterior = data.descricao_anterior;
+
+    if (data.descricao_nova !== undefined)
+      updatePayload.descricao_nova = data.descricao_nova;
+
+    if (data.motivo_alteracao !== undefined)
+      updatePayload.motivo_alteracao = data.motivo_alteracao;
+
+    if (data.responsavel_alteracao !== undefined)
+      updatePayload.responsavel_alteracao = data.responsavel_alteracao;
+
+    if (data.comentarios !== undefined)
+      updatePayload.comentarios = data.comentarios;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await historico_alteracoes_projeto.update(updatePayload, { transaction });
+
+    if (data.estrutura !== undefined) {
+      await historico_alteracoes_projeto.setEstrutura(
+        data.estrutura,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await historico_alteracoes_projeto.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return historico_alteracoes_projeto;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const historico_alteracoes_projeto =
+      await db.historico_alteracoes_projeto.findAll({
+        where: {
+          id: {
+            [Op.in]: ids,
+          },
+        },
+        transaction,
+      });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of historico_alteracoes_projeto) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of historico_alteracoes_projeto) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return historico_alteracoes_projeto;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const historico_alteracoes_projeto =
+      await db.historico_alteracoes_projeto.findByPk(id, options);
+
+    await historico_alteracoes_projeto.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await historico_alteracoes_projeto.destroy({
+      transaction,
+    });
+
+    return historico_alteracoes_projeto;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const historico_alteracoes_projeto =
+      await db.historico_alteracoes_projeto.findOne({ where }, { transaction });
+
+    if (!historico_alteracoes_projeto) {
+      return historico_alteracoes_projeto;
+    }
+
+    const output = historico_alteracoes_projeto.get({ plain: true });
+
+    output.estrutura = await historico_alteracoes_projeto.getEstrutura({
+      transaction,
+    });
+
+    output.clientes = await historico_alteracoes_projeto.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.estrutura_projeto,
+        as: 'estrutura',
+
+        where: filter.estrutura
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.estrutura
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  etapa: {
+                    [Op.or]: filter.estrutura
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.tipo_alteracao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'historico_alteracoes_projeto',
+            'tipo_alteracao',
+            filter.tipo_alteracao,
+          ),
+        };
+      }
+
+      if (filter.descricao_anterior) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'historico_alteracoes_projeto',
+            'descricao_anterior',
+            filter.descricao_anterior,
+          ),
+        };
+      }
+
+      if (filter.descricao_nova) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'historico_alteracoes_projeto',
+            'descricao_nova',
+            filter.descricao_nova,
+          ),
+        };
+      }
+
+      if (filter.motivo_alteracao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'historico_alteracoes_projeto',
+            'motivo_alteracao',
+            filter.motivo_alteracao,
+          ),
+        };
+      }
+
+      if (filter.responsavel_alteracao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'historico_alteracoes_projeto',
+            'responsavel_alteracao',
+            filter.responsavel_alteracao,
+          ),
+        };
+      }
+
+      if (filter.comentarios) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'historico_alteracoes_projeto',
+            'comentarios',
+            filter.comentarios,
+          ),
+        };
+      }
+
+      if (filter.data_alteracaoRange) {
+        const [start, end] = filter.data_alteracaoRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_alteracao: {
+              ...where.data_alteracao,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_alteracao: {
+              ...where.data_alteracao,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.historico_alteracoes_projeto.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('historico_alteracoes_projeto', 'tipo_alteracao', query),
+        ],
+      };
+    }
+
+    const records = await db.historico_alteracoes_projeto.findAll({
+      attributes: ['id', 'tipo_alteracao'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['tipo_alteracao', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.tipo_alteracao,
+    }));
+  }
+};
--- a/backend/src/db/api/inspecao_aerea.js
+++ b/backend/src/db/api/inspecao_aerea.js
@ -0,0 +1,439 @@
+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 Inspecao_aereaDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const inspecao_aerea = await db.inspecao_aerea.create(
+      {
+        id: data.id || undefined,
+
+        data_inspecao: data.data_inspecao || null,
+        tipo_inspecao: data.tipo_inspecao || null,
+        observacoes: data.observacoes || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await inspecao_aerea.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await inspecao_aerea.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return inspecao_aerea;
+  }
+
+  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 inspecao_aereaData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      data_inspecao: item.data_inspecao || null,
+      tipo_inspecao: item.tipo_inspecao || null,
+      observacoes: item.observacoes || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const inspecao_aerea = await db.inspecao_aerea.bulkCreate(
+      inspecao_aereaData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return inspecao_aerea;
+  }
+
+  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 inspecao_aerea = await db.inspecao_aerea.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.data_inspecao !== undefined)
+      updatePayload.data_inspecao = data.data_inspecao;
+
+    if (data.tipo_inspecao !== undefined)
+      updatePayload.tipo_inspecao = data.tipo_inspecao;
+
+    if (data.observacoes !== undefined)
+      updatePayload.observacoes = data.observacoes;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await inspecao_aerea.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await inspecao_aerea.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await inspecao_aerea.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return inspecao_aerea;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const inspecao_aerea = await db.inspecao_aerea.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of inspecao_aerea) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of inspecao_aerea) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return inspecao_aerea;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const inspecao_aerea = await db.inspecao_aerea.findByPk(id, options);
+
+    await inspecao_aerea.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await inspecao_aerea.destroy({
+      transaction,
+    });
+
+    return inspecao_aerea;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const inspecao_aerea = await db.inspecao_aerea.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!inspecao_aerea) {
+      return inspecao_aerea;
+    }
+
+    const output = inspecao_aerea.get({ plain: true });
+
+    output.frames_imagem_inspecao =
+      await inspecao_aerea.getFrames_imagem_inspecao({
+        transaction,
+      });
+
+    output.gemeos_digitais_inspecao =
+      await inspecao_aerea.getGemeos_digitais_inspecao({
+        transaction,
+      });
+
+    output.relatorios_analiticos_video_inspecao =
+      await inspecao_aerea.getRelatorios_analiticos_video_inspecao({
+        transaction,
+      });
+
+    output.obra = await inspecao_aerea.getObra({
+      transaction,
+    });
+
+    output.clientes = await inspecao_aerea.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.tipo_inspecao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'inspecao_aerea',
+            'tipo_inspecao',
+            filter.tipo_inspecao,
+          ),
+        };
+      }
+
+      if (filter.observacoes) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'inspecao_aerea',
+            'observacoes',
+            filter.observacoes,
+          ),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              data_inspecao: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              data_inspecao: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.data_inspecaoRange) {
+        const [start, end] = filter.data_inspecaoRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_inspecao: {
+              ...where.data_inspecao,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_inspecao: {
+              ...where.data_inspecao,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.inspecao_aerea.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('inspecao_aerea', 'tipo_inspecao', query),
+        ],
+      };
+    }
+
+    const records = await db.inspecao_aerea.findAll({
+      attributes: ['id', 'tipo_inspecao'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['tipo_inspecao', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.tipo_inspecao,
+    }));
+  }
+};
--- a/backend/src/db/api/maquinas_atividade.js
+++ b/backend/src/db/api/maquinas_atividade.js
@ -0,0 +1,423 @@
+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 Maquinas_atividadeDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const maquinas_atividade = await db.maquinas_atividade.create(
+      {
+        id: data.id || undefined,
+
+        quantidade_prevista: data.quantidade_prevista || null,
+        horas_utilizacao_previstas: data.horas_utilizacao_previstas || null,
+        comentarios: data.comentarios || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await maquinas_atividade.setEstrutura(data.estrutura || null, {
+      transaction,
+    });
+
+    await maquinas_atividade.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return maquinas_atividade;
+  }
+
+  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 maquinas_atividadeData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      quantidade_prevista: item.quantidade_prevista || null,
+      horas_utilizacao_previstas: item.horas_utilizacao_previstas || null,
+      comentarios: item.comentarios || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const maquinas_atividade = await db.maquinas_atividade.bulkCreate(
+      maquinas_atividadeData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return maquinas_atividade;
+  }
+
+  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 maquinas_atividade = await db.maquinas_atividade.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.quantidade_prevista !== undefined)
+      updatePayload.quantidade_prevista = data.quantidade_prevista;
+
+    if (data.horas_utilizacao_previstas !== undefined)
+      updatePayload.horas_utilizacao_previstas =
+        data.horas_utilizacao_previstas;
+
+    if (data.comentarios !== undefined)
+      updatePayload.comentarios = data.comentarios;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await maquinas_atividade.update(updatePayload, { transaction });
+
+    if (data.estrutura !== undefined) {
+      await maquinas_atividade.setEstrutura(
+        data.estrutura,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await maquinas_atividade.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return maquinas_atividade;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const maquinas_atividade = await db.maquinas_atividade.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of maquinas_atividade) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of maquinas_atividade) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return maquinas_atividade;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const maquinas_atividade = await db.maquinas_atividade.findByPk(
+      id,
+      options,
+    );
+
+    await maquinas_atividade.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await maquinas_atividade.destroy({
+      transaction,
+    });
+
+    return maquinas_atividade;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const maquinas_atividade = await db.maquinas_atividade.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!maquinas_atividade) {
+      return maquinas_atividade;
+    }
+
+    const output = maquinas_atividade.get({ plain: true });
+
+    output.estrutura = await maquinas_atividade.getEstrutura({
+      transaction,
+    });
+
+    output.clientes = await maquinas_atividade.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.estrutura_projeto,
+        as: 'estrutura',
+
+        where: filter.estrutura
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.estrutura
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  etapa: {
+                    [Op.or]: filter.estrutura
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.comentarios) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'maquinas_atividade',
+            'comentarios',
+            filter.comentarios,
+          ),
+        };
+      }
+
+      if (filter.quantidade_previstaRange) {
+        const [start, end] = filter.quantidade_previstaRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            quantidade_prevista: {
+              ...where.quantidade_prevista,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            quantidade_prevista: {
+              ...where.quantidade_prevista,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.horas_utilizacao_previstasRange) {
+        const [start, end] = filter.horas_utilizacao_previstasRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            horas_utilizacao_previstas: {
+              ...where.horas_utilizacao_previstas,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            horas_utilizacao_previstas: {
+              ...where.horas_utilizacao_previstas,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.maquinas_atividade.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('maquinas_atividade', 'quantidade_prevista', query),
+        ],
+      };
+    }
+
+    const records = await db.maquinas_atividade.findAll({
+      attributes: ['id', 'quantidade_prevista'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['quantidade_prevista', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.quantidade_prevista,
+    }));
+  }
+};
--- a/backend/src/db/api/materiais_atividade.js
+++ b/backend/src/db/api/materiais_atividade.js
@ -0,0 +1,438 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class Materiais_atividadeDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const materiais_atividade = await db.materiais_atividade.create(
+      {
+        id: data.id || undefined,
+
+        quantidade_prevista: data.quantidade_prevista || null,
+        unidade_medida: data.unidade_medida || null,
+        tolerancia_estoque: data.tolerancia_estoque || null,
+        comentarios: data.comentarios || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await materiais_atividade.setEstrutura(data.estrutura || null, {
+      transaction,
+    });
+
+    await materiais_atividade.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return materiais_atividade;
+  }
+
+  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 materiais_atividadeData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      quantidade_prevista: item.quantidade_prevista || null,
+      unidade_medida: item.unidade_medida || null,
+      tolerancia_estoque: item.tolerancia_estoque || null,
+      comentarios: item.comentarios || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const materiais_atividade = await db.materiais_atividade.bulkCreate(
+      materiais_atividadeData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return materiais_atividade;
+  }
+
+  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 materiais_atividade = await db.materiais_atividade.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.quantidade_prevista !== undefined)
+      updatePayload.quantidade_prevista = data.quantidade_prevista;
+
+    if (data.unidade_medida !== undefined)
+      updatePayload.unidade_medida = data.unidade_medida;
+
+    if (data.tolerancia_estoque !== undefined)
+      updatePayload.tolerancia_estoque = data.tolerancia_estoque;
+
+    if (data.comentarios !== undefined)
+      updatePayload.comentarios = data.comentarios;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await materiais_atividade.update(updatePayload, { transaction });
+
+    if (data.estrutura !== undefined) {
+      await materiais_atividade.setEstrutura(
+        data.estrutura,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await materiais_atividade.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return materiais_atividade;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const materiais_atividade = await db.materiais_atividade.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of materiais_atividade) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of materiais_atividade) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return materiais_atividade;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const materiais_atividade = await db.materiais_atividade.findByPk(
+      id,
+      options,
+    );
+
+    await materiais_atividade.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await materiais_atividade.destroy({
+      transaction,
+    });
+
+    return materiais_atividade;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const materiais_atividade = await db.materiais_atividade.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!materiais_atividade) {
+      return materiais_atividade;
+    }
+
+    const output = materiais_atividade.get({ plain: true });
+
+    output.estrutura = await materiais_atividade.getEstrutura({
+      transaction,
+    });
+
+    output.clientes = await materiais_atividade.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.estrutura_projeto,
+        as: 'estrutura',
+
+        where: filter.estrutura
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.estrutura
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  etapa: {
+                    [Op.or]: filter.estrutura
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.unidade_medida) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'materiais_atividade',
+            'unidade_medida',
+            filter.unidade_medida,
+          ),
+        };
+      }
+
+      if (filter.comentarios) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'materiais_atividade',
+            'comentarios',
+            filter.comentarios,
+          ),
+        };
+      }
+
+      if (filter.quantidade_previstaRange) {
+        const [start, end] = filter.quantidade_previstaRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            quantidade_prevista: {
+              ...where.quantidade_prevista,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            quantidade_prevista: {
+              ...where.quantidade_prevista,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.tolerancia_estoqueRange) {
+        const [start, end] = filter.tolerancia_estoqueRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            tolerancia_estoque: {
+              ...where.tolerancia_estoque,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            tolerancia_estoque: {
+              ...where.tolerancia_estoque,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.materiais_atividade.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('materiais_atividade', 'quantidade_prevista', query),
+        ],
+      };
+    }
+
+    const records = await db.materiais_atividade.findAll({
+      attributes: ['id', 'quantidade_prevista'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['quantidade_prevista', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.quantidade_prevista,
+    }));
+  }
+};
--- a/backend/src/db/api/membros_equipe.js
+++ b/backend/src/db/api/membros_equipe.js
@ -0,0 +1,372 @@
+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 Membros_equipeDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const membros_equipe = await db.membros_equipe.create(
+      {
+        id: data.id || undefined,
+
+        nome: data.nome || null,
+        funcao: data.funcao || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await membros_equipe.setEquipe(data.equipe || null, {
+      transaction,
+    });
+
+    await membros_equipe.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return membros_equipe;
+  }
+
+  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 membros_equipeData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      nome: item.nome || null,
+      funcao: item.funcao || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const membros_equipe = await db.membros_equipe.bulkCreate(
+      membros_equipeData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return membros_equipe;
+  }
+
+  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 membros_equipe = await db.membros_equipe.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.nome !== undefined) updatePayload.nome = data.nome;
+
+    if (data.funcao !== undefined) updatePayload.funcao = data.funcao;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await membros_equipe.update(updatePayload, { transaction });
+
+    if (data.equipe !== undefined) {
+      await membros_equipe.setEquipe(
+        data.equipe,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await membros_equipe.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return membros_equipe;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const membros_equipe = await db.membros_equipe.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of membros_equipe) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of membros_equipe) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return membros_equipe;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const membros_equipe = await db.membros_equipe.findByPk(id, options);
+
+    await membros_equipe.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await membros_equipe.destroy({
+      transaction,
+    });
+
+    return membros_equipe;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const membros_equipe = await db.membros_equipe.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!membros_equipe) {
+      return membros_equipe;
+    }
+
+    const output = membros_equipe.get({ plain: true });
+
+    output.pessoas_atividade_membro =
+      await membros_equipe.getPessoas_atividade_membro({
+        transaction,
+      });
+
+    output.equipe = await membros_equipe.getEquipe({
+      transaction,
+    });
+
+    output.clientes = await membros_equipe.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.equipes_trabalho,
+        as: 'equipe',
+
+        where: filter.equipe
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.equipe
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_equipe: {
+                    [Op.or]: filter.equipe
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.nome) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('membros_equipe', 'nome', filter.nome),
+        };
+      }
+
+      if (filter.funcao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('membros_equipe', 'funcao', filter.funcao),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.membros_equipe.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('membros_equipe', 'nome', query),
+        ],
+      };
+    }
+
+    const records = await db.membros_equipe.findAll({
+      attributes: ['id', 'nome'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome,
+    }));
+  }
+};
--- a/backend/src/db/api/memoriais_descritivos_asbuilt.js
+++ b/backend/src/db/api/memoriais_descritivos_asbuilt.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 Memoriais_descritivos_asbuiltDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const memoriais_descritivos_asbuilt =
+      await db.memoriais_descritivos_asbuilt.create(
+        {
+          id: data.id || undefined,
+
+          titulo: data.titulo || null,
+          descricao: data.descricao || null,
+          arquivo_digital: data.arquivo_digital || null,
+          data_entrega: data.data_entrega || null,
+          responsavel_tecnico: data.responsavel_tecnico || null,
+          validado_por_copasa: data.validado_por_copasa || false,
+
+          comentarios_validacao: data.comentarios_validacao || null,
+          importHash: data.importHash || null,
+          createdById: currentUser.id,
+          updatedById: currentUser.id,
+        },
+        { transaction },
+      );
+
+    await memoriais_descritivos_asbuilt.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await memoriais_descritivos_asbuilt.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return memoriais_descritivos_asbuilt;
+  }
+
+  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 memoriais_descritivos_asbuiltData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      titulo: item.titulo || null,
+      descricao: item.descricao || null,
+      arquivo_digital: item.arquivo_digital || null,
+      data_entrega: item.data_entrega || null,
+      responsavel_tecnico: item.responsavel_tecnico || null,
+      validado_por_copasa: item.validado_por_copasa || false,
+
+      comentarios_validacao: item.comentarios_validacao || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const memoriais_descritivos_asbuilt =
+      await db.memoriais_descritivos_asbuilt.bulkCreate(
+        memoriais_descritivos_asbuiltData,
+        { transaction },
+      );
+
+    // For each item created, replace relation files
+
+    return memoriais_descritivos_asbuilt;
+  }
+
+  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 memoriais_descritivos_asbuilt =
+      await db.memoriais_descritivos_asbuilt.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.titulo !== undefined) updatePayload.titulo = data.titulo;
+
+    if (data.descricao !== undefined) updatePayload.descricao = data.descricao;
+
+    if (data.arquivo_digital !== undefined)
+      updatePayload.arquivo_digital = data.arquivo_digital;
+
+    if (data.data_entrega !== undefined)
+      updatePayload.data_entrega = data.data_entrega;
+
+    if (data.responsavel_tecnico !== undefined)
+      updatePayload.responsavel_tecnico = data.responsavel_tecnico;
+
+    if (data.validado_por_copasa !== undefined)
+      updatePayload.validado_por_copasa = data.validado_por_copasa;
+
+    if (data.comentarios_validacao !== undefined)
+      updatePayload.comentarios_validacao = data.comentarios_validacao;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await memoriais_descritivos_asbuilt.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await memoriais_descritivos_asbuilt.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await memoriais_descritivos_asbuilt.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return memoriais_descritivos_asbuilt;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const memoriais_descritivos_asbuilt =
+      await db.memoriais_descritivos_asbuilt.findAll({
+        where: {
+          id: {
+            [Op.in]: ids,
+          },
+        },
+        transaction,
+      });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of memoriais_descritivos_asbuilt) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of memoriais_descritivos_asbuilt) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return memoriais_descritivos_asbuilt;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const memoriais_descritivos_asbuilt =
+      await db.memoriais_descritivos_asbuilt.findByPk(id, options);
+
+    await memoriais_descritivos_asbuilt.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await memoriais_descritivos_asbuilt.destroy({
+      transaction,
+    });
+
+    return memoriais_descritivos_asbuilt;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const memoriais_descritivos_asbuilt =
+      await db.memoriais_descritivos_asbuilt.findOne(
+        { where },
+        { transaction },
+      );
+
+    if (!memoriais_descritivos_asbuilt) {
+      return memoriais_descritivos_asbuilt;
+    }
+
+    const output = memoriais_descritivos_asbuilt.get({ plain: true });
+
+    output.obra = await memoriais_descritivos_asbuilt.getObra({
+      transaction,
+    });
+
+    output.clientes = await memoriais_descritivos_asbuilt.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.titulo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'memoriais_descritivos_asbuilt',
+            'titulo',
+            filter.titulo,
+          ),
+        };
+      }
+
+      if (filter.descricao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'memoriais_descritivos_asbuilt',
+            'descricao',
+            filter.descricao,
+          ),
+        };
+      }
+
+      if (filter.arquivo_digital) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'memoriais_descritivos_asbuilt',
+            'arquivo_digital',
+            filter.arquivo_digital,
+          ),
+        };
+      }
+
+      if (filter.responsavel_tecnico) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'memoriais_descritivos_asbuilt',
+            'responsavel_tecnico',
+            filter.responsavel_tecnico,
+          ),
+        };
+      }
+
+      if (filter.comentarios_validacao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'memoriais_descritivos_asbuilt',
+            'comentarios_validacao',
+            filter.comentarios_validacao,
+          ),
+        };
+      }
+
+      if (filter.data_entregaRange) {
+        const [start, end] = filter.data_entregaRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_entrega: {
+              ...where.data_entrega,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_entrega: {
+              ...where.data_entrega,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.validado_por_copasa) {
+        where = {
+          ...where,
+          validado_por_copasa: filter.validado_por_copasa,
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.memoriais_descritivos_asbuilt.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('memoriais_descritivos_asbuilt', 'titulo', query),
+        ],
+      };
+    }
+
+    const records = await db.memoriais_descritivos_asbuilt.findAll({
+      attributes: ['id', 'titulo'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['titulo', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.titulo,
+    }));
+  }
+};
--- a/backend/src/db/api/modelos_bim_asbuilt.js
+++ b/backend/src/db/api/modelos_bim_asbuilt.js
@ -0,0 +1,520 @@
+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 Modelos_bim_asbuiltDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const modelos_bim_asbuilt = await db.modelos_bim_asbuilt.create(
+      {
+        id: data.id || undefined,
+
+        nome_modelo: data.nome_modelo || null,
+        descricao: data.descricao || null,
+        arquivo_modelo: data.arquivo_modelo || null,
+        formato: data.formato || null,
+        plataforma_origem: data.plataforma_origem || null,
+        data_modelagem: data.data_modelagem || null,
+        responsavel_modelagem: data.responsavel_modelagem || null,
+        nivel_detalhamento: data.nivel_detalhamento || null,
+        coordenacao_com_outros_modelos:
+          data.coordenacao_com_outros_modelos || false,
+
+        comentarios: data.comentarios || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await modelos_bim_asbuilt.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await modelos_bim_asbuilt.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return modelos_bim_asbuilt;
+  }
+
+  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 modelos_bim_asbuiltData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      nome_modelo: item.nome_modelo || null,
+      descricao: item.descricao || null,
+      arquivo_modelo: item.arquivo_modelo || null,
+      formato: item.formato || null,
+      plataforma_origem: item.plataforma_origem || null,
+      data_modelagem: item.data_modelagem || null,
+      responsavel_modelagem: item.responsavel_modelagem || null,
+      nivel_detalhamento: item.nivel_detalhamento || null,
+      coordenacao_com_outros_modelos:
+        item.coordenacao_com_outros_modelos || false,
+
+      comentarios: item.comentarios || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const modelos_bim_asbuilt = await db.modelos_bim_asbuilt.bulkCreate(
+      modelos_bim_asbuiltData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return modelos_bim_asbuilt;
+  }
+
+  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 modelos_bim_asbuilt = await db.modelos_bim_asbuilt.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.nome_modelo !== undefined)
+      updatePayload.nome_modelo = data.nome_modelo;
+
+    if (data.descricao !== undefined) updatePayload.descricao = data.descricao;
+
+    if (data.arquivo_modelo !== undefined)
+      updatePayload.arquivo_modelo = data.arquivo_modelo;
+
+    if (data.formato !== undefined) updatePayload.formato = data.formato;
+
+    if (data.plataforma_origem !== undefined)
+      updatePayload.plataforma_origem = data.plataforma_origem;
+
+    if (data.data_modelagem !== undefined)
+      updatePayload.data_modelagem = data.data_modelagem;
+
+    if (data.responsavel_modelagem !== undefined)
+      updatePayload.responsavel_modelagem = data.responsavel_modelagem;
+
+    if (data.nivel_detalhamento !== undefined)
+      updatePayload.nivel_detalhamento = data.nivel_detalhamento;
+
+    if (data.coordenacao_com_outros_modelos !== undefined)
+      updatePayload.coordenacao_com_outros_modelos =
+        data.coordenacao_com_outros_modelos;
+
+    if (data.comentarios !== undefined)
+      updatePayload.comentarios = data.comentarios;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await modelos_bim_asbuilt.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await modelos_bim_asbuilt.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await modelos_bim_asbuilt.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return modelos_bim_asbuilt;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const modelos_bim_asbuilt = await db.modelos_bim_asbuilt.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of modelos_bim_asbuilt) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of modelos_bim_asbuilt) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return modelos_bim_asbuilt;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const modelos_bim_asbuilt = await db.modelos_bim_asbuilt.findByPk(
+      id,
+      options,
+    );
+
+    await modelos_bim_asbuilt.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await modelos_bim_asbuilt.destroy({
+      transaction,
+    });
+
+    return modelos_bim_asbuilt;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const modelos_bim_asbuilt = await db.modelos_bim_asbuilt.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!modelos_bim_asbuilt) {
+      return modelos_bim_asbuilt;
+    }
+
+    const output = modelos_bim_asbuilt.get({ plain: true });
+
+    output.obra = await modelos_bim_asbuilt.getObra({
+      transaction,
+    });
+
+    output.clientes = await modelos_bim_asbuilt.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.nome_modelo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'modelos_bim_asbuilt',
+            'nome_modelo',
+            filter.nome_modelo,
+          ),
+        };
+      }
+
+      if (filter.descricao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'modelos_bim_asbuilt',
+            'descricao',
+            filter.descricao,
+          ),
+        };
+      }
+
+      if (filter.arquivo_modelo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'modelos_bim_asbuilt',
+            'arquivo_modelo',
+            filter.arquivo_modelo,
+          ),
+        };
+      }
+
+      if (filter.formato) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'modelos_bim_asbuilt',
+            'formato',
+            filter.formato,
+          ),
+        };
+      }
+
+      if (filter.plataforma_origem) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'modelos_bim_asbuilt',
+            'plataforma_origem',
+            filter.plataforma_origem,
+          ),
+        };
+      }
+
+      if (filter.responsavel_modelagem) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'modelos_bim_asbuilt',
+            'responsavel_modelagem',
+            filter.responsavel_modelagem,
+          ),
+        };
+      }
+
+      if (filter.nivel_detalhamento) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'modelos_bim_asbuilt',
+            'nivel_detalhamento',
+            filter.nivel_detalhamento,
+          ),
+        };
+      }
+
+      if (filter.comentarios) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'modelos_bim_asbuilt',
+            'comentarios',
+            filter.comentarios,
+          ),
+        };
+      }
+
+      if (filter.data_modelagemRange) {
+        const [start, end] = filter.data_modelagemRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_modelagem: {
+              ...where.data_modelagem,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_modelagem: {
+              ...where.data_modelagem,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.coordenacao_com_outros_modelos) {
+        where = {
+          ...where,
+          coordenacao_com_outros_modelos: filter.coordenacao_com_outros_modelos,
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.modelos_bim_asbuilt.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('modelos_bim_asbuilt', 'nome_modelo', query),
+        ],
+      };
+    }
+
+    const records = await db.modelos_bim_asbuilt.findAll({
+      attributes: ['id', 'nome_modelo'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome_modelo', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome_modelo,
+    }));
+  }
+};
--- a/backend/src/db/api/obras.js
+++ b/backend/src/db/api/obras.js
@ -0,0 +1,509 @@
+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 ObrasDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const obras = await db.obras.create(
+      {
+        id: data.id || undefined,
+
+        nome_obra: data.nome_obra || null,
+        cidade: data.cidade || null,
+        estado: data.estado || null,
+        descricao: data.descricao || null,
+        data_inicio: data.data_inicio || null,
+        data_previsao_termino: data.data_previsao_termino || null,
+        plantas_2d_georreferenciadas:
+          data.plantas_2d_georreferenciadas || false,
+
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await obras.setCliente(data.cliente || null, {
+      transaction,
+    });
+
+    await obras.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return obras;
+  }
+
+  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 obrasData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      nome_obra: item.nome_obra || null,
+      cidade: item.cidade || null,
+      estado: item.estado || null,
+      descricao: item.descricao || null,
+      data_inicio: item.data_inicio || null,
+      data_previsao_termino: item.data_previsao_termino || null,
+      plantas_2d_georreferenciadas: item.plantas_2d_georreferenciadas || false,
+
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const obras = await db.obras.bulkCreate(obrasData, { transaction });
+
+    // For each item created, replace relation files
+
+    return obras;
+  }
+
+  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 obras = await db.obras.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.nome_obra !== undefined) updatePayload.nome_obra = data.nome_obra;
+
+    if (data.cidade !== undefined) updatePayload.cidade = data.cidade;
+
+    if (data.estado !== undefined) updatePayload.estado = data.estado;
+
+    if (data.descricao !== undefined) updatePayload.descricao = data.descricao;
+
+    if (data.data_inicio !== undefined)
+      updatePayload.data_inicio = data.data_inicio;
+
+    if (data.data_previsao_termino !== undefined)
+      updatePayload.data_previsao_termino = data.data_previsao_termino;
+
+    if (data.plantas_2d_georreferenciadas !== undefined)
+      updatePayload.plantas_2d_georreferenciadas =
+        data.plantas_2d_georreferenciadas;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await obras.update(updatePayload, { transaction });
+
+    if (data.cliente !== undefined) {
+      await obras.setCliente(
+        data.cliente,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await obras.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return obras;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const obras = await db.obras.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of obras) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of obras) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return obras;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const obras = await db.obras.findByPk(id, options);
+
+    await obras.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await obras.destroy({
+      transaction,
+    });
+
+    return obras;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const obras = await db.obras.findOne({ where }, { transaction });
+
+    if (!obras) {
+      return obras;
+    }
+
+    const output = obras.get({ plain: true });
+
+    output.cameras_ptz_obra = await obras.getCameras_ptz_obra({
+      transaction,
+    });
+
+    output.equipes_trabalho_obra = await obras.getEquipes_trabalho_obra({
+      transaction,
+    });
+
+    output.estrutura_projeto_obra = await obras.getEstrutura_projeto_obra({
+      transaction,
+    });
+
+    output.etapas_ou_trechos_obra = await obras.getEtapas_ou_trechos_obra({
+      transaction,
+    });
+
+    output.inspecao_aerea_obra = await obras.getInspecao_aerea_obra({
+      transaction,
+    });
+
+    output.memoriais_descritivos_asbuilt_obra =
+      await obras.getMemoriais_descritivos_asbuilt_obra({
+        transaction,
+      });
+
+    output.modelos_bim_asbuilt_obra = await obras.getModelos_bim_asbuilt_obra({
+      transaction,
+    });
+
+    output.plantas_asbuilt_2d_obra = await obras.getPlantas_asbuilt_2d_obra({
+      transaction,
+    });
+
+    output.relatorio_andamento_atual_obra =
+      await obras.getRelatorio_andamento_atual_obra({
+        transaction,
+      });
+
+    output.relatorios_diarios_obra = await obras.getRelatorios_diarios_obra({
+      transaction,
+    });
+
+    output.relatorios_mensais_obra = await obras.getRelatorios_mensais_obra({
+      transaction,
+    });
+
+    output.relatorios_semanais_obra = await obras.getRelatorios_semanais_obra({
+      transaction,
+    });
+
+    output.cliente = await obras.getCliente({
+      transaction,
+    });
+
+    output.clientes = await obras.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.clientes,
+        as: 'cliente',
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.nome_obra) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('obras', 'nome_obra', filter.nome_obra),
+        };
+      }
+
+      if (filter.cidade) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('obras', 'cidade', filter.cidade),
+        };
+      }
+
+      if (filter.estado) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('obras', 'estado', filter.estado),
+        };
+      }
+
+      if (filter.descricao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('obras', 'descricao', filter.descricao),
+        };
+      }
+
+      if (filter.calendarStart && filter.calendarEnd) {
+        where = {
+          ...where,
+          [Op.or]: [
+            {
+              data_inicio: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+            {
+              data_previsao_termino: {
+                [Op.between]: [filter.calendarStart, filter.calendarEnd],
+              },
+            },
+          ],
+        };
+      }
+
+      if (filter.data_inicioRange) {
+        const [start, end] = filter.data_inicioRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_inicio: {
+              ...where.data_inicio,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_inicio: {
+              ...where.data_inicio,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.data_previsao_terminoRange) {
+        const [start, end] = filter.data_previsao_terminoRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_previsao_termino: {
+              ...where.data_previsao_termino,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_previsao_termino: {
+              ...where.data_previsao_termino,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.plantas_2d_georreferenciadas) {
+        where = {
+          ...where,
+          plantas_2d_georreferenciadas: filter.plantas_2d_georreferenciadas,
+        };
+      }
+
+      if (filter.cliente) {
+        const listItems = filter.cliente.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clienteId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.obras.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('obras', 'nome_obra', query),
+        ],
+      };
+    }
+
+    const records = await db.obras.findAll({
+      attributes: ['id', 'nome_obra'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome_obra', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome_obra,
+    }));
+  }
+};
--- 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 userClientes = (user && user.clientes?.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/permissoes_modulo.js
+++ b/backend/src/db/api/permissoes_modulo.js
@ -0,0 +1,395 @@
+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 Permissoes_moduloDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const permissoes_modulo = await db.permissoes_modulo.create(
+      {
+        id: data.id || undefined,
+
+        modulo: data.modulo || null,
+        leitura: data.leitura || false,
+
+        escrita: data.escrita || false,
+
+        aprovacao: data.aprovacao || false,
+
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await permissoes_modulo.setRole(data.role || null, {
+      transaction,
+    });
+
+    await permissoes_modulo.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return permissoes_modulo;
+  }
+
+  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 permissoes_moduloData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      modulo: item.modulo || null,
+      leitura: item.leitura || false,
+
+      escrita: item.escrita || false,
+
+      aprovacao: item.aprovacao || false,
+
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const permissoes_modulo = await db.permissoes_modulo.bulkCreate(
+      permissoes_moduloData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return permissoes_modulo;
+  }
+
+  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 permissoes_modulo = await db.permissoes_modulo.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.modulo !== undefined) updatePayload.modulo = data.modulo;
+
+    if (data.leitura !== undefined) updatePayload.leitura = data.leitura;
+
+    if (data.escrita !== undefined) updatePayload.escrita = data.escrita;
+
+    if (data.aprovacao !== undefined) updatePayload.aprovacao = data.aprovacao;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await permissoes_modulo.update(updatePayload, { transaction });
+
+    if (data.role !== undefined) {
+      await permissoes_modulo.setRole(
+        data.role,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await permissoes_modulo.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return permissoes_modulo;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const permissoes_modulo = await db.permissoes_modulo.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of permissoes_modulo) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of permissoes_modulo) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return permissoes_modulo;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const permissoes_modulo = await db.permissoes_modulo.findByPk(id, options);
+
+    await permissoes_modulo.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await permissoes_modulo.destroy({
+      transaction,
+    });
+
+    return permissoes_modulo;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const permissoes_modulo = await db.permissoes_modulo.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!permissoes_modulo) {
+      return permissoes_modulo;
+    }
+
+    const output = permissoes_modulo.get({ plain: true });
+
+    output.role = await permissoes_modulo.getRole({
+      transaction,
+    });
+
+    output.clientes = await permissoes_modulo.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.roles,
+        as: 'role',
+
+        where: filter.role
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.role
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.role
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.modulo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('permissoes_modulo', 'modulo', filter.modulo),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.leitura) {
+        where = {
+          ...where,
+          leitura: filter.leitura,
+        };
+      }
+
+      if (filter.escrita) {
+        where = {
+          ...where,
+          escrita: filter.escrita,
+        };
+      }
+
+      if (filter.aprovacao) {
+        where = {
+          ...where,
+          aprovacao: filter.aprovacao,
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.permissoes_modulo.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('permissoes_modulo', 'modulo', query),
+        ],
+      };
+    }
+
+    const records = await db.permissoes_modulo.findAll({
+      attributes: ['id', 'modulo'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['modulo', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.modulo,
+    }));
+  }
+};
--- a/backend/src/db/api/pessoas_atividade.js
+++ b/backend/src/db/api/pessoas_atividade.js
@ -0,0 +1,448 @@
+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 Pessoas_atividadeDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const pessoas_atividade = await db.pessoas_atividade.create(
+      {
+        id: data.id || undefined,
+
+        funcao_na_atividade: data.funcao_na_atividade || null,
+        horas_previstas: data.horas_previstas || null,
+        comentarios: data.comentarios || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await pessoas_atividade.setEstrutura(data.estrutura || null, {
+      transaction,
+    });
+
+    await pessoas_atividade.setMembro(data.membro || null, {
+      transaction,
+    });
+
+    await pessoas_atividade.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return pessoas_atividade;
+  }
+
+  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 pessoas_atividadeData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      funcao_na_atividade: item.funcao_na_atividade || null,
+      horas_previstas: item.horas_previstas || null,
+      comentarios: item.comentarios || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const pessoas_atividade = await db.pessoas_atividade.bulkCreate(
+      pessoas_atividadeData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return pessoas_atividade;
+  }
+
+  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 pessoas_atividade = await db.pessoas_atividade.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.funcao_na_atividade !== undefined)
+      updatePayload.funcao_na_atividade = data.funcao_na_atividade;
+
+    if (data.horas_previstas !== undefined)
+      updatePayload.horas_previstas = data.horas_previstas;
+
+    if (data.comentarios !== undefined)
+      updatePayload.comentarios = data.comentarios;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await pessoas_atividade.update(updatePayload, { transaction });
+
+    if (data.estrutura !== undefined) {
+      await pessoas_atividade.setEstrutura(
+        data.estrutura,
+
+        { transaction },
+      );
+    }
+
+    if (data.membro !== undefined) {
+      await pessoas_atividade.setMembro(
+        data.membro,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await pessoas_atividade.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return pessoas_atividade;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const pessoas_atividade = await db.pessoas_atividade.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of pessoas_atividade) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of pessoas_atividade) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return pessoas_atividade;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const pessoas_atividade = await db.pessoas_atividade.findByPk(id, options);
+
+    await pessoas_atividade.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await pessoas_atividade.destroy({
+      transaction,
+    });
+
+    return pessoas_atividade;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const pessoas_atividade = await db.pessoas_atividade.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!pessoas_atividade) {
+      return pessoas_atividade;
+    }
+
+    const output = pessoas_atividade.get({ plain: true });
+
+    output.estrutura = await pessoas_atividade.getEstrutura({
+      transaction,
+    });
+
+    output.membro = await pessoas_atividade.getMembro({
+      transaction,
+    });
+
+    output.clientes = await pessoas_atividade.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.estrutura_projeto,
+        as: 'estrutura',
+
+        where: filter.estrutura
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.estrutura
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  etapa: {
+                    [Op.or]: filter.estrutura
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.membros_equipe,
+        as: 'membro',
+
+        where: filter.membro
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.membro
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome: {
+                    [Op.or]: filter.membro
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.funcao_na_atividade) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'pessoas_atividade',
+            'funcao_na_atividade',
+            filter.funcao_na_atividade,
+          ),
+        };
+      }
+
+      if (filter.comentarios) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'pessoas_atividade',
+            'comentarios',
+            filter.comentarios,
+          ),
+        };
+      }
+
+      if (filter.horas_previstasRange) {
+        const [start, end] = filter.horas_previstasRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            horas_previstas: {
+              ...where.horas_previstas,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            horas_previstas: {
+              ...where.horas_previstas,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.pessoas_atividade.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('pessoas_atividade', 'funcao_na_atividade', query),
+        ],
+      };
+    }
+
+    const records = await db.pessoas_atividade.findAll({
+      attributes: ['id', 'funcao_na_atividade'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['funcao_na_atividade', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.funcao_na_atividade,
+    }));
+  }
+};
--- a/backend/src/db/api/pessoas_frame.js
+++ b/backend/src/db/api/pessoas_frame.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 Pessoas_frameDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const pessoas_frame = await db.pessoas_frame.create(
+      {
+        id: data.id || undefined,
+
+        atividade: data.atividade || null,
+        posicao_aproximada: data.posicao_aproximada || null,
+        epi_visiveis: data.epi_visiveis || null,
+        foco_no_trabalho: data.foco_no_trabalho || false,
+
+        operando_maquina: data.operando_maquina || false,
+
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await pessoas_frame.setFrame(data.frame || null, {
+      transaction,
+    });
+
+    await pessoas_frame.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return pessoas_frame;
+  }
+
+  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 pessoas_frameData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      atividade: item.atividade || null,
+      posicao_aproximada: item.posicao_aproximada || null,
+      epi_visiveis: item.epi_visiveis || null,
+      foco_no_trabalho: item.foco_no_trabalho || false,
+
+      operando_maquina: item.operando_maquina || false,
+
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const pessoas_frame = await db.pessoas_frame.bulkCreate(pessoas_frameData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return pessoas_frame;
+  }
+
+  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 pessoas_frame = await db.pessoas_frame.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.atividade !== undefined) updatePayload.atividade = data.atividade;
+
+    if (data.posicao_aproximada !== undefined)
+      updatePayload.posicao_aproximada = data.posicao_aproximada;
+
+    if (data.epi_visiveis !== undefined)
+      updatePayload.epi_visiveis = data.epi_visiveis;
+
+    if (data.foco_no_trabalho !== undefined)
+      updatePayload.foco_no_trabalho = data.foco_no_trabalho;
+
+    if (data.operando_maquina !== undefined)
+      updatePayload.operando_maquina = data.operando_maquina;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await pessoas_frame.update(updatePayload, { transaction });
+
+    if (data.frame !== undefined) {
+      await pessoas_frame.setFrame(
+        data.frame,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await pessoas_frame.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return pessoas_frame;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const pessoas_frame = await db.pessoas_frame.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of pessoas_frame) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of pessoas_frame) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return pessoas_frame;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const pessoas_frame = await db.pessoas_frame.findByPk(id, options);
+
+    await pessoas_frame.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await pessoas_frame.destroy({
+      transaction,
+    });
+
+    return pessoas_frame;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const pessoas_frame = await db.pessoas_frame.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!pessoas_frame) {
+      return pessoas_frame;
+    }
+
+    const output = pessoas_frame.get({ plain: true });
+
+    output.frame = await pessoas_frame.getFrame({
+      transaction,
+    });
+
+    output.clientes = await pessoas_frame.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.frames_imagem,
+        as: 'frame',
+
+        where: filter.frame
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.frame
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  imagem_url: {
+                    [Op.or]: filter.frame
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.atividade) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('pessoas_frame', 'atividade', filter.atividade),
+        };
+      }
+
+      if (filter.posicao_aproximada) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'pessoas_frame',
+            'posicao_aproximada',
+            filter.posicao_aproximada,
+          ),
+        };
+      }
+
+      if (filter.epi_visiveis) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'pessoas_frame',
+            'epi_visiveis',
+            filter.epi_visiveis,
+          ),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.foco_no_trabalho) {
+        where = {
+          ...where,
+          foco_no_trabalho: filter.foco_no_trabalho,
+        };
+      }
+
+      if (filter.operando_maquina) {
+        where = {
+          ...where,
+          operando_maquina: filter.operando_maquina,
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.pessoas_frame.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('pessoas_frame', 'atividade', query),
+        ],
+      };
+    }
+
+    const records = await db.pessoas_frame.findAll({
+      attributes: ['id', 'atividade'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['atividade', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.atividade,
+    }));
+  }
+};
--- a/backend/src/db/api/plantas_asbuilt_2d.js
+++ b/backend/src/db/api/plantas_asbuilt_2d.js
@ -0,0 +1,501 @@
+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 Plantas_asbuilt_2dDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const plantas_asbuilt_2d = await db.plantas_asbuilt_2d.create(
+      {
+        id: data.id || undefined,
+
+        nome_planta: data.nome_planta || null,
+        descricao: data.descricao || null,
+        arquivo_digital: data.arquivo_digital || null,
+        formato: data.formato || null,
+        data_criacao: data.data_criacao || null,
+        responsavel_tecnico: data.responsavel_tecnico || null,
+        georreferenciada: data.georreferenciada || false,
+
+        sistema_referencia: data.sistema_referencia || null,
+        comentarios: data.comentarios || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await plantas_asbuilt_2d.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await plantas_asbuilt_2d.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return plantas_asbuilt_2d;
+  }
+
+  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 plantas_asbuilt_2dData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      nome_planta: item.nome_planta || null,
+      descricao: item.descricao || null,
+      arquivo_digital: item.arquivo_digital || null,
+      formato: item.formato || null,
+      data_criacao: item.data_criacao || null,
+      responsavel_tecnico: item.responsavel_tecnico || null,
+      georreferenciada: item.georreferenciada || false,
+
+      sistema_referencia: item.sistema_referencia || null,
+      comentarios: item.comentarios || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const plantas_asbuilt_2d = await db.plantas_asbuilt_2d.bulkCreate(
+      plantas_asbuilt_2dData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return plantas_asbuilt_2d;
+  }
+
+  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 plantas_asbuilt_2d = await db.plantas_asbuilt_2d.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.nome_planta !== undefined)
+      updatePayload.nome_planta = data.nome_planta;
+
+    if (data.descricao !== undefined) updatePayload.descricao = data.descricao;
+
+    if (data.arquivo_digital !== undefined)
+      updatePayload.arquivo_digital = data.arquivo_digital;
+
+    if (data.formato !== undefined) updatePayload.formato = data.formato;
+
+    if (data.data_criacao !== undefined)
+      updatePayload.data_criacao = data.data_criacao;
+
+    if (data.responsavel_tecnico !== undefined)
+      updatePayload.responsavel_tecnico = data.responsavel_tecnico;
+
+    if (data.georreferenciada !== undefined)
+      updatePayload.georreferenciada = data.georreferenciada;
+
+    if (data.sistema_referencia !== undefined)
+      updatePayload.sistema_referencia = data.sistema_referencia;
+
+    if (data.comentarios !== undefined)
+      updatePayload.comentarios = data.comentarios;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await plantas_asbuilt_2d.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await plantas_asbuilt_2d.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await plantas_asbuilt_2d.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return plantas_asbuilt_2d;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const plantas_asbuilt_2d = await db.plantas_asbuilt_2d.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of plantas_asbuilt_2d) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of plantas_asbuilt_2d) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return plantas_asbuilt_2d;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const plantas_asbuilt_2d = await db.plantas_asbuilt_2d.findByPk(
+      id,
+      options,
+    );
+
+    await plantas_asbuilt_2d.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await plantas_asbuilt_2d.destroy({
+      transaction,
+    });
+
+    return plantas_asbuilt_2d;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const plantas_asbuilt_2d = await db.plantas_asbuilt_2d.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!plantas_asbuilt_2d) {
+      return plantas_asbuilt_2d;
+    }
+
+    const output = plantas_asbuilt_2d.get({ plain: true });
+
+    output.obra = await plantas_asbuilt_2d.getObra({
+      transaction,
+    });
+
+    output.clientes = await plantas_asbuilt_2d.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.nome_planta) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'plantas_asbuilt_2d',
+            'nome_planta',
+            filter.nome_planta,
+          ),
+        };
+      }
+
+      if (filter.descricao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'plantas_asbuilt_2d',
+            'descricao',
+            filter.descricao,
+          ),
+        };
+      }
+
+      if (filter.arquivo_digital) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'plantas_asbuilt_2d',
+            'arquivo_digital',
+            filter.arquivo_digital,
+          ),
+        };
+      }
+
+      if (filter.formato) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'plantas_asbuilt_2d',
+            'formato',
+            filter.formato,
+          ),
+        };
+      }
+
+      if (filter.responsavel_tecnico) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'plantas_asbuilt_2d',
+            'responsavel_tecnico',
+            filter.responsavel_tecnico,
+          ),
+        };
+      }
+
+      if (filter.sistema_referencia) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'plantas_asbuilt_2d',
+            'sistema_referencia',
+            filter.sistema_referencia,
+          ),
+        };
+      }
+
+      if (filter.comentarios) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'plantas_asbuilt_2d',
+            'comentarios',
+            filter.comentarios,
+          ),
+        };
+      }
+
+      if (filter.data_criacaoRange) {
+        const [start, end] = filter.data_criacaoRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_criacao: {
+              ...where.data_criacao,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_criacao: {
+              ...where.data_criacao,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.georreferenciada) {
+        where = {
+          ...where,
+          georreferenciada: filter.georreferenciada,
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.plantas_asbuilt_2d.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('plantas_asbuilt_2d', 'nome_planta', query),
+        ],
+      };
+    }
+
+    const records = await db.plantas_asbuilt_2d.findAll({
+      attributes: ['id', 'nome_planta'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome_planta', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome_planta,
+    }));
+  }
+};
--- a/backend/src/db/api/relatorio_andamento_atual.js
+++ b/backend/src/db/api/relatorio_andamento_atual.js
@ -0,0 +1,545 @@
+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 Relatorio_andamento_atualDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorio_andamento_atual = await db.relatorio_andamento_atual.create(
+      {
+        id: data.id || undefined,
+
+        data_ultima_atualizacao: data.data_ultima_atualizacao || null,
+        status_obra: data.status_obra || null,
+        percentual_execucao_total: data.percentual_execucao_total || null,
+        atividade_atual_predominante: data.atividade_atual_predominante || null,
+        riscos_em_aberto: data.riscos_em_aberto || null,
+        tempo_estimado_para_conclusao:
+          data.tempo_estimado_para_conclusao || null,
+        grau_conformidade_geral: data.grau_conformidade_geral || null,
+        observacoes_finais: data.observacoes_finais || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await relatorio_andamento_atual.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await relatorio_andamento_atual.setUltimo_relatorio_video(
+      data.ultimo_relatorio_video || null,
+      {
+        transaction,
+      },
+    );
+
+    await relatorio_andamento_atual.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return relatorio_andamento_atual;
+  }
+
+  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 relatorio_andamento_atualData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      data_ultima_atualizacao: item.data_ultima_atualizacao || null,
+      status_obra: item.status_obra || null,
+      percentual_execucao_total: item.percentual_execucao_total || null,
+      atividade_atual_predominante: item.atividade_atual_predominante || null,
+      riscos_em_aberto: item.riscos_em_aberto || null,
+      tempo_estimado_para_conclusao: item.tempo_estimado_para_conclusao || null,
+      grau_conformidade_geral: item.grau_conformidade_geral || null,
+      observacoes_finais: item.observacoes_finais || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const relatorio_andamento_atual =
+      await db.relatorio_andamento_atual.bulkCreate(
+        relatorio_andamento_atualData,
+        { transaction },
+      );
+
+    // For each item created, replace relation files
+
+    return relatorio_andamento_atual;
+  }
+
+  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 relatorio_andamento_atual =
+      await db.relatorio_andamento_atual.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.data_ultima_atualizacao !== undefined)
+      updatePayload.data_ultima_atualizacao = data.data_ultima_atualizacao;
+
+    if (data.status_obra !== undefined)
+      updatePayload.status_obra = data.status_obra;
+
+    if (data.percentual_execucao_total !== undefined)
+      updatePayload.percentual_execucao_total = data.percentual_execucao_total;
+
+    if (data.atividade_atual_predominante !== undefined)
+      updatePayload.atividade_atual_predominante =
+        data.atividade_atual_predominante;
+
+    if (data.riscos_em_aberto !== undefined)
+      updatePayload.riscos_em_aberto = data.riscos_em_aberto;
+
+    if (data.tempo_estimado_para_conclusao !== undefined)
+      updatePayload.tempo_estimado_para_conclusao =
+        data.tempo_estimado_para_conclusao;
+
+    if (data.grau_conformidade_geral !== undefined)
+      updatePayload.grau_conformidade_geral = data.grau_conformidade_geral;
+
+    if (data.observacoes_finais !== undefined)
+      updatePayload.observacoes_finais = data.observacoes_finais;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await relatorio_andamento_atual.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await relatorio_andamento_atual.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.ultimo_relatorio_video !== undefined) {
+      await relatorio_andamento_atual.setUltimo_relatorio_video(
+        data.ultimo_relatorio_video,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await relatorio_andamento_atual.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return relatorio_andamento_atual;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorio_andamento_atual =
+      await db.relatorio_andamento_atual.findAll({
+        where: {
+          id: {
+            [Op.in]: ids,
+          },
+        },
+        transaction,
+      });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of relatorio_andamento_atual) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of relatorio_andamento_atual) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return relatorio_andamento_atual;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorio_andamento_atual =
+      await db.relatorio_andamento_atual.findByPk(id, options);
+
+    await relatorio_andamento_atual.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await relatorio_andamento_atual.destroy({
+      transaction,
+    });
+
+    return relatorio_andamento_atual;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorio_andamento_atual =
+      await db.relatorio_andamento_atual.findOne({ where }, { transaction });
+
+    if (!relatorio_andamento_atual) {
+      return relatorio_andamento_atual;
+    }
+
+    const output = relatorio_andamento_atual.get({ plain: true });
+
+    output.obra = await relatorio_andamento_atual.getObra({
+      transaction,
+    });
+
+    output.ultimo_relatorio_video =
+      await relatorio_andamento_atual.getUltimo_relatorio_video({
+        transaction,
+      });
+
+    output.clientes = await relatorio_andamento_atual.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.relatorios_analiticos_video,
+        as: 'ultimo_relatorio_video',
+
+        where: filter.ultimo_relatorio_video
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.ultimo_relatorio_video
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  json_analise: {
+                    [Op.or]: filter.ultimo_relatorio_video
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.status_obra) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'relatorio_andamento_atual',
+            'status_obra',
+            filter.status_obra,
+          ),
+        };
+      }
+
+      if (filter.atividade_atual_predominante) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'relatorio_andamento_atual',
+            'atividade_atual_predominante',
+            filter.atividade_atual_predominante,
+          ),
+        };
+      }
+
+      if (filter.riscos_em_aberto) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'relatorio_andamento_atual',
+            'riscos_em_aberto',
+            filter.riscos_em_aberto,
+          ),
+        };
+      }
+
+      if (filter.tempo_estimado_para_conclusao) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'relatorio_andamento_atual',
+            'tempo_estimado_para_conclusao',
+            filter.tempo_estimado_para_conclusao,
+          ),
+        };
+      }
+
+      if (filter.grau_conformidade_geral) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'relatorio_andamento_atual',
+            'grau_conformidade_geral',
+            filter.grau_conformidade_geral,
+          ),
+        };
+      }
+
+      if (filter.observacoes_finais) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'relatorio_andamento_atual',
+            'observacoes_finais',
+            filter.observacoes_finais,
+          ),
+        };
+      }
+
+      if (filter.data_ultima_atualizacaoRange) {
+        const [start, end] = filter.data_ultima_atualizacaoRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_ultima_atualizacao: {
+              ...where.data_ultima_atualizacao,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_ultima_atualizacao: {
+              ...where.data_ultima_atualizacao,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.percentual_execucao_totalRange) {
+        const [start, end] = filter.percentual_execucao_totalRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            percentual_execucao_total: {
+              ...where.percentual_execucao_total,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            percentual_execucao_total: {
+              ...where.percentual_execucao_total,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.relatorio_andamento_atual.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('relatorio_andamento_atual', 'status_obra', query),
+        ],
+      };
+    }
+
+    const records = await db.relatorio_andamento_atual.findAll({
+      attributes: ['id', 'status_obra'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['status_obra', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.status_obra,
+    }));
+  }
+};
--- a/backend/src/db/api/relatorios_analiticos_video.js
+++ b/backend/src/db/api/relatorios_analiticos_video.js
@ -0,0 +1,395 @@
+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 Relatorios_analiticos_videoDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_analiticos_video =
+      await db.relatorios_analiticos_video.create(
+        {
+          id: data.id || undefined,
+
+          json_analise: data.json_analise || null,
+          data_geracao: data.data_geracao || null,
+          importHash: data.importHash || null,
+          createdById: currentUser.id,
+          updatedById: currentUser.id,
+        },
+        { transaction },
+      );
+
+    await relatorios_analiticos_video.setInspecao(data.inspecao || null, {
+      transaction,
+    });
+
+    await relatorios_analiticos_video.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return relatorios_analiticos_video;
+  }
+
+  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 relatorios_analiticos_videoData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      json_analise: item.json_analise || null,
+      data_geracao: item.data_geracao || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const relatorios_analiticos_video =
+      await db.relatorios_analiticos_video.bulkCreate(
+        relatorios_analiticos_videoData,
+        { transaction },
+      );
+
+    // For each item created, replace relation files
+
+    return relatorios_analiticos_video;
+  }
+
+  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 relatorios_analiticos_video =
+      await db.relatorios_analiticos_video.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.json_analise !== undefined)
+      updatePayload.json_analise = data.json_analise;
+
+    if (data.data_geracao !== undefined)
+      updatePayload.data_geracao = data.data_geracao;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await relatorios_analiticos_video.update(updatePayload, { transaction });
+
+    if (data.inspecao !== undefined) {
+      await relatorios_analiticos_video.setInspecao(
+        data.inspecao,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await relatorios_analiticos_video.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return relatorios_analiticos_video;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_analiticos_video =
+      await db.relatorios_analiticos_video.findAll({
+        where: {
+          id: {
+            [Op.in]: ids,
+          },
+        },
+        transaction,
+      });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of relatorios_analiticos_video) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of relatorios_analiticos_video) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return relatorios_analiticos_video;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_analiticos_video =
+      await db.relatorios_analiticos_video.findByPk(id, options);
+
+    await relatorios_analiticos_video.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await relatorios_analiticos_video.destroy({
+      transaction,
+    });
+
+    return relatorios_analiticos_video;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_analiticos_video =
+      await db.relatorios_analiticos_video.findOne({ where }, { transaction });
+
+    if (!relatorios_analiticos_video) {
+      return relatorios_analiticos_video;
+    }
+
+    const output = relatorios_analiticos_video.get({ plain: true });
+
+    output.relatorio_andamento_atual_ultimo_relatorio_video =
+      await relatorios_analiticos_video.getRelatorio_andamento_atual_ultimo_relatorio_video(
+        {
+          transaction,
+        },
+      );
+
+    output.inspecao = await relatorios_analiticos_video.getInspecao({
+      transaction,
+    });
+
+    output.clientes = await relatorios_analiticos_video.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.inspecao_aerea,
+        as: 'inspecao',
+
+        where: filter.inspecao
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.inspecao
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  tipo_inspecao: {
+                    [Op.or]: filter.inspecao
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.json_analise) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'relatorios_analiticos_video',
+            'json_analise',
+            filter.json_analise,
+          ),
+        };
+      }
+
+      if (filter.data_geracaoRange) {
+        const [start, end] = filter.data_geracaoRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_geracao: {
+              ...where.data_geracao,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_geracao: {
+              ...where.data_geracao,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.relatorios_analiticos_video.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('relatorios_analiticos_video', 'json_analise', query),
+        ],
+      };
+    }
+
+    const records = await db.relatorios_analiticos_video.findAll({
+      attributes: ['id', 'json_analise'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['json_analise', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.json_analise,
+    }));
+  }
+};
--- a/backend/src/db/api/relatorios_diarios.js
+++ b/backend/src/db/api/relatorios_diarios.js
@ -0,0 +1,387 @@
+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 Relatorios_diariosDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_diarios = await db.relatorios_diarios.create(
+      {
+        id: data.id || undefined,
+
+        data: data.data || null,
+        resumo: data.resumo || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await relatorios_diarios.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await relatorios_diarios.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return relatorios_diarios;
+  }
+
+  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 relatorios_diariosData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      data: item.data || null,
+      resumo: item.resumo || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const relatorios_diarios = await db.relatorios_diarios.bulkCreate(
+      relatorios_diariosData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return relatorios_diarios;
+  }
+
+  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 relatorios_diarios = await db.relatorios_diarios.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.data !== undefined) updatePayload.data = data.data;
+
+    if (data.resumo !== undefined) updatePayload.resumo = data.resumo;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await relatorios_diarios.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await relatorios_diarios.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await relatorios_diarios.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return relatorios_diarios;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_diarios = await db.relatorios_diarios.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of relatorios_diarios) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of relatorios_diarios) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return relatorios_diarios;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_diarios = await db.relatorios_diarios.findByPk(
+      id,
+      options,
+    );
+
+    await relatorios_diarios.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await relatorios_diarios.destroy({
+      transaction,
+    });
+
+    return relatorios_diarios;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_diarios = await db.relatorios_diarios.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!relatorios_diarios) {
+      return relatorios_diarios;
+    }
+
+    const output = relatorios_diarios.get({ plain: true });
+
+    output.obra = await relatorios_diarios.getObra({
+      transaction,
+    });
+
+    output.clientes = await relatorios_diarios.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.resumo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('relatorios_diarios', 'resumo', filter.resumo),
+        };
+      }
+
+      if (filter.dataRange) {
+        const [start, end] = filter.dataRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data: {
+              ...where.data,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data: {
+              ...where.data,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.relatorios_diarios.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('relatorios_diarios', 'resumo', query),
+        ],
+      };
+    }
+
+    const records = await db.relatorios_diarios.findAll({
+      attributes: ['id', 'resumo'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['resumo', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.resumo,
+    }));
+  }
+};
--- a/backend/src/db/api/relatorios_mensais.js
+++ b/backend/src/db/api/relatorios_mensais.js
@ -0,0 +1,388 @@
+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 Relatorios_mensaisDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_mensais = await db.relatorios_mensais.create(
+      {
+        id: data.id || undefined,
+
+        mes_referencia: data.mes_referencia || null,
+        resumo: data.resumo || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await relatorios_mensais.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await relatorios_mensais.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return relatorios_mensais;
+  }
+
+  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 relatorios_mensaisData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      mes_referencia: item.mes_referencia || null,
+      resumo: item.resumo || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const relatorios_mensais = await db.relatorios_mensais.bulkCreate(
+      relatorios_mensaisData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return relatorios_mensais;
+  }
+
+  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 relatorios_mensais = await db.relatorios_mensais.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.mes_referencia !== undefined)
+      updatePayload.mes_referencia = data.mes_referencia;
+
+    if (data.resumo !== undefined) updatePayload.resumo = data.resumo;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await relatorios_mensais.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await relatorios_mensais.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await relatorios_mensais.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return relatorios_mensais;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_mensais = await db.relatorios_mensais.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of relatorios_mensais) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of relatorios_mensais) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return relatorios_mensais;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_mensais = await db.relatorios_mensais.findByPk(
+      id,
+      options,
+    );
+
+    await relatorios_mensais.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await relatorios_mensais.destroy({
+      transaction,
+    });
+
+    return relatorios_mensais;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_mensais = await db.relatorios_mensais.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!relatorios_mensais) {
+      return relatorios_mensais;
+    }
+
+    const output = relatorios_mensais.get({ plain: true });
+
+    output.obra = await relatorios_mensais.getObra({
+      transaction,
+    });
+
+    output.clientes = await relatorios_mensais.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.resumo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('relatorios_mensais', 'resumo', filter.resumo),
+        };
+      }
+
+      if (filter.mes_referenciaRange) {
+        const [start, end] = filter.mes_referenciaRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            mes_referencia: {
+              ...where.mes_referencia,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            mes_referencia: {
+              ...where.mes_referencia,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.relatorios_mensais.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('relatorios_mensais', 'resumo', query),
+        ],
+      };
+    }
+
+    const records = await db.relatorios_mensais.findAll({
+      attributes: ['id', 'resumo'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['resumo', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.resumo,
+    }));
+  }
+};
--- a/backend/src/db/api/relatorios_semanais.js
+++ b/backend/src/db/api/relatorios_semanais.js
@ -0,0 +1,388 @@
+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 Relatorios_semanaisDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_semanais = await db.relatorios_semanais.create(
+      {
+        id: data.id || undefined,
+
+        semana_referencia: data.semana_referencia || null,
+        resumo: data.resumo || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await relatorios_semanais.setObra(data.obra || null, {
+      transaction,
+    });
+
+    await relatorios_semanais.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return relatorios_semanais;
+  }
+
+  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 relatorios_semanaisData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      semana_referencia: item.semana_referencia || null,
+      resumo: item.resumo || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const relatorios_semanais = await db.relatorios_semanais.bulkCreate(
+      relatorios_semanaisData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return relatorios_semanais;
+  }
+
+  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 relatorios_semanais = await db.relatorios_semanais.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.semana_referencia !== undefined)
+      updatePayload.semana_referencia = data.semana_referencia;
+
+    if (data.resumo !== undefined) updatePayload.resumo = data.resumo;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await relatorios_semanais.update(updatePayload, { transaction });
+
+    if (data.obra !== undefined) {
+      await relatorios_semanais.setObra(
+        data.obra,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await relatorios_semanais.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return relatorios_semanais;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_semanais = await db.relatorios_semanais.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of relatorios_semanais) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of relatorios_semanais) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return relatorios_semanais;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_semanais = await db.relatorios_semanais.findByPk(
+      id,
+      options,
+    );
+
+    await relatorios_semanais.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await relatorios_semanais.destroy({
+      transaction,
+    });
+
+    return relatorios_semanais;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const relatorios_semanais = await db.relatorios_semanais.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!relatorios_semanais) {
+      return relatorios_semanais;
+    }
+
+    const output = relatorios_semanais.get({ plain: true });
+
+    output.obra = await relatorios_semanais.getObra({
+      transaction,
+    });
+
+    output.clientes = await relatorios_semanais.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.obras,
+        as: 'obra',
+
+        where: filter.obra
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.obra
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  nome_obra: {
+                    [Op.or]: filter.obra
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.resumo) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('relatorios_semanais', 'resumo', filter.resumo),
+        };
+      }
+
+      if (filter.semana_referenciaRange) {
+        const [start, end] = filter.semana_referenciaRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            semana_referencia: {
+              ...where.semana_referencia,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            semana_referencia: {
+              ...where.semana_referencia,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.relatorios_semanais.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('relatorios_semanais', 'resumo', query),
+        ],
+      };
+    }
+
+    const records = await db.relatorios_semanais.findAll({
+      attributes: ['id', 'resumo'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['resumo', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.resumo,
+    }));
+  }
+};
--- a/backend/src/db/api/roles.js
+++ b/backend/src/db/api/roles.js
@ -0,0 +1,352 @@
+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.permissoes_modulo_role = await roles.getPermissoes_modulo_role({
+      transaction,
+    });
+
+    output.usuarios_role = await roles.getUsuarios_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 userClientes = (user && user.clientes?.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/subcontratadas.js
+++ b/backend/src/db/api/subcontratadas.js
@ -0,0 +1,352 @@
+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 SubcontratadasDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const subcontratadas = await db.subcontratadas.create(
+      {
+        id: data.id || undefined,
+
+        nome: data.nome || null,
+        cnpj: data.cnpj || null,
+        endereco: data.endereco || null,
+        responsavel_tecnico: data.responsavel_tecnico || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await subcontratadas.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return subcontratadas;
+  }
+
+  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 subcontratadasData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      nome: item.nome || null,
+      cnpj: item.cnpj || null,
+      endereco: item.endereco || null,
+      responsavel_tecnico: item.responsavel_tecnico || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const subcontratadas = await db.subcontratadas.bulkCreate(
+      subcontratadasData,
+      { transaction },
+    );
+
+    // For each item created, replace relation files
+
+    return subcontratadas;
+  }
+
+  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 subcontratadas = await db.subcontratadas.findByPk(
+      id,
+      {},
+      { transaction },
+    );
+
+    const updatePayload = {};
+
+    if (data.nome !== undefined) updatePayload.nome = data.nome;
+
+    if (data.cnpj !== undefined) updatePayload.cnpj = data.cnpj;
+
+    if (data.endereco !== undefined) updatePayload.endereco = data.endereco;
+
+    if (data.responsavel_tecnico !== undefined)
+      updatePayload.responsavel_tecnico = data.responsavel_tecnico;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await subcontratadas.update(updatePayload, { transaction });
+
+    if (data.clientes !== undefined) {
+      await subcontratadas.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return subcontratadas;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const subcontratadas = await db.subcontratadas.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of subcontratadas) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of subcontratadas) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return subcontratadas;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const subcontratadas = await db.subcontratadas.findByPk(id, options);
+
+    await subcontratadas.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await subcontratadas.destroy({
+      transaction,
+    });
+
+    return subcontratadas;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const subcontratadas = await db.subcontratadas.findOne(
+      { where },
+      { transaction },
+    );
+
+    if (!subcontratadas) {
+      return subcontratadas;
+    }
+
+    const output = subcontratadas.get({ plain: true });
+
+    output.clientes = await subcontratadas.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.nome) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('subcontratadas', 'nome', filter.nome),
+        };
+      }
+
+      if (filter.cnpj) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('subcontratadas', 'cnpj', filter.cnpj),
+        };
+      }
+
+      if (filter.endereco) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('subcontratadas', 'endereco', filter.endereco),
+        };
+      }
+
+      if (filter.responsavel_tecnico) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike(
+            'subcontratadas',
+            'responsavel_tecnico',
+            filter.responsavel_tecnico,
+          ),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.subcontratadas.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('subcontratadas', 'nome', query),
+        ],
+      };
+    }
+
+    const records = await db.subcontratadas.findAll({
+      attributes: ['id', 'nome'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome,
+    }));
+  }
+};
--- a/backend/src/db/api/users.js
+++ b/backend/src/db/api/users.js
@ -0,0 +1,800 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const bcrypt = require('bcrypt');
+const config = require('../../config');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class UsersDBApi {
+  static async create(data, globalAccess, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.create(
+      {
+        id: data.data.id || undefined,
+
+        firstName: data.data.firstName || null,
+        lastName: data.data.lastName || null,
+        phoneNumber: data.data.phoneNumber || null,
+        email: data.data.email || null,
+        disabled: data.data.disabled || false,
+
+        password: data.data.password || null,
+        emailVerified: data.data.emailVerified || true,
+
+        emailVerificationToken: data.data.emailVerificationToken || null,
+        emailVerificationTokenExpiresAt:
+          data.data.emailVerificationTokenExpiresAt || null,
+        passwordResetToken: data.data.passwordResetToken || null,
+        passwordResetTokenExpiresAt:
+          data.data.passwordResetTokenExpiresAt || null,
+        provider: data.data.provider || null,
+        importHash: data.data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    if (!data.data.app_role) {
+      const role = await db.roles.findOne({
+        where: { name: 'User' },
+      });
+      if (role) {
+        await users.setApp_role(role, {
+          transaction,
+        });
+      }
+    } else {
+      await users.setApp_role(data.data.app_role || null, {
+        transaction,
+      });
+    }
+
+    await users.setClientes(data.data.clientes || 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.clientes !== undefined) {
+      await users.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    if (data.custom_permissions !== undefined) {
+      await users.setCustom_permissions(data.custom_permissions, {
+        transaction,
+      });
+    }
+
+    await FileDBApi.replaceRelationFiles(
+      {
+        belongsTo: db.users.getTableName(),
+        belongsToColumn: 'avatar',
+        belongsToId: users.id,
+      },
+      data.avatar,
+      options,
+    );
+
+    return users;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of users) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of users) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return users;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findByPk(id, options);
+
+    await users.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await users.destroy({
+      transaction,
+    });
+
+    return users;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const users = await db.users.findOne({ where }, { transaction });
+
+    if (!users) {
+      return users;
+    }
+
+    const output = users.get({ plain: true });
+
+    output.avatar = await users.getAvatar({
+      transaction,
+    });
+
+    output.app_role = await users.getApp_role({
+      transaction,
+    });
+
+    if (output.app_role) {
+      output.app_role_permissions = await output.app_role.getPermissions({
+        transaction,
+      });
+    }
+
+    output.custom_permissions = await users.getCustom_permissions({
+      transaction,
+    });
+
+    output.clientes = await users.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    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.clientes,
+        as: 'clientes',
+      },
+
+      {
+        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.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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/usuarios.js
+++ b/backend/src/db/api/usuarios.js
@ -0,0 +1,443 @@
+const db = require('../models');
+const FileDBApi = require('./file');
+const crypto = require('crypto');
+const Utils = require('../utils');
+
+const Sequelize = db.Sequelize;
+const Op = Sequelize.Op;
+
+module.exports = class UsuariosDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const usuarios = await db.usuarios.create(
+      {
+        id: data.id || undefined,
+
+        nome: data.nome || null,
+        email: data.email || null,
+        senha_hash: data.senha_hash || null,
+        ativo: data.ativo || false,
+
+        data_criacao: data.data_criacao || null,
+        importHash: data.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+      },
+      { transaction },
+    );
+
+    await usuarios.setRole(data.role || null, {
+      transaction,
+    });
+
+    await usuarios.setCliente(data.cliente || null, {
+      transaction,
+    });
+
+    await usuarios.setClientes(data.clientes || null, {
+      transaction,
+    });
+
+    return usuarios;
+  }
+
+  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 usuariosData = data.map((item, index) => ({
+      id: item.id || undefined,
+
+      nome: item.nome || null,
+      email: item.email || null,
+      senha_hash: item.senha_hash || null,
+      ativo: item.ativo || false,
+
+      data_criacao: item.data_criacao || null,
+      importHash: item.importHash || null,
+      createdById: currentUser.id,
+      updatedById: currentUser.id,
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const usuarios = await db.usuarios.bulkCreate(usuariosData, {
+      transaction,
+    });
+
+    // For each item created, replace relation files
+
+    return usuarios;
+  }
+
+  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 usuarios = await db.usuarios.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.nome !== undefined) updatePayload.nome = data.nome;
+
+    if (data.email !== undefined) updatePayload.email = data.email;
+
+    if (data.senha_hash !== undefined)
+      updatePayload.senha_hash = data.senha_hash;
+
+    if (data.ativo !== undefined) updatePayload.ativo = data.ativo;
+
+    if (data.data_criacao !== undefined)
+      updatePayload.data_criacao = data.data_criacao;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await usuarios.update(updatePayload, { transaction });
+
+    if (data.role !== undefined) {
+      await usuarios.setRole(
+        data.role,
+
+        { transaction },
+      );
+    }
+
+    if (data.cliente !== undefined) {
+      await usuarios.setCliente(
+        data.cliente,
+
+        { transaction },
+      );
+    }
+
+    if (data.clientes !== undefined) {
+      await usuarios.setClientes(
+        data.clientes,
+
+        { transaction },
+      );
+    }
+
+    return usuarios;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const usuarios = await db.usuarios.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of usuarios) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of usuarios) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return usuarios;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const usuarios = await db.usuarios.findByPk(id, options);
+
+    await usuarios.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await usuarios.destroy({
+      transaction,
+    });
+
+    return usuarios;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const usuarios = await db.usuarios.findOne({ where }, { transaction });
+
+    if (!usuarios) {
+      return usuarios;
+    }
+
+    const output = usuarios.get({ plain: true });
+
+    output.role = await usuarios.getRole({
+      transaction,
+    });
+
+    output.cliente = await usuarios.getCliente({
+      transaction,
+    });
+
+    output.clientes = await usuarios.getClientes({
+      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 userClientes = (user && user.clientes?.id) || null;
+
+    if (userClientes) {
+      if (options?.currentUser?.clientesId) {
+        where.clientesId = options.currentUser.clientesId;
+      }
+    }
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.roles,
+        as: 'role',
+
+        where: filter.role
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.role
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.role
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+
+      {
+        model: db.clientes,
+        as: 'cliente',
+      },
+
+      {
+        model: db.clientes,
+        as: 'clientes',
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.nome) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('usuarios', 'nome', filter.nome),
+        };
+      }
+
+      if (filter.email) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('usuarios', 'email', filter.email),
+        };
+      }
+
+      if (filter.senha_hash) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('usuarios', 'senha_hash', filter.senha_hash),
+        };
+      }
+
+      if (filter.data_criacaoRange) {
+        const [start, end] = filter.data_criacaoRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            data_criacao: {
+              ...where.data_criacao,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            data_criacao: {
+              ...where.data_criacao,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.ativo) {
+        where = {
+          ...where,
+          ativo: filter.ativo,
+        };
+      }
+
+      if (filter.cliente) {
+        const listItems = filter.cliente.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clienteId: { [Op.or]: listItems },
+        };
+      }
+
+      if (filter.clientes) {
+        const listItems = filter.clientes.split('|').map((item) => {
+          return Utils.uuid(item);
+        });
+
+        where = {
+          ...where,
+          clientesId: { [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.clientesId;
+    }
+
+    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.usuarios.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('usuarios', 'nome', query),
+        ],
+      };
+    }
+
+    const records = await db.usuarios.findAll({
+      attributes: ['id', 'nome'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['nome', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.nome,
+    }));
+  }
+};
--- 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_gerenciador_e_fiscalizador_de_obras_copasa',
+    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/1761298705478.js
+++ b/backend/src/db/migrations/1761298705478.js
--- a/backend/src/db/models/cameras_ptz.js
+++ b/backend/src/db/models/cameras_ptz.js
@ -0,0 +1,113 @@
+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 cameras_ptz = sequelize.define(
+    'cameras_ptz',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      modelo: {
+        type: DataTypes.TEXT,
+      },
+
+      fabricante: {
+        type: DataTypes.TEXT,
+      },
+
+      local_instalacao: {
+        type: DataTypes.TEXT,
+      },
+
+      coordenada_lat: {
+        type: DataTypes.DECIMAL,
+      },
+
+      coordenada_lon: {
+        type: DataTypes.DECIMAL,
+      },
+
+      altura_instalacao_m: {
+        type: DataTypes.DECIMAL,
+      },
+
+      angulo_focal: {
+        type: DataTypes.TEXT,
+      },
+
+      ip_acesso: {
+        type: DataTypes.TEXT,
+      },
+
+      status_operacional: {
+        type: DataTypes.TEXT,
+      },
+
+      data_instalacao: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('data_instalacao')
+            ? moment
+                .utc(this.getDataValue('data_instalacao'))
+                .format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      observacoes: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  cameras_ptz.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.cameras_ptz.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.cameras_ptz.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.cameras_ptz.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.cameras_ptz.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return cameras_ptz;
+};
--- a/backend/src/db/models/clientes.js
+++ b/backend/src/db/models/clientes.js
@ -0,0 +1,289 @@
+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 clientes = sequelize.define(
+    'clientes',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  clientes.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.clientes.hasMany(db.users, {
+      as: 'users_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.cameras_ptz, {
+      as: 'cameras_ptz_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.epcs, {
+      as: 'epcs_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.epis, {
+      as: 'epis_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.equipes_trabalho, {
+      as: 'equipes_trabalho_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.estrutura_projeto, {
+      as: 'estrutura_projeto_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.etapas_ou_trechos, {
+      as: 'etapas_ou_trechos_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.frames_imagem, {
+      as: 'frames_imagem_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.gemeos_digitais, {
+      as: 'gemeos_digitais_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.historico_alteracoes_projeto, {
+      as: 'historico_alteracoes_projeto_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.inspecao_aerea, {
+      as: 'inspecao_aerea_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.maquinas_atividade, {
+      as: 'maquinas_atividade_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.materiais_atividade, {
+      as: 'materiais_atividade_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.membros_equipe, {
+      as: 'membros_equipe_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.memoriais_descritivos_asbuilt, {
+      as: 'memoriais_descritivos_asbuilt_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.modelos_bim_asbuilt, {
+      as: 'modelos_bim_asbuilt_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.obras, {
+      as: 'obras_cliente',
+      foreignKey: {
+        name: 'clienteId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.obras, {
+      as: 'obras_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.permissoes_modulo, {
+      as: 'permissoes_modulo_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.pessoas_atividade, {
+      as: 'pessoas_atividade_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.pessoas_frame, {
+      as: 'pessoas_frame_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.plantas_asbuilt_2d, {
+      as: 'plantas_asbuilt_2d_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.relatorio_andamento_atual, {
+      as: 'relatorio_andamento_atual_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.relatorios_analiticos_video, {
+      as: 'relatorios_analiticos_video_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.relatorios_diarios, {
+      as: 'relatorios_diarios_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.relatorios_mensais, {
+      as: 'relatorios_mensais_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.relatorios_semanais, {
+      as: 'relatorios_semanais_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.subcontratadas, {
+      as: 'subcontratadas_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.usuarios, {
+      as: 'usuarios_cliente',
+      foreignKey: {
+        name: 'clienteId',
+      },
+      constraints: false,
+    });
+
+    db.clientes.hasMany(db.usuarios, {
+      as: 'usuarios_clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.clientes.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.clientes.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return clientes;
+};
--- a/backend/src/db/models/epcs.js
+++ b/backend/src/db/models/epcs.js
@ -0,0 +1,61 @@
+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 epcs = sequelize.define(
+    'epcs',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      nome_epc: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  epcs.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.epcs.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.epcs.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.epcs.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return epcs;
+};
--- a/backend/src/db/models/epis.js
+++ b/backend/src/db/models/epis.js
@ -0,0 +1,61 @@
+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 epis = sequelize.define(
+    'epis',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      nome_epi: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  epis.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.epis.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.epis.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.epis.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return epis;
+};
--- a/backend/src/db/models/equipes_trabalho.js
+++ b/backend/src/db/models/equipes_trabalho.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 equipes_trabalho = sequelize.define(
+    'equipes_trabalho',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      nome_equipe: {
+        type: DataTypes.TEXT,
+      },
+
+      tipo: {
+        type: DataTypes.ENUM,
+
+        values: ['Copasa', 'Subcontratada'],
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  equipes_trabalho.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.equipes_trabalho.hasMany(db.membros_equipe, {
+      as: 'membros_equipe_equipe',
+      foreignKey: {
+        name: 'equipeId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.equipes_trabalho.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.equipes_trabalho.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.equipes_trabalho.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.equipes_trabalho.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return equipes_trabalho;
+};
--- a/backend/src/db/models/estrutura_projeto.js
+++ b/backend/src/db/models/estrutura_projeto.js
@ -0,0 +1,109 @@
+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 estrutura_projeto = sequelize.define(
+    'estrutura_projeto',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      etapa: {
+        type: DataTypes.TEXT,
+      },
+
+      atividade: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao: {
+        type: DataTypes.TEXT,
+      },
+
+      prazo_estimado_dias: {
+        type: DataTypes.INTEGER,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  estrutura_projeto.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.estrutura_projeto.hasMany(db.historico_alteracoes_projeto, {
+      as: 'historico_alteracoes_projeto_estrutura',
+      foreignKey: {
+        name: 'estruturaId',
+      },
+      constraints: false,
+    });
+
+    db.estrutura_projeto.hasMany(db.maquinas_atividade, {
+      as: 'maquinas_atividade_estrutura',
+      foreignKey: {
+        name: 'estruturaId',
+      },
+      constraints: false,
+    });
+
+    db.estrutura_projeto.hasMany(db.materiais_atividade, {
+      as: 'materiais_atividade_estrutura',
+      foreignKey: {
+        name: 'estruturaId',
+      },
+      constraints: false,
+    });
+
+    db.estrutura_projeto.hasMany(db.pessoas_atividade, {
+      as: 'pessoas_atividade_estrutura',
+      foreignKey: {
+        name: 'estruturaId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.estrutura_projeto.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.estrutura_projeto.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.estrutura_projeto.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.estrutura_projeto.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return estrutura_projeto;
+};
--- a/backend/src/db/models/etapas_ou_trechos.js
+++ b/backend/src/db/models/etapas_ou_trechos.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 etapas_ou_trechos = sequelize.define(
+    'etapas_ou_trechos',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      tipo: {
+        type: DataTypes.TEXT,
+      },
+
+      nome: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  etapas_ou_trechos.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.etapas_ou_trechos.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.etapas_ou_trechos.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.etapas_ou_trechos.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.etapas_ou_trechos.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return etapas_ou_trechos;
+};
--- a/backend/src/db/models/file.js
+++ b/backend/src/db/models/file.js
@ -0,0 +1,53 @@
+module.exports = function (sequelize, DataTypes) {
+  const file = sequelize.define(
+    'file',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      belongsTo: DataTypes.STRING(255),
+      belongsToId: DataTypes.UUID,
+      belongsToColumn: DataTypes.STRING(255),
+      name: {
+        type: DataTypes.STRING(2083),
+        allowNull: false,
+        validate: {
+          notEmpty: true,
+        },
+      },
+      sizeInBytes: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+      },
+      privateUrl: {
+        type: DataTypes.STRING(2083),
+        allowNull: true,
+      },
+      publicUrl: {
+        type: DataTypes.STRING(2083),
+        allowNull: false,
+        validate: {
+          notEmpty: true,
+        },
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+    },
+  );
+
+  file.associate = (db) => {
+    db.file.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.file.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return file;
+};
--- a/backend/src/db/models/frames_imagem.js
+++ b/backend/src/db/models/frames_imagem.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 frames_imagem = sequelize.define(
+    'frames_imagem',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      origem: {
+        type: DataTypes.ENUM,
+
+        values: ['drone', 'ptz'],
+      },
+
+      imagem_url: {
+        type: DataTypes.TEXT,
+      },
+
+      timestamp_frame: {
+        type: DataTypes.DATE,
+      },
+
+      observacoes: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  frames_imagem.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.frames_imagem.hasMany(db.pessoas_frame, {
+      as: 'pessoas_frame_frame',
+      foreignKey: {
+        name: 'frameId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.frames_imagem.belongsTo(db.inspecao_aerea, {
+      as: 'inspecao',
+      foreignKey: {
+        name: 'inspecaoId',
+      },
+      constraints: false,
+    });
+
+    db.frames_imagem.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.frames_imagem.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.frames_imagem.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return frames_imagem;
+};
--- a/backend/src/db/models/gemeos_digitais.js
+++ b/backend/src/db/models/gemeos_digitais.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 gemeos_digitais = sequelize.define(
+    'gemeos_digitais',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      tipo: {
+        type: DataTypes.TEXT,
+      },
+
+      arquivo_url: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  gemeos_digitais.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.gemeos_digitais.belongsTo(db.inspecao_aerea, {
+      as: 'inspecao',
+      foreignKey: {
+        name: 'inspecaoId',
+      },
+      constraints: false,
+    });
+
+    db.gemeos_digitais.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.gemeos_digitais.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.gemeos_digitais.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return gemeos_digitais;
+};
--- a/backend/src/db/models/historico_alteracoes_projeto.js
+++ b/backend/src/db/models/historico_alteracoes_projeto.js
@ -0,0 +1,89 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const historico_alteracoes_projeto = sequelize.define(
+    'historico_alteracoes_projeto',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      data_alteracao: {
+        type: DataTypes.DATE,
+      },
+
+      tipo_alteracao: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao_anterior: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao_nova: {
+        type: DataTypes.TEXT,
+      },
+
+      motivo_alteracao: {
+        type: DataTypes.TEXT,
+      },
+
+      responsavel_alteracao: {
+        type: DataTypes.TEXT,
+      },
+
+      comentarios: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  historico_alteracoes_projeto.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.historico_alteracoes_projeto.belongsTo(db.estrutura_projeto, {
+      as: 'estrutura',
+      foreignKey: {
+        name: 'estruturaId',
+      },
+      constraints: false,
+    });
+
+    db.historico_alteracoes_projeto.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.historico_alteracoes_projeto.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.historico_alteracoes_projeto.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return historico_alteracoes_projeto;
+};
--- a/backend/src/db/models/index.js
+++ b/backend/src/db/models/index.js
@ -0,0 +1,47 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const Sequelize = require('sequelize');
+const basename = path.basename(__filename);
+const env = process.env.NODE_ENV || 'development';
+const config = require('../db.config')[env];
+const db = {};
+
+let sequelize;
+console.log(env);
+if (config.use_env_variable) {
+  sequelize = new Sequelize(process.env[config.use_env_variable], config);
+} else {
+  sequelize = new Sequelize(
+    config.database,
+    config.username,
+    config.password,
+    config,
+  );
+}
+
+fs.readdirSync(__dirname)
+  .filter((file) => {
+    return (
+      file.indexOf('.') !== 0 && file !== basename && file.slice(-3) === '.js'
+    );
+  })
+  .forEach((file) => {
+    const model = require(path.join(__dirname, file))(
+      sequelize,
+      Sequelize.DataTypes,
+    );
+    db[model.name] = model;
+  });
+
+Object.keys(db).forEach((modelName) => {
+  if (db[modelName].associate) {
+    db[modelName].associate(db);
+  }
+});
+
+db.sequelize = sequelize;
+db.Sequelize = Sequelize;
+
+module.exports = db;
--- a/backend/src/db/models/inspecao_aerea.js
+++ b/backend/src/db/models/inspecao_aerea.js
@ -0,0 +1,97 @@
+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 inspecao_aerea = sequelize.define(
+    'inspecao_aerea',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      data_inspecao: {
+        type: DataTypes.DATE,
+      },
+
+      tipo_inspecao: {
+        type: DataTypes.TEXT,
+      },
+
+      observacoes: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  inspecao_aerea.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.inspecao_aerea.hasMany(db.frames_imagem, {
+      as: 'frames_imagem_inspecao',
+      foreignKey: {
+        name: 'inspecaoId',
+      },
+      constraints: false,
+    });
+
+    db.inspecao_aerea.hasMany(db.gemeos_digitais, {
+      as: 'gemeos_digitais_inspecao',
+      foreignKey: {
+        name: 'inspecaoId',
+      },
+      constraints: false,
+    });
+
+    db.inspecao_aerea.hasMany(db.relatorios_analiticos_video, {
+      as: 'relatorios_analiticos_video_inspecao',
+      foreignKey: {
+        name: 'inspecaoId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.inspecao_aerea.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.inspecao_aerea.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.inspecao_aerea.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.inspecao_aerea.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return inspecao_aerea;
+};
--- a/backend/src/db/models/maquinas_atividade.js
+++ b/backend/src/db/models/maquinas_atividade.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 maquinas_atividade = sequelize.define(
+    'maquinas_atividade',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      quantidade_prevista: {
+        type: DataTypes.INTEGER,
+      },
+
+      horas_utilizacao_previstas: {
+        type: DataTypes.DECIMAL,
+      },
+
+      comentarios: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  maquinas_atividade.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.maquinas_atividade.belongsTo(db.estrutura_projeto, {
+      as: 'estrutura',
+      foreignKey: {
+        name: 'estruturaId',
+      },
+      constraints: false,
+    });
+
+    db.maquinas_atividade.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.maquinas_atividade.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.maquinas_atividade.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return maquinas_atividade;
+};
--- a/backend/src/db/models/materiais_atividade.js
+++ b/backend/src/db/models/materiais_atividade.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 materiais_atividade = sequelize.define(
+    'materiais_atividade',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      quantidade_prevista: {
+        type: DataTypes.DECIMAL,
+      },
+
+      unidade_medida: {
+        type: DataTypes.TEXT,
+      },
+
+      tolerancia_estoque: {
+        type: DataTypes.DECIMAL,
+      },
+
+      comentarios: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  materiais_atividade.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.materiais_atividade.belongsTo(db.estrutura_projeto, {
+      as: 'estrutura',
+      foreignKey: {
+        name: 'estruturaId',
+      },
+      constraints: false,
+    });
+
+    db.materiais_atividade.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.materiais_atividade.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.materiais_atividade.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return materiais_atividade;
+};
--- a/backend/src/db/models/membros_equipe.js
+++ b/backend/src/db/models/membros_equipe.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 membros_equipe = sequelize.define(
+    'membros_equipe',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      nome: {
+        type: DataTypes.TEXT,
+      },
+
+      funcao: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  membros_equipe.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.membros_equipe.hasMany(db.pessoas_atividade, {
+      as: 'pessoas_atividade_membro',
+      foreignKey: {
+        name: 'membroId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.membros_equipe.belongsTo(db.equipes_trabalho, {
+      as: 'equipe',
+      foreignKey: {
+        name: 'equipeId',
+      },
+      constraints: false,
+    });
+
+    db.membros_equipe.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.membros_equipe.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.membros_equipe.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return membros_equipe;
+};
--- a/backend/src/db/models/memoriais_descritivos_asbuilt.js
+++ b/backend/src/db/models/memoriais_descritivos_asbuilt.js
@ -0,0 +1,98 @@
+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 memoriais_descritivos_asbuilt = sequelize.define(
+    'memoriais_descritivos_asbuilt',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      titulo: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao: {
+        type: DataTypes.TEXT,
+      },
+
+      arquivo_digital: {
+        type: DataTypes.TEXT,
+      },
+
+      data_entrega: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('data_entrega')
+            ? moment.utc(this.getDataValue('data_entrega')).format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      responsavel_tecnico: {
+        type: DataTypes.TEXT,
+      },
+
+      validado_por_copasa: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      comentarios_validacao: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  memoriais_descritivos_asbuilt.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.memoriais_descritivos_asbuilt.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.memoriais_descritivos_asbuilt.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.memoriais_descritivos_asbuilt.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.memoriais_descritivos_asbuilt.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return memoriais_descritivos_asbuilt;
+};
--- a/backend/src/db/models/modelos_bim_asbuilt.js
+++ b/backend/src/db/models/modelos_bim_asbuilt.js
@ -0,0 +1,112 @@
+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 modelos_bim_asbuilt = sequelize.define(
+    'modelos_bim_asbuilt',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      nome_modelo: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao: {
+        type: DataTypes.TEXT,
+      },
+
+      arquivo_modelo: {
+        type: DataTypes.TEXT,
+      },
+
+      formato: {
+        type: DataTypes.TEXT,
+      },
+
+      plataforma_origem: {
+        type: DataTypes.TEXT,
+      },
+
+      data_modelagem: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('data_modelagem')
+            ? moment
+                .utc(this.getDataValue('data_modelagem'))
+                .format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      responsavel_modelagem: {
+        type: DataTypes.TEXT,
+      },
+
+      nivel_detalhamento: {
+        type: DataTypes.TEXT,
+      },
+
+      coordenacao_com_outros_modelos: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      comentarios: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  modelos_bim_asbuilt.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.modelos_bim_asbuilt.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.modelos_bim_asbuilt.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.modelos_bim_asbuilt.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.modelos_bim_asbuilt.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return modelos_bim_asbuilt;
+};
--- a/backend/src/db/models/obras.js
+++ b/backend/src/db/models/obras.js
@ -0,0 +1,202 @@
+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 obras = sequelize.define(
+    'obras',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      nome_obra: {
+        type: DataTypes.TEXT,
+      },
+
+      cidade: {
+        type: DataTypes.TEXT,
+      },
+
+      estado: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao: {
+        type: DataTypes.TEXT,
+      },
+
+      data_inicio: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('data_inicio')
+            ? moment.utc(this.getDataValue('data_inicio')).format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      data_previsao_termino: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('data_previsao_termino')
+            ? moment
+                .utc(this.getDataValue('data_previsao_termino'))
+                .format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      plantas_2d_georreferenciadas: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  obras.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.obras.hasMany(db.cameras_ptz, {
+      as: 'cameras_ptz_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.equipes_trabalho, {
+      as: 'equipes_trabalho_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.estrutura_projeto, {
+      as: 'estrutura_projeto_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.etapas_ou_trechos, {
+      as: 'etapas_ou_trechos_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.inspecao_aerea, {
+      as: 'inspecao_aerea_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.memoriais_descritivos_asbuilt, {
+      as: 'memoriais_descritivos_asbuilt_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.modelos_bim_asbuilt, {
+      as: 'modelos_bim_asbuilt_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.plantas_asbuilt_2d, {
+      as: 'plantas_asbuilt_2d_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.relatorio_andamento_atual, {
+      as: 'relatorio_andamento_atual_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.relatorios_diarios, {
+      as: 'relatorios_diarios_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.relatorios_mensais, {
+      as: 'relatorios_mensais_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.obras.hasMany(db.relatorios_semanais, {
+      as: 'relatorios_semanais_obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.obras.belongsTo(db.clientes, {
+      as: 'cliente',
+      foreignKey: {
+        name: 'clienteId',
+      },
+      constraints: false,
+    });
+
+    db.obras.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.obras.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.obras.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return obras;
+};
--- a/backend/src/db/models/permissions.js
+++ b/backend/src/db/models/permissions.js
@ -0,0 +1,49 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const permissions = sequelize.define(
+    'permissions',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      name: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  permissions.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    //end loop
+
+    db.permissions.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.permissions.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return permissions;
+};
--- a/backend/src/db/models/permissoes_modulo.js
+++ b/backend/src/db/models/permissoes_modulo.js
@ -0,0 +1,86 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const permissoes_modulo = sequelize.define(
+    'permissoes_modulo',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      modulo: {
+        type: DataTypes.TEXT,
+      },
+
+      leitura: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      escrita: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      aprovacao: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  permissoes_modulo.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.permissoes_modulo.belongsTo(db.roles, {
+      as: 'role',
+      foreignKey: {
+        name: 'roleId',
+      },
+      constraints: false,
+    });
+
+    db.permissoes_modulo.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.permissoes_modulo.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.permissoes_modulo.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return permissoes_modulo;
+};
--- a/backend/src/db/models/pessoas_atividade.js
+++ b/backend/src/db/models/pessoas_atividade.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 pessoas_atividade = sequelize.define(
+    'pessoas_atividade',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      funcao_na_atividade: {
+        type: DataTypes.TEXT,
+      },
+
+      horas_previstas: {
+        type: DataTypes.DECIMAL,
+      },
+
+      comentarios: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  pessoas_atividade.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.pessoas_atividade.belongsTo(db.estrutura_projeto, {
+      as: 'estrutura',
+      foreignKey: {
+        name: 'estruturaId',
+      },
+      constraints: false,
+    });
+
+    db.pessoas_atividade.belongsTo(db.membros_equipe, {
+      as: 'membro',
+      foreignKey: {
+        name: 'membroId',
+      },
+      constraints: false,
+    });
+
+    db.pessoas_atividade.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.pessoas_atividade.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.pessoas_atividade.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return pessoas_atividade;
+};
--- a/backend/src/db/models/pessoas_frame.js
+++ b/backend/src/db/models/pessoas_frame.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 pessoas_frame = sequelize.define(
+    'pessoas_frame',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      atividade: {
+        type: DataTypes.TEXT,
+      },
+
+      posicao_aproximada: {
+        type: DataTypes.TEXT,
+      },
+
+      epi_visiveis: {
+        type: DataTypes.TEXT,
+      },
+
+      foco_no_trabalho: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      operando_maquina: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  pessoas_frame.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.pessoas_frame.belongsTo(db.frames_imagem, {
+      as: 'frame',
+      foreignKey: {
+        name: 'frameId',
+      },
+      constraints: false,
+    });
+
+    db.pessoas_frame.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.pessoas_frame.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.pessoas_frame.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return pessoas_frame;
+};
--- a/backend/src/db/models/plantas_asbuilt_2d.js
+++ b/backend/src/db/models/plantas_asbuilt_2d.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 plantas_asbuilt_2d = sequelize.define(
+    'plantas_asbuilt_2d',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      nome_planta: {
+        type: DataTypes.TEXT,
+      },
+
+      descricao: {
+        type: DataTypes.TEXT,
+      },
+
+      arquivo_digital: {
+        type: DataTypes.TEXT,
+      },
+
+      formato: {
+        type: DataTypes.TEXT,
+      },
+
+      data_criacao: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('data_criacao')
+            ? moment.utc(this.getDataValue('data_criacao')).format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      responsavel_tecnico: {
+        type: DataTypes.TEXT,
+      },
+
+      georreferenciada: {
+        type: DataTypes.BOOLEAN,
+
+        allowNull: false,
+        defaultValue: false,
+      },
+
+      sistema_referencia: {
+        type: DataTypes.TEXT,
+      },
+
+      comentarios: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  plantas_asbuilt_2d.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.plantas_asbuilt_2d.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.plantas_asbuilt_2d.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.plantas_asbuilt_2d.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.plantas_asbuilt_2d.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return plantas_asbuilt_2d;
+};
--- a/backend/src/db/models/relatorio_andamento_atual.js
+++ b/backend/src/db/models/relatorio_andamento_atual.js
@ -0,0 +1,101 @@
+const config = require('../../config');
+const providers = config.providers;
+const crypto = require('crypto');
+const bcrypt = require('bcrypt');
+const moment = require('moment');
+
+module.exports = function (sequelize, DataTypes) {
+  const relatorio_andamento_atual = sequelize.define(
+    'relatorio_andamento_atual',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      data_ultima_atualizacao: {
+        type: DataTypes.DATE,
+      },
+
+      status_obra: {
+        type: DataTypes.TEXT,
+      },
+
+      percentual_execucao_total: {
+        type: DataTypes.DECIMAL,
+      },
+
+      atividade_atual_predominante: {
+        type: DataTypes.TEXT,
+      },
+
+      riscos_em_aberto: {
+        type: DataTypes.TEXT,
+      },
+
+      tempo_estimado_para_conclusao: {
+        type: DataTypes.TEXT,
+      },
+
+      grau_conformidade_geral: {
+        type: DataTypes.TEXT,
+      },
+
+      observacoes_finais: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  relatorio_andamento_atual.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.relatorio_andamento_atual.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.relatorio_andamento_atual.belongsTo(db.relatorios_analiticos_video, {
+      as: 'ultimo_relatorio_video',
+      foreignKey: {
+        name: 'ultimo_relatorio_videoId',
+      },
+      constraints: false,
+    });
+
+    db.relatorio_andamento_atual.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.relatorio_andamento_atual.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.relatorio_andamento_atual.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return relatorio_andamento_atual;
+};
--- a/backend/src/db/models/relatorios_analiticos_video.js
+++ b/backend/src/db/models/relatorios_analiticos_video.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 relatorios_analiticos_video = sequelize.define(
+    'relatorios_analiticos_video',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      json_analise: {
+        type: DataTypes.TEXT,
+      },
+
+      data_geracao: {
+        type: DataTypes.DATE,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  relatorios_analiticos_video.associate = (db) => {
+    /// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
+
+    db.relatorios_analiticos_video.hasMany(db.relatorio_andamento_atual, {
+      as: 'relatorio_andamento_atual_ultimo_relatorio_video',
+      foreignKey: {
+        name: 'ultimo_relatorio_videoId',
+      },
+      constraints: false,
+    });
+
+    //end loop
+
+    db.relatorios_analiticos_video.belongsTo(db.inspecao_aerea, {
+      as: 'inspecao',
+      foreignKey: {
+        name: 'inspecaoId',
+      },
+      constraints: false,
+    });
+
+    db.relatorios_analiticos_video.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.relatorios_analiticos_video.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.relatorios_analiticos_video.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return relatorios_analiticos_video;
+};
--- a/backend/src/db/models/relatorios_diarios.js
+++ b/backend/src/db/models/relatorios_diarios.js
@ -0,0 +1,75 @@
+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 relatorios_diarios = sequelize.define(
+    'relatorios_diarios',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      data: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('data')
+            ? moment.utc(this.getDataValue('data')).format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      resumo: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  relatorios_diarios.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.relatorios_diarios.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.relatorios_diarios.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.relatorios_diarios.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.relatorios_diarios.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return relatorios_diarios;
+};
--- a/backend/src/db/models/relatorios_mensais.js
+++ b/backend/src/db/models/relatorios_mensais.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 relatorios_mensais = sequelize.define(
+    'relatorios_mensais',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      mes_referencia: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('mes_referencia')
+            ? moment
+                .utc(this.getDataValue('mes_referencia'))
+                .format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      resumo: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  relatorios_mensais.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.relatorios_mensais.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.relatorios_mensais.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.relatorios_mensais.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.relatorios_mensais.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return relatorios_mensais;
+};
--- a/backend/src/db/models/relatorios_semanais.js
+++ b/backend/src/db/models/relatorios_semanais.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 relatorios_semanais = sequelize.define(
+    'relatorios_semanais',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+
+      semana_referencia: {
+        type: DataTypes.DATEONLY,
+
+        get: function () {
+          return this.getDataValue('semana_referencia')
+            ? moment
+                .utc(this.getDataValue('semana_referencia'))
+                .format('YYYY-MM-DD')
+            : null;
+        },
+      },
+
+      resumo: {
+        type: DataTypes.TEXT,
+      },
+
+      importHash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        unique: true,
+      },
+    },
+    {
+      timestamps: true,
+      paranoid: true,
+      freezeTableName: true,
+    },
+  );
+
+  relatorios_semanais.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.relatorios_semanais.belongsTo(db.obras, {
+      as: 'obra',
+      foreignKey: {
+        name: 'obraId',
+      },
+      constraints: false,
+    });
+
+    db.relatorios_semanais.belongsTo(db.clientes, {
+      as: 'clientes',
+      foreignKey: {
+        name: 'clientesId',
+      },
+      constraints: false,
+    });
+
+    db.relatorios_semanais.belongsTo(db.users, {
+      as: 'createdBy',
+    });
+
+    db.relatorios_semanais.belongsTo(db.users, {
+      as: 'updatedBy',
+    });
+  };
+
+  return relatorios_semanais;
+};
--- a/Show More
+++ b/Show More