Initial version

This commit is contained in:
Flatlogic Bot 2025-09-02 05:46:03 +00:00
commit 1676b53366
922 changed files with 196574 additions and 0 deletions

3
.gitignore vendored Normal file
View File

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

187
502.html Normal file
View File

@ -0,0 +1,187 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Service Starting</title>
<style>
body {
font-family: sans-serif;
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
min-height: 100vh;
background-color: #EFF2FF;
margin: 0;
padding: 20px;
}
.container {
text-align: center;
padding: 30px 40px;
background-color: #fff;
border-radius: 20px;
margin-bottom: 20px;
max-width: 538px;
width: 100%;
box-shadow: 0 13px 34px 0 rgba(167, 187, 242, 0.2);
box-sizing: border-box;
}
#status-heading {
font-size: 24px;
font-weight: 700;
color: #02004E;
margin-bottom: 20px;
}
h2 {
color: #333;
margin-bottom: 15px;
}
p {
color: #666;
font-size: 1.1em;
margin-bottom: 10px;
}
.tip {
font-weight: 300;
font-size: 17px;
line-height: 150%;
letter-spacing: 0;
text-align: center;
margin-top: 30px;
}
.loader-container {
position: relative;
display: flex;
justify-content: center;
align-items: center;
}
.loader {
width: 100px;
aspect-ratio: 1;
border-radius: 50%;
background:
radial-gradient(farthest-side, #5C7EF1 94%, #0000) top/8px 8px no-repeat,
conic-gradient(#0000 30%, #5C7EF1);
-webkit-mask: radial-gradient(farthest-side, #0000 calc(100% - 8px), #000 0);
animation: l13 2s infinite linear;
}
@keyframes l13 {
100% {
transform: rotate(1turn)
}
}
.app-logo {
position: absolute;
width: 36px;
}
.panel {
padding: 0 18px;
display: none;
background-color: white;
overflow: hidden;
margin-top: 10px;
}
.show {
display: block;
}
.project-info {
border: 1px solid #8C9DFF;
border-radius: 10px;
padding: 12px 16px;
max-width: 600px;
margin: 40px auto;
background-color: #FBFCFF;
}
.project-info h2 {
color: #02004E;
font-size: 14px;
font-weight: 500;
margin-bottom: 10px;
text-align: left;
}
.project-info p {
color: #686791;
font-size: 12px;
font-weight: 400;
text-align: left;
}
</style>
</head>
<body>
<div class="container">
<h2 id="status-heading">Loading the app, just a moment…</h2>
<p class="tip">The application is currently launching. The page will automatically refresh once site is
available.</p>
<div class="project-info">
<h2>CTPLERP</h2>
<p>A comprehensive HRMS + ATS platform for seamless employee management.</p>
</div>
<div class="loader-container">
<img src="https://flatlogic.com/blog/wp-content/uploads/2025/05/logo-bot-1.png" alt="App Logo"
class="app-logo">
<div class="loader"></div>
</div>
<div class="panel">
<video width="100%" height="315" controls loop>
<source
src="https://flatlogic.com/blog/wp-content/uploads/2025/04/20250430_1336_professional_dynamo_spinner_simple_compose_01jt349yvtenxt7xhg8hhr85j8.mp4"
type="video/mp4">
Your browser does not support the video tag.
</video>
</div>
</div>
<script>
function checkAvailability() {
fetch('/')
.then(response => {
if (response.ok) {
window.location.reload();
} else {
setTimeout(checkAvailability, 5000);
}
})
.catch(() => {
setTimeout(checkAvailability, 5000);
});
}
document.addEventListener('DOMContentLoaded', checkAvailability);
document.addEventListener('DOMContentLoaded', function () {
const appTitle = document.querySelector('#status-heading');
const panel = document.querySelector('.panel');
const video = panel.querySelector('video');
let clickCount = 0;
appTitle.addEventListener('click', function () {
clickCount++;
if (clickCount === 5) {
panel.classList.toggle('show');
if (panel.classList.contains('show')) {
video.play();
} else {
video.pause();
}
clickCount = 0;
}
});
});
</script>
</body>
</html>

17
Dockerfile Normal file
View File

@ -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"]

85
Dockerfile.dev Normal file
View File

@ -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"]

1
LICENSE Normal file
View File

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

200
README.md Normal file
View File

@ -0,0 +1,200 @@
# CTPLERP
## This project was generated by [Flatlogic Platform](https://flatlogic.com).
- Frontend: [React.js](https://flatlogic.com/templates?framework%5B%5D=react&sort=default)
- Backend: [NodeJS](https://flatlogic.com/templates?backend%5B%5D=nodejs&sort=default)
<details><summary>Backend Folder Structure</summary>
The generated application has the following backend folder structure:
`src` folder which contains your working files that will be used later to create the build. The src folder contains folders as:
- `auth` - config the library for authentication and authorization;
- `db` - contains such folders as:
- `api` - documentation that is automatically generated by jsdoc or other tools;
- `migrations` - is a skeleton of the database or all the actions that users do with the database;
- `models`- what will represent the database for the backend;
- `seeders` - the entity that creates the data for the database.
- `routes` - this folder would contain all the routes that you have created using Express Router and what they do would be exported from a Controller file;
- `services` - contains such folders as `emails` and `notifications`.
</details>
- Database: PostgreSQL
- app-shel: Core application framework that provides essential infrastructure services
for the entire application.
-----------------------
### We offer 2 ways how to start the project locally: by running Frontend and Backend or with Docker.
-----------------------
## To start the project:
### Backend:
> Please change current folder: `cd backend`
#### Install local dependencies:
`yarn install`
------------
#### Adjust local db:
##### 1. Install postgres:
MacOS:
`brew install postgres`
> if you dont 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 youve 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`

26
app-shell/.eslintrc.cjs Normal file
View File

@ -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',
},
},
];

11
app-shell/.prettierrc Normal file
View File

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

7
app-shell/.sequelizerc Normal file
View File

@ -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")
};

23
app-shell/Dockerfile Normal file
View File

@ -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" ]

13
app-shell/README.md Normal file
View File

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

43
app-shell/package.json Normal file
View File

@ -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"
}
}

File diff suppressed because one or more lines are too long

18
app-shell/src/config.js Normal file
View File

@ -0,0 +1,18 @@
const config = {
admin_pass: "1ee96857",
admin_email: "admin@flatlogic.com",
schema_encryption_key: process.env.SCHEMA_ENCRYPTION_KEY || '',
project_uuid: '1ee96857-e87a-431f-9118-b2ad6ee7f151',
flHost: process.env.NODE_ENV === 'production' ? 'https://flatlogic.com/projects' : 'http://localhost:3000/projects',
gitea_domain: process.env.GITEA_DOMAIN || 'gitea.flatlogic.app',
gitea_username: process.env.GITEA_USERNAME || 'admin',
gitea_api_token: process.env.GITEA_API_TOKEN || null,
github_repo_url: process.env.GITHUB_REPO_URL || null,
github_token: process.env.GITHUB_TOKEN || null,
};
module.exports = config;

23
app-shell/src/helpers.js Normal file
View File

@ -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' });
}
};

54
app-shell/src/index.js Normal file
View File

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

View File

@ -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;

View File

@ -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;

View File

@ -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;

View File

@ -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;

View File

@ -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();

File diff suppressed because it is too large Load Diff

View File

@ -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;
}
};

View File

@ -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;
}
};

View File

@ -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;

View File

@ -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;

View File

@ -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;

View File

@ -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 };

File diff suppressed because it is too large Load Diff

3044
app-shell/yarn.lock Normal file

File diff suppressed because it is too large Load Diff

11
backend/.prettierrc Normal file
View File

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

7
backend/.sequelizerc Normal file
View File

@ -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")
};

23
backend/Dockerfile Normal file
View File

@ -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" ]

67
backend/README.md Normal file
View File

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

53
backend/package.json Normal file
View File

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

79
backend/src/auth/auth.js Normal file
View File

@ -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 });
});
}

77
backend/src/config.js Normal file
View File

@ -0,0 +1,77 @@
const os = require('os');
const config = {
gcloud: {
bucket: 'fldemo-files',
hash: 'f9dbaa9b3e36fc0b0e8da83ac913a37d',
},
bcrypt: {
saltRounds: 12,
},
admin_pass: '1ee96857',
user_pass: 'b2ad6ee7f151',
admin_email: 'admin@flatlogic.com',
providers: {
LOCAL: 'local',
GOOGLE: 'google',
MICROSOFT: 'microsoft',
},
secret_key: process.env.SECRET_KEY || '',
remote: '',
port: process.env.NODE_ENV === 'production' ? '' : '8080',
hostUI: process.env.NODE_ENV === 'production' ? '' : 'http://localhost',
portUI: process.env.NODE_ENV === 'production' ? '' : '3000',
portUIProd: process.env.NODE_ENV === 'production' ? '' : ':3000',
swaggerUI: process.env.NODE_ENV === 'production' ? '' : 'http://localhost',
swaggerPort: process.env.NODE_ENV === 'production' ? '' : ':8080',
google: {
clientId: process.env.GOOGLE_CLIENT_ID || '',
clientSecret: process.env.GOOGLE_CLIENT_SECRET || '',
},
microsoft: {
clientId: process.env.MS_CLIENT_ID || '',
clientSecret: process.env.MS_CLIENT_SECRET || '',
},
uploadDir: os.tmpdir(),
email: {
from: 'CTPLERP <app@flatlogic.app>',
host: 'email-smtp.us-east-1.amazonaws.com',
port: 587,
auth: {
user: process.env.EMAIL_USER || '',
pass: process.env.EMAIL_PASS,
},
tls: {
rejectUnauthorized: false,
},
},
roles: {
super_admin: 'Super Administrator',
admin: 'Administrator',
user: 'Finance Analyst',
},
project_uuid: '1ee96857-e87a-431f-9118-b2ad6ee7f151',
flHost:
process.env.NODE_ENV === 'production' ||
process.env.NODE_ENV === 'dev_stage'
? 'https://flatlogic.com/projects'
: 'http://localhost:3000/projects',
gpt_key: process.env.GPT_KEY || '',
};
config.pexelsKey = process.env.PEXELS_KEY || '';
config.pexelsQuery = 'Abstract teamwork concept illustration';
config.host =
process.env.NODE_ENV === 'production' ? config.remote : 'http://localhost';
config.apiUrl = `${config.host}${config.port ? `:${config.port}` : ``}/api`;
config.swaggerUrl = `${config.swaggerUI}${config.swaggerPort}`;
config.uiUrl = `${config.hostUI}${config.portUI ? `:${config.portUI}` : ``}/#`;
config.backUrl = `${config.hostUI}${config.portUI ? `:${config.portUI}` : ``}`;
module.exports = config;

View File

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

View File

@ -0,0 +1,435 @@
const db = require('../models');
const FileDBApi = require('./file');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class ApplicationsDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const applications = await db.applications.create(
{
id: data.id || undefined,
submitted_at: data.submitted_at || null,
status: data.status || null,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
await applications.setCandidate(data.candidate || null, {
transaction,
});
await applications.setRequisition(data.requisition || null, {
transaction,
});
await applications.setOrganizations(data.organizations || null, {
transaction,
});
return applications;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const applicationsData = data.map((item, index) => ({
id: item.id || undefined,
submitted_at: item.submitted_at || null,
status: item.status || null,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const applications = await db.applications.bulkCreate(applicationsData, {
transaction,
});
// For each item created, replace relation files
return applications;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const globalAccess = currentUser.app_role?.globalAccess;
const applications = await db.applications.findByPk(
id,
{},
{ transaction },
);
const updatePayload = {};
if (data.submitted_at !== undefined)
updatePayload.submitted_at = data.submitted_at;
if (data.status !== undefined) updatePayload.status = data.status;
updatePayload.updatedById = currentUser.id;
await applications.update(updatePayload, { transaction });
if (data.candidate !== undefined) {
await applications.setCandidate(
data.candidate,
{ transaction },
);
}
if (data.requisition !== undefined) {
await applications.setRequisition(
data.requisition,
{ transaction },
);
}
if (data.organizations !== undefined) {
await applications.setOrganizations(
data.organizations,
{ transaction },
);
}
return applications;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const applications = await db.applications.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of applications) {
await record.update({ deletedBy: currentUser.id }, { transaction });
}
for (const record of applications) {
await record.destroy({ transaction });
}
});
return applications;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const applications = await db.applications.findByPk(id, options);
await applications.update(
{
deletedBy: currentUser.id,
},
{
transaction,
},
);
await applications.destroy({
transaction,
});
return applications;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const applications = await db.applications.findOne(
{ where },
{ transaction },
);
if (!applications) {
return applications;
}
const output = applications.get({ plain: true });
output.interviews_application =
await applications.getInterviews_application({
transaction,
});
output.offers_application = await applications.getOffers_application({
transaction,
});
output.candidate = await applications.getCandidate({
transaction,
});
output.requisition = await applications.getRequisition({
transaction,
});
output.organizations = await applications.getOrganizations({
transaction,
});
return output;
}
static async findAll(filter, globalAccess, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
const userOrganizations = (user && user.organizations?.id) || null;
if (userOrganizations) {
if (options?.currentUser?.organizationsId) {
where.organizationsId = options.currentUser.organizationsId;
}
}
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [
{
model: db.candidates,
as: 'candidate',
where: filter.candidate
? {
[Op.or]: [
{
id: {
[Op.in]: filter.candidate
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
name: {
[Op.or]: filter.candidate
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.job_requisitions,
as: 'requisition',
where: filter.requisition
? {
[Op.or]: [
{
id: {
[Op.in]: filter.requisition
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
title: {
[Op.or]: filter.requisition
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.organizations,
as: 'organizations',
},
];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.submitted_atRange) {
const [start, end] = filter.submitted_atRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
submitted_at: {
...where.submitted_at,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
submitted_at: {
...where.submitted_at,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true',
};
}
if (filter.status) {
where = {
...where,
status: filter.status,
};
}
if (filter.organizations) {
const listItems = filter.organizations.split('|').map((item) => {
return Utils.uuid(item);
});
where = {
...where,
organizationsId: { [Op.or]: listItems },
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
if (globalAccess) {
delete where.organizationsId;
}
const queryOptions = {
where,
include,
distinct: true,
order:
filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log,
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.applications.findAndCountAll(
queryOptions,
);
return {
rows: options?.countOnly ? [] : rows,
count: count,
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(
query,
limit,
offset,
globalAccess,
organizationId,
) {
let where = {};
if (!globalAccess && organizationId) {
where.organizationId = organizationId;
}
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike('applications', 'status', query),
],
};
}
const records = await db.applications.findAll({
attributes: ['id', 'status'],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['status', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.status,
}));
}
};

View File

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

View File

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

View File

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

467
backend/src/db/api/bills.js Normal file
View File

@ -0,0 +1,467 @@
const db = require('../models');
const FileDBApi = require('./file');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class BillsDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const bills = await db.bills.create(
{
id: data.id || undefined,
invoice_no: data.invoice_no || null,
invoice_date: data.invoice_date || null,
due_date: data.due_date || null,
amount: data.amount || null,
currency: data.currency || null,
category: data.category || null,
status: data.status || null,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
await bills.setVendor(data.vendor || null, {
transaction,
});
await bills.setOrganizations(data.organizations || null, {
transaction,
});
return bills;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const billsData = data.map((item, index) => ({
id: item.id || undefined,
invoice_no: item.invoice_no || null,
invoice_date: item.invoice_date || null,
due_date: item.due_date || null,
amount: item.amount || null,
currency: item.currency || null,
category: item.category || null,
status: item.status || null,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const bills = await db.bills.bulkCreate(billsData, { transaction });
// For each item created, replace relation files
return bills;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const globalAccess = currentUser.app_role?.globalAccess;
const bills = await db.bills.findByPk(id, {}, { transaction });
const updatePayload = {};
if (data.invoice_no !== undefined)
updatePayload.invoice_no = data.invoice_no;
if (data.invoice_date !== undefined)
updatePayload.invoice_date = data.invoice_date;
if (data.due_date !== undefined) updatePayload.due_date = data.due_date;
if (data.amount !== undefined) updatePayload.amount = data.amount;
if (data.currency !== undefined) updatePayload.currency = data.currency;
if (data.category !== undefined) updatePayload.category = data.category;
if (data.status !== undefined) updatePayload.status = data.status;
updatePayload.updatedById = currentUser.id;
await bills.update(updatePayload, { transaction });
if (data.vendor !== undefined) {
await bills.setVendor(
data.vendor,
{ transaction },
);
}
if (data.organizations !== undefined) {
await bills.setOrganizations(
data.organizations,
{ transaction },
);
}
return bills;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const bills = await db.bills.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of bills) {
await record.update({ deletedBy: currentUser.id }, { transaction });
}
for (const record of bills) {
await record.destroy({ transaction });
}
});
return bills;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const bills = await db.bills.findByPk(id, options);
await bills.update(
{
deletedBy: currentUser.id,
},
{
transaction,
},
);
await bills.destroy({
transaction,
});
return bills;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const bills = await db.bills.findOne({ where }, { transaction });
if (!bills) {
return bills;
}
const output = bills.get({ plain: true });
output.payments_bill = await bills.getPayments_bill({
transaction,
});
output.vendor = await bills.getVendor({
transaction,
});
output.organizations = await bills.getOrganizations({
transaction,
});
return output;
}
static async findAll(filter, globalAccess, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
const userOrganizations = (user && user.organizations?.id) || null;
if (userOrganizations) {
if (options?.currentUser?.organizationsId) {
where.organizationsId = options.currentUser.organizationsId;
}
}
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [
{
model: db.vendors,
as: 'vendor',
where: filter.vendor
? {
[Op.or]: [
{
id: {
[Op.in]: filter.vendor
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
name: {
[Op.or]: filter.vendor
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.organizations,
as: 'organizations',
},
];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.invoice_no) {
where = {
...where,
[Op.and]: Utils.ilike('bills', 'invoice_no', filter.invoice_no),
};
}
if (filter.currency) {
where = {
...where,
[Op.and]: Utils.ilike('bills', 'currency', filter.currency),
};
}
if (filter.category) {
where = {
...where,
[Op.and]: Utils.ilike('bills', 'category', filter.category),
};
}
if (filter.invoice_dateRange) {
const [start, end] = filter.invoice_dateRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
invoice_date: {
...where.invoice_date,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
invoice_date: {
...where.invoice_date,
[Op.lte]: end,
},
};
}
}
if (filter.due_dateRange) {
const [start, end] = filter.due_dateRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
due_date: {
...where.due_date,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
due_date: {
...where.due_date,
[Op.lte]: end,
},
};
}
}
if (filter.amountRange) {
const [start, end] = filter.amountRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
amount: {
...where.amount,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
amount: {
...where.amount,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true',
};
}
if (filter.status) {
where = {
...where,
status: filter.status,
};
}
if (filter.organizations) {
const listItems = filter.organizations.split('|').map((item) => {
return Utils.uuid(item);
});
where = {
...where,
organizationsId: { [Op.or]: listItems },
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
if (globalAccess) {
delete where.organizationsId;
}
const queryOptions = {
where,
include,
distinct: true,
order:
filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log,
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.bills.findAndCountAll(queryOptions);
return {
rows: options?.countOnly ? [] : rows,
count: count,
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(
query,
limit,
offset,
globalAccess,
organizationId,
) {
let where = {};
if (!globalAccess && organizationId) {
where.organizationId = organizationId;
}
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike('bills', 'invoice_no', query),
],
};
}
const records = await db.bills.findAll({
attributes: ['id', 'invoice_no'],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['invoice_no', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.invoice_no,
}));
}
};

View File

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

394
backend/src/db/api/cards.js Normal file
View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -0,0 +1,496 @@
const db = require('../models');
const FileDBApi = require('./file');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class EarningsDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const earnings = await db.earnings.create(
{
id: data.id || undefined,
component: data.component || null,
units: data.units || null,
rate: data.rate || null,
amount: data.amount || null,
currency: data.currency || null,
taxable: data.taxable || false,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
await earnings.setPayroll_run(data.payroll_run || null, {
transaction,
});
await earnings.setEmployee(data.employee || null, {
transaction,
});
await earnings.setOrganizations(data.organizations || null, {
transaction,
});
return earnings;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const earningsData = data.map((item, index) => ({
id: item.id || undefined,
component: item.component || null,
units: item.units || null,
rate: item.rate || null,
amount: item.amount || null,
currency: item.currency || null,
taxable: item.taxable || false,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const earnings = await db.earnings.bulkCreate(earningsData, {
transaction,
});
// For each item created, replace relation files
return earnings;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const globalAccess = currentUser.app_role?.globalAccess;
const earnings = await db.earnings.findByPk(id, {}, { transaction });
const updatePayload = {};
if (data.component !== undefined) updatePayload.component = data.component;
if (data.units !== undefined) updatePayload.units = data.units;
if (data.rate !== undefined) updatePayload.rate = data.rate;
if (data.amount !== undefined) updatePayload.amount = data.amount;
if (data.currency !== undefined) updatePayload.currency = data.currency;
if (data.taxable !== undefined) updatePayload.taxable = data.taxable;
updatePayload.updatedById = currentUser.id;
await earnings.update(updatePayload, { transaction });
if (data.payroll_run !== undefined) {
await earnings.setPayroll_run(
data.payroll_run,
{ transaction },
);
}
if (data.employee !== undefined) {
await earnings.setEmployee(
data.employee,
{ transaction },
);
}
if (data.organizations !== undefined) {
await earnings.setOrganizations(
data.organizations,
{ transaction },
);
}
return earnings;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const earnings = await db.earnings.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of earnings) {
await record.update({ deletedBy: currentUser.id }, { transaction });
}
for (const record of earnings) {
await record.destroy({ transaction });
}
});
return earnings;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const earnings = await db.earnings.findByPk(id, options);
await earnings.update(
{
deletedBy: currentUser.id,
},
{
transaction,
},
);
await earnings.destroy({
transaction,
});
return earnings;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const earnings = await db.earnings.findOne({ where }, { transaction });
if (!earnings) {
return earnings;
}
const output = earnings.get({ plain: true });
output.payroll_run = await earnings.getPayroll_run({
transaction,
});
output.employee = await earnings.getEmployee({
transaction,
});
output.organizations = await earnings.getOrganizations({
transaction,
});
return output;
}
static async findAll(filter, globalAccess, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
const userOrganizations = (user && user.organizations?.id) || null;
if (userOrganizations) {
if (options?.currentUser?.organizationsId) {
where.organizationsId = options.currentUser.organizationsId;
}
}
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [
{
model: db.payroll_runs,
as: 'payroll_run',
where: filter.payroll_run
? {
[Op.or]: [
{
id: {
[Op.in]: filter.payroll_run
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
country: {
[Op.or]: filter.payroll_run
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.employees,
as: 'employee',
where: filter.employee
? {
[Op.or]: [
{
id: {
[Op.in]: filter.employee
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
user: {
[Op.or]: filter.employee
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.organizations,
as: 'organizations',
},
];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.component) {
where = {
...where,
[Op.and]: Utils.ilike('earnings', 'component', filter.component),
};
}
if (filter.currency) {
where = {
...where,
[Op.and]: Utils.ilike('earnings', 'currency', filter.currency),
};
}
if (filter.unitsRange) {
const [start, end] = filter.unitsRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
units: {
...where.units,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
units: {
...where.units,
[Op.lte]: end,
},
};
}
}
if (filter.rateRange) {
const [start, end] = filter.rateRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
rate: {
...where.rate,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
rate: {
...where.rate,
[Op.lte]: end,
},
};
}
}
if (filter.amountRange) {
const [start, end] = filter.amountRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
amount: {
...where.amount,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
amount: {
...where.amount,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true',
};
}
if (filter.taxable) {
where = {
...where,
taxable: filter.taxable,
};
}
if (filter.organizations) {
const listItems = filter.organizations.split('|').map((item) => {
return Utils.uuid(item);
});
where = {
...where,
organizationsId: { [Op.or]: listItems },
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
if (globalAccess) {
delete where.organizationsId;
}
const queryOptions = {
where,
include,
distinct: true,
order:
filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log,
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.earnings.findAndCountAll(queryOptions);
return {
rows: options?.countOnly ? [] : rows,
count: count,
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(
query,
limit,
offset,
globalAccess,
organizationId,
) {
let where = {};
if (!globalAccess && organizationId) {
where.organizationId = organizationId;
}
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike('earnings', 'component', query),
],
};
}
const records = await db.earnings.findAll({
attributes: ['id', 'component'],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['component', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.component,
}));
}
};

View File

@ -0,0 +1,644 @@
const db = require('../models');
const FileDBApi = require('./file');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class EmployeesDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const employees = await db.employees.create(
{
id: data.id || undefined,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
await employees.setUser(data.user || null, {
transaction,
});
await employees.setOrganizations(data.organizations || null, {
transaction,
});
await employees.setEmployments(data.employments || [], {
transaction,
});
await employees.setPositions(data.positions || [], {
transaction,
});
await employees.setCompensations(data.compensations || [], {
transaction,
});
await employees.setDocuments(data.documents || [], {
transaction,
});
return employees;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const employeesData = data.map((item, index) => ({
id: item.id || undefined,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const employees = await db.employees.bulkCreate(employeesData, {
transaction,
});
// For each item created, replace relation files
return employees;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const globalAccess = currentUser.app_role?.globalAccess;
const employees = await db.employees.findByPk(id, {}, { transaction });
const updatePayload = {};
updatePayload.updatedById = currentUser.id;
await employees.update(updatePayload, { transaction });
if (data.user !== undefined) {
await employees.setUser(
data.user,
{ transaction },
);
}
if (data.organizations !== undefined) {
await employees.setOrganizations(
data.organizations,
{ transaction },
);
}
if (data.employments !== undefined) {
await employees.setEmployments(data.employments, { transaction });
}
if (data.positions !== undefined) {
await employees.setPositions(data.positions, { transaction });
}
if (data.compensations !== undefined) {
await employees.setCompensations(data.compensations, { transaction });
}
if (data.documents !== undefined) {
await employees.setDocuments(data.documents, { transaction });
}
return employees;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const employees = await db.employees.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of employees) {
await record.update({ deletedBy: currentUser.id }, { transaction });
}
for (const record of employees) {
await record.destroy({ transaction });
}
});
return employees;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const employees = await db.employees.findByPk(id, options);
await employees.update(
{
deletedBy: currentUser.id,
},
{
transaction,
},
);
await employees.destroy({
transaction,
});
return employees;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const employees = await db.employees.findOne({ where }, { transaction });
if (!employees) {
return employees;
}
const output = employees.get({ plain: true });
output.app_accounts_employee = await employees.getApp_accounts_employee({
transaction,
});
output.approvals_approver = await employees.getApprovals_approver({
transaction,
});
output.cards_employee = await employees.getCards_employee({
transaction,
});
output.compensations_employee = await employees.getCompensations_employee({
transaction,
});
output.deductions_employee = await employees.getDeductions_employee({
transaction,
});
output.devices_owner = await employees.getDevices_owner({
transaction,
});
output.documents_owner = await employees.getDocuments_owner({
transaction,
});
output.earnings_employee = await employees.getEarnings_employee({
transaction,
});
output.employments_employee = await employees.getEmployments_employee({
transaction,
});
output.enrollment_learnings_employee =
await employees.getEnrollment_learnings_employee({
transaction,
});
output.enrollment_learnings_assigned_by =
await employees.getEnrollment_learnings_assigned_by({
transaction,
});
output.enrollments_employee = await employees.getEnrollments_employee({
transaction,
});
output.expense_reports_employee =
await employees.getExpense_reports_employee({
transaction,
});
output.goals_employee = await employees.getGoals_employee({
transaction,
});
output.identity_accounts_employee =
await employees.getIdentity_accounts_employee({
transaction,
});
output.interviews_interviewer = await employees.getInterviews_interviewer({
transaction,
});
output.job_requisitions_recruiter =
await employees.getJob_requisitions_recruiter({
transaction,
});
output.leave_requests_employee = await employees.getLeave_requests_employee(
{
transaction,
},
);
output.positions_manager = await employees.getPositions_manager({
transaction,
});
output.reviews_employee = await employees.getReviews_employee({
transaction,
});
output.reviews_reviewer = await employees.getReviews_reviewer({
transaction,
});
output.schedule_shifts_employee =
await employees.getSchedule_shifts_employee({
transaction,
});
output.taxes_employee = await employees.getTaxes_employee({
transaction,
});
output.timecards_employee = await employees.getTimecards_employee({
transaction,
});
output.travel_bookings_employee =
await employees.getTravel_bookings_employee({
transaction,
});
output.user = await employees.getUser({
transaction,
});
output.employments = await employees.getEmployments({
transaction,
});
output.positions = await employees.getPositions({
transaction,
});
output.compensations = await employees.getCompensations({
transaction,
});
output.documents = await employees.getDocuments({
transaction,
});
output.organizations = await employees.getOrganizations({
transaction,
});
return output;
}
static async findAll(filter, globalAccess, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
const userOrganizations = (user && user.organizations?.id) || null;
if (userOrganizations) {
if (options?.currentUser?.organizationsId) {
where.organizationsId = options.currentUser.organizationsId;
}
}
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [
{
model: db.users,
as: 'user',
where: filter.user
? {
[Op.or]: [
{
id: {
[Op.in]: filter.user
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
firstName: {
[Op.or]: filter.user
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.organizations,
as: 'organizations',
},
{
model: db.employments,
as: 'employments',
required: false,
},
{
model: db.positions,
as: 'positions',
required: false,
},
{
model: db.compensations,
as: 'compensations',
required: false,
},
{
model: db.documents,
as: 'documents',
required: false,
},
];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true',
};
}
if (filter.organizations) {
const listItems = filter.organizations.split('|').map((item) => {
return Utils.uuid(item);
});
where = {
...where,
organizationsId: { [Op.or]: listItems },
};
}
if (filter.employments) {
const searchTerms = filter.employments.split('|');
include = [
{
model: db.employments,
as: 'employments_filter',
required: searchTerms.length > 0,
where:
searchTerms.length > 0
? {
[Op.or]: [
{
id: {
[Op.in]: searchTerms.map((term) => Utils.uuid(term)),
},
},
{
employment_type: {
[Op.or]: searchTerms.map((term) => ({
[Op.iLike]: `%${term}%`,
})),
},
},
],
}
: undefined,
},
...include,
];
}
if (filter.positions) {
const searchTerms = filter.positions.split('|');
include = [
{
model: db.positions,
as: 'positions_filter',
required: searchTerms.length > 0,
where:
searchTerms.length > 0
? {
[Op.or]: [
{
id: {
[Op.in]: searchTerms.map((term) => Utils.uuid(term)),
},
},
{
title: {
[Op.or]: searchTerms.map((term) => ({
[Op.iLike]: `%${term}%`,
})),
},
},
],
}
: undefined,
},
...include,
];
}
if (filter.compensations) {
const searchTerms = filter.compensations.split('|');
include = [
{
model: db.compensations,
as: 'compensations_filter',
required: searchTerms.length > 0,
where:
searchTerms.length > 0
? {
[Op.or]: [
{
id: {
[Op.in]: searchTerms.map((term) => Utils.uuid(term)),
},
},
{
base_pay: {
[Op.or]: searchTerms.map((term) => ({
[Op.iLike]: `%${term}%`,
})),
},
},
],
}
: undefined,
},
...include,
];
}
if (filter.documents) {
const searchTerms = filter.documents.split('|');
include = [
{
model: db.documents,
as: 'documents_filter',
required: searchTerms.length > 0,
where:
searchTerms.length > 0
? {
[Op.or]: [
{
id: {
[Op.in]: searchTerms.map((term) => Utils.uuid(term)),
},
},
{
doc_type: {
[Op.or]: searchTerms.map((term) => ({
[Op.iLike]: `%${term}%`,
})),
},
},
],
}
: undefined,
},
...include,
];
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
if (globalAccess) {
delete where.organizationsId;
}
const queryOptions = {
where,
include,
distinct: true,
order:
filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log,
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.employees.findAndCountAll(queryOptions);
return {
rows: options?.countOnly ? [] : rows,
count: count,
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(
query,
limit,
offset,
globalAccess,
organizationId,
) {
let where = {};
if (!globalAccess && organizationId) {
where.organizationId = organizationId;
}
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike('employees', 'user', query),
],
};
}
const records = await db.employees.findAll({
attributes: ['id', 'user'],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['user', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.user,
}));
}
};

View File

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

View File

@ -0,0 +1,471 @@
const db = require('../models');
const FileDBApi = require('./file');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class Enrollment_learningsDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const enrollment_learnings = await db.enrollment_learnings.create(
{
id: data.id || undefined,
due_date: data.due_date || null,
status: data.status || null,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
await enrollment_learnings.setEmployee(data.employee || null, {
transaction,
});
await enrollment_learnings.setCourse(data.course || null, {
transaction,
});
await enrollment_learnings.setAssigned_by(data.assigned_by || null, {
transaction,
});
await enrollment_learnings.setOrganizations(data.organizations || null, {
transaction,
});
return enrollment_learnings;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const enrollment_learningsData = data.map((item, index) => ({
id: item.id || undefined,
due_date: item.due_date || null,
status: item.status || null,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const enrollment_learnings = await db.enrollment_learnings.bulkCreate(
enrollment_learningsData,
{ transaction },
);
// For each item created, replace relation files
return enrollment_learnings;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const globalAccess = currentUser.app_role?.globalAccess;
const enrollment_learnings = await db.enrollment_learnings.findByPk(
id,
{},
{ transaction },
);
const updatePayload = {};
if (data.due_date !== undefined) updatePayload.due_date = data.due_date;
if (data.status !== undefined) updatePayload.status = data.status;
updatePayload.updatedById = currentUser.id;
await enrollment_learnings.update(updatePayload, { transaction });
if (data.employee !== undefined) {
await enrollment_learnings.setEmployee(
data.employee,
{ transaction },
);
}
if (data.course !== undefined) {
await enrollment_learnings.setCourse(
data.course,
{ transaction },
);
}
if (data.assigned_by !== undefined) {
await enrollment_learnings.setAssigned_by(
data.assigned_by,
{ transaction },
);
}
if (data.organizations !== undefined) {
await enrollment_learnings.setOrganizations(
data.organizations,
{ transaction },
);
}
return enrollment_learnings;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const enrollment_learnings = await db.enrollment_learnings.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of enrollment_learnings) {
await record.update({ deletedBy: currentUser.id }, { transaction });
}
for (const record of enrollment_learnings) {
await record.destroy({ transaction });
}
});
return enrollment_learnings;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const enrollment_learnings = await db.enrollment_learnings.findByPk(
id,
options,
);
await enrollment_learnings.update(
{
deletedBy: currentUser.id,
},
{
transaction,
},
);
await enrollment_learnings.destroy({
transaction,
});
return enrollment_learnings;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const enrollment_learnings = await db.enrollment_learnings.findOne(
{ where },
{ transaction },
);
if (!enrollment_learnings) {
return enrollment_learnings;
}
const output = enrollment_learnings.get({ plain: true });
output.employee = await enrollment_learnings.getEmployee({
transaction,
});
output.course = await enrollment_learnings.getCourse({
transaction,
});
output.assigned_by = await enrollment_learnings.getAssigned_by({
transaction,
});
output.organizations = await enrollment_learnings.getOrganizations({
transaction,
});
return output;
}
static async findAll(filter, globalAccess, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
const userOrganizations = (user && user.organizations?.id) || null;
if (userOrganizations) {
if (options?.currentUser?.organizationsId) {
where.organizationsId = options.currentUser.organizationsId;
}
}
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [
{
model: db.employees,
as: 'employee',
where: filter.employee
? {
[Op.or]: [
{
id: {
[Op.in]: filter.employee
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
user: {
[Op.or]: filter.employee
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.learning_courses,
as: 'course',
where: filter.course
? {
[Op.or]: [
{
id: {
[Op.in]: filter.course
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
title: {
[Op.or]: filter.course
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.employees,
as: 'assigned_by',
where: filter.assigned_by
? {
[Op.or]: [
{
id: {
[Op.in]: filter.assigned_by
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
user: {
[Op.or]: filter.assigned_by
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.organizations,
as: 'organizations',
},
];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.due_dateRange) {
const [start, end] = filter.due_dateRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
due_date: {
...where.due_date,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
due_date: {
...where.due_date,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true',
};
}
if (filter.status) {
where = {
...where,
status: filter.status,
};
}
if (filter.organizations) {
const listItems = filter.organizations.split('|').map((item) => {
return Utils.uuid(item);
});
where = {
...where,
organizationsId: { [Op.or]: listItems },
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
if (globalAccess) {
delete where.organizationsId;
}
const queryOptions = {
where,
include,
distinct: true,
order:
filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log,
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.enrollment_learnings.findAndCountAll(
queryOptions,
);
return {
rows: options?.countOnly ? [] : rows,
count: count,
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(
query,
limit,
offset,
globalAccess,
organizationId,
) {
let where = {};
if (!globalAccess && organizationId) {
where.organizationId = organizationId;
}
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike('enrollment_learnings', 'course', query),
],
};
}
const records = await db.enrollment_learnings.findAll({
attributes: ['id', 'course'],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['course', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.course,
}));
}
};

View File

@ -0,0 +1,480 @@
const db = require('../models');
const FileDBApi = require('./file');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class EnrollmentsDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const enrollments = await db.enrollments.create(
{
id: data.id || undefined,
effective_date: data.effective_date || null,
premium_employee: data.premium_employee || null,
premium_employer: data.premium_employer || null,
status: data.status || null,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
await enrollments.setEmployee(data.employee || null, {
transaction,
});
await enrollments.setPlan(data.plan || null, {
transaction,
});
await enrollments.setOrganizations(data.organizations || null, {
transaction,
});
return enrollments;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const enrollmentsData = data.map((item, index) => ({
id: item.id || undefined,
effective_date: item.effective_date || null,
premium_employee: item.premium_employee || null,
premium_employer: item.premium_employer || null,
status: item.status || null,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const enrollments = await db.enrollments.bulkCreate(enrollmentsData, {
transaction,
});
// For each item created, replace relation files
return enrollments;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const globalAccess = currentUser.app_role?.globalAccess;
const enrollments = await db.enrollments.findByPk(id, {}, { transaction });
const updatePayload = {};
if (data.effective_date !== undefined)
updatePayload.effective_date = data.effective_date;
if (data.premium_employee !== undefined)
updatePayload.premium_employee = data.premium_employee;
if (data.premium_employer !== undefined)
updatePayload.premium_employer = data.premium_employer;
if (data.status !== undefined) updatePayload.status = data.status;
updatePayload.updatedById = currentUser.id;
await enrollments.update(updatePayload, { transaction });
if (data.employee !== undefined) {
await enrollments.setEmployee(
data.employee,
{ transaction },
);
}
if (data.plan !== undefined) {
await enrollments.setPlan(
data.plan,
{ transaction },
);
}
if (data.organizations !== undefined) {
await enrollments.setOrganizations(
data.organizations,
{ transaction },
);
}
return enrollments;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const enrollments = await db.enrollments.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of enrollments) {
await record.update({ deletedBy: currentUser.id }, { transaction });
}
for (const record of enrollments) {
await record.destroy({ transaction });
}
});
return enrollments;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const enrollments = await db.enrollments.findByPk(id, options);
await enrollments.update(
{
deletedBy: currentUser.id,
},
{
transaction,
},
);
await enrollments.destroy({
transaction,
});
return enrollments;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const enrollments = await db.enrollments.findOne(
{ where },
{ transaction },
);
if (!enrollments) {
return enrollments;
}
const output = enrollments.get({ plain: true });
output.employee = await enrollments.getEmployee({
transaction,
});
output.plan = await enrollments.getPlan({
transaction,
});
output.organizations = await enrollments.getOrganizations({
transaction,
});
return output;
}
static async findAll(filter, globalAccess, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
const userOrganizations = (user && user.organizations?.id) || null;
if (userOrganizations) {
if (options?.currentUser?.organizationsId) {
where.organizationsId = options.currentUser.organizationsId;
}
}
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [
{
model: db.employees,
as: 'employee',
where: filter.employee
? {
[Op.or]: [
{
id: {
[Op.in]: filter.employee
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
user: {
[Op.or]: filter.employee
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.benefit_plans,
as: 'plan',
where: filter.plan
? {
[Op.or]: [
{
id: {
[Op.in]: filter.plan
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
carrier: {
[Op.or]: filter.plan
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.organizations,
as: 'organizations',
},
];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.effective_dateRange) {
const [start, end] = filter.effective_dateRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
effective_date: {
...where.effective_date,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
effective_date: {
...where.effective_date,
[Op.lte]: end,
},
};
}
}
if (filter.premium_employeeRange) {
const [start, end] = filter.premium_employeeRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
premium_employee: {
...where.premium_employee,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
premium_employee: {
...where.premium_employee,
[Op.lte]: end,
},
};
}
}
if (filter.premium_employerRange) {
const [start, end] = filter.premium_employerRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
premium_employer: {
...where.premium_employer,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
premium_employer: {
...where.premium_employer,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true',
};
}
if (filter.status) {
where = {
...where,
status: filter.status,
};
}
if (filter.organizations) {
const listItems = filter.organizations.split('|').map((item) => {
return Utils.uuid(item);
});
where = {
...where,
organizationsId: { [Op.or]: listItems },
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
if (globalAccess) {
delete where.organizationsId;
}
const queryOptions = {
where,
include,
distinct: true,
order:
filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log,
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.enrollments.findAndCountAll(
queryOptions,
);
return {
rows: options?.countOnly ? [] : rows,
count: count,
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(
query,
limit,
offset,
globalAccess,
organizationId,
) {
let where = {};
if (!globalAccess && organizationId) {
where.organizationId = organizationId;
}
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike('enrollments', 'plan', query),
],
};
}
const records = await db.enrollments.findAll({
attributes: ['id', 'plan'],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['plan', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.plan,
}));
}
};

View File

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

View File

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

View File

@ -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,
});
}
}
};

496
backend/src/db/api/goals.js Normal file
View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -0,0 +1,478 @@
const db = require('../models');
const FileDBApi = require('./file');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class OrganizationsDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const organizations = await db.organizations.create(
{
id: data.id || undefined,
name: data.name || null,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
return organizations;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const organizationsData = data.map((item, index) => ({
id: item.id || undefined,
name: item.name || null,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const organizations = await db.organizations.bulkCreate(organizationsData, {
transaction,
});
// For each item created, replace relation files
return organizations;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const globalAccess = currentUser.app_role?.globalAccess;
const organizations = await db.organizations.findByPk(
id,
{},
{ transaction },
);
const updatePayload = {};
if (data.name !== undefined) updatePayload.name = data.name;
updatePayload.updatedById = currentUser.id;
await organizations.update(updatePayload, { transaction });
return organizations;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const organizations = await db.organizations.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of organizations) {
await record.update({ deletedBy: currentUser.id }, { transaction });
}
for (const record of organizations) {
await record.destroy({ transaction });
}
});
return organizations;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const organizations = await db.organizations.findByPk(id, options);
await organizations.update(
{
deletedBy: currentUser.id,
},
{
transaction,
},
);
await organizations.destroy({
transaction,
});
return organizations;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const organizations = await db.organizations.findOne(
{ where },
{ transaction },
);
if (!organizations) {
return organizations;
}
const output = organizations.get({ plain: true });
output.users_organizations = await organizations.getUsers_organizations({
transaction,
});
output.app_accounts_organizations =
await organizations.getApp_accounts_organizations({
transaction,
});
output.applications_organizations =
await organizations.getApplications_organizations({
transaction,
});
output.approvals_organizations =
await organizations.getApprovals_organizations({
transaction,
});
output.audit_logs_organizations =
await organizations.getAudit_logs_organizations({
transaction,
});
output.benefit_plans_organizations =
await organizations.getBenefit_plans_organizations({
transaction,
});
output.bills_organizations = await organizations.getBills_organizations({
transaction,
});
output.candidates_organizations =
await organizations.getCandidates_organizations({
transaction,
});
output.cards_organizations = await organizations.getCards_organizations({
transaction,
});
output.compensations_organizations =
await organizations.getCompensations_organizations({
transaction,
});
output.deductions_organizations =
await organizations.getDeductions_organizations({
transaction,
});
output.devices_organizations = await organizations.getDevices_organizations(
{
transaction,
},
);
output.documents_organizations =
await organizations.getDocuments_organizations({
transaction,
});
output.earnings_organizations =
await organizations.getEarnings_organizations({
transaction,
});
output.employees_organizations =
await organizations.getEmployees_organizations({
transaction,
});
output.employments_organizations =
await organizations.getEmployments_organizations({
transaction,
});
output.enrollment_learnings_organizations =
await organizations.getEnrollment_learnings_organizations({
transaction,
});
output.enrollments_organizations =
await organizations.getEnrollments_organizations({
transaction,
});
output.expense_lines_organizations =
await organizations.getExpense_lines_organizations({
transaction,
});
output.expense_reports_organizations =
await organizations.getExpense_reports_organizations({
transaction,
});
output.goals_organizations = await organizations.getGoals_organizations({
transaction,
});
output.identity_accounts_organizations =
await organizations.getIdentity_accounts_organizations({
transaction,
});
output.interviews_organizations =
await organizations.getInterviews_organizations({
transaction,
});
output.inventory_events_organizations =
await organizations.getInventory_events_organizations({
transaction,
});
output.job_requisitions_organizations =
await organizations.getJob_requisitions_organizations({
transaction,
});
output.learning_courses_organizations =
await organizations.getLearning_courses_organizations({
transaction,
});
output.leave_requests_organizations =
await organizations.getLeave_requests_organizations({
transaction,
});
output.offers_organizations = await organizations.getOffers_organizations({
transaction,
});
output.payments_organizations =
await organizations.getPayments_organizations({
transaction,
});
output.payroll_runs_organizations =
await organizations.getPayroll_runs_organizations({
transaction,
});
output.policies_organizations =
await organizations.getPolicies_organizations({
transaction,
});
output.positions_organizations =
await organizations.getPositions_organizations({
transaction,
});
output.review_cycles_organizations =
await organizations.getReview_cycles_organizations({
transaction,
});
output.reviews_organizations = await organizations.getReviews_organizations(
{
transaction,
},
);
output.schedule_shifts_organizations =
await organizations.getSchedule_shifts_organizations({
transaction,
});
output.taxes_organizations = await organizations.getTaxes_organizations({
transaction,
});
output.time_entries_organizations =
await organizations.getTime_entries_organizations({
transaction,
});
output.timecards_organizations =
await organizations.getTimecards_organizations({
transaction,
});
output.travel_bookings_organizations =
await organizations.getTravel_bookings_organizations({
transaction,
});
output.vendors_organizations = await organizations.getVendors_organizations(
{
transaction,
},
);
return output;
}
static async findAll(filter, globalAccess, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
const userOrganizations = (user && user.organizations?.id) || null;
if (userOrganizations) {
if (options?.currentUser?.organizationsId) {
where.organizationsId = options.currentUser.organizationsId;
}
}
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.name) {
where = {
...where,
[Op.and]: Utils.ilike('organizations', 'name', filter.name),
};
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true',
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
if (globalAccess) {
delete where.organizationsId;
}
const queryOptions = {
where,
include,
distinct: true,
order:
filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log,
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.organizations.findAndCountAll(
queryOptions,
);
return {
rows: options?.countOnly ? [] : rows,
count: count,
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(
query,
limit,
offset,
globalAccess,
organizationId,
) {
let where = {};
if (!globalAccess && organizationId) {
where.organizationId = organizationId;
}
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike('organizations', 'name', query),
],
};
}
const records = await db.organizations.findAll({
attributes: ['id', 'name'],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['name', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.name,
}));
}
};

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

344
backend/src/db/api/roles.js Normal file
View File

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

View File

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

415
backend/src/db/api/taxes.js Normal file
View File

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

View File

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

View File

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

View File

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

804
backend/src/db/api/users.js Normal file
View File

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

View File

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

View File

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

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,73 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const app_accounts = sequelize.define(
'app_accounts',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
role: {
type: DataTypes.ENUM,
values: ['User', 'Admin', 'SuperAdmin'],
},
status: {
type: DataTypes.ENUM,
values: ['Active', 'Inactive'],
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
app_accounts.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.app_accounts.belongsTo(db.employees, {
as: 'employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.app_accounts.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.app_accounts.belongsTo(db.users, {
as: 'createdBy',
});
db.app_accounts.belongsTo(db.users, {
as: 'updatedBy',
});
};
return app_accounts;
};

View File

@ -0,0 +1,95 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const applications = sequelize.define(
'applications',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
submitted_at: {
type: DataTypes.DATE,
},
status: {
type: DataTypes.ENUM,
values: ['Pending', 'Reviewed', 'Rejected'],
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
applications.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
db.applications.hasMany(db.interviews, {
as: 'interviews_application',
foreignKey: {
name: 'applicationId',
},
constraints: false,
});
db.applications.hasMany(db.offers, {
as: 'offers_application',
foreignKey: {
name: 'applicationId',
},
constraints: false,
});
//end loop
db.applications.belongsTo(db.candidates, {
as: 'candidate',
foreignKey: {
name: 'candidateId',
},
constraints: false,
});
db.applications.belongsTo(db.job_requisitions, {
as: 'requisition',
foreignKey: {
name: 'requisitionId',
},
constraints: false,
});
db.applications.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.applications.belongsTo(db.users, {
as: 'createdBy',
});
db.applications.belongsTo(db.users, {
as: 'updatedBy',
});
};
return applications;
};

View File

@ -0,0 +1,83 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const approvals = sequelize.define(
'approvals',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
object_type: {
type: DataTypes.TEXT,
},
object_id: {
type: DataTypes.INTEGER,
},
step: {
type: DataTypes.INTEGER,
},
status: {
type: DataTypes.ENUM,
values: ['Pending', 'Approved', 'Rejected'],
},
timestamp: {
type: DataTypes.DATE,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
approvals.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.approvals.belongsTo(db.employees, {
as: 'approver',
foreignKey: {
name: 'approverId',
},
constraints: false,
});
db.approvals.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.approvals.belongsTo(db.users, {
as: 'createdBy',
});
db.approvals.belongsTo(db.users, {
as: 'updatedBy',
});
};
return approvals;
};

View File

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

View File

@ -0,0 +1,79 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const benefit_plans = sequelize.define(
'benefit_plans',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
carrier: {
type: DataTypes.TEXT,
},
plan_type: {
type: DataTypes.ENUM,
values: ['Medical', 'Dental', 'Vision'],
},
country: {
type: DataTypes.TEXT,
},
currency: {
type: DataTypes.TEXT,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
benefit_plans.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
db.benefit_plans.hasMany(db.enrollments, {
as: 'enrollments_plan',
foreignKey: {
name: 'planId',
},
constraints: false,
});
//end loop
db.benefit_plans.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.benefit_plans.belongsTo(db.users, {
as: 'createdBy',
});
db.benefit_plans.belongsTo(db.users, {
as: 'updatedBy',
});
};
return benefit_plans;
};

View File

@ -0,0 +1,99 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const bills = sequelize.define(
'bills',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
invoice_no: {
type: DataTypes.TEXT,
},
invoice_date: {
type: DataTypes.DATE,
},
due_date: {
type: DataTypes.DATE,
},
amount: {
type: DataTypes.DECIMAL,
},
currency: {
type: DataTypes.TEXT,
},
category: {
type: DataTypes.TEXT,
},
status: {
type: DataTypes.ENUM,
values: ['Pending', 'Paid', 'Overdue'],
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
bills.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
db.bills.hasMany(db.payments, {
as: 'payments_bill',
foreignKey: {
name: 'billId',
},
constraints: false,
});
//end loop
db.bills.belongsTo(db.vendors, {
as: 'vendor',
foreignKey: {
name: 'vendorId',
},
constraints: false,
});
db.bills.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.bills.belongsTo(db.users, {
as: 'createdBy',
});
db.bills.belongsTo(db.users, {
as: 'updatedBy',
});
};
return bills;
};

View File

@ -0,0 +1,83 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const candidates = sequelize.define(
'candidates',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: DataTypes.TEXT,
},
email: {
type: DataTypes.TEXT,
},
phone: {
type: DataTypes.TEXT,
},
source: {
type: DataTypes.TEXT,
},
current_stage: {
type: DataTypes.ENUM,
values: ['Applied', 'Interviewing', 'Offered', 'Hired'],
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
candidates.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
db.candidates.hasMany(db.applications, {
as: 'applications_candidate',
foreignKey: {
name: 'candidateId',
},
constraints: false,
});
//end loop
db.candidates.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.candidates.belongsTo(db.users, {
as: 'createdBy',
});
db.candidates.belongsTo(db.users, {
as: 'updatedBy',
});
};
return candidates;
};

View File

@ -0,0 +1,81 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const cards = sequelize.define(
'cards',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
type: {
type: DataTypes.ENUM,
values: ['Virtual', 'Physical'],
},
last4: {
type: DataTypes.TEXT,
},
limit: {
type: DataTypes.DECIMAL,
},
status: {
type: DataTypes.ENUM,
values: ['Active', 'Inactive'],
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
cards.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.cards.belongsTo(db.employees, {
as: 'employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.cards.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.cards.belongsTo(db.users, {
as: 'createdBy',
});
db.cards.belongsTo(db.users, {
as: 'updatedBy',
});
};
return cards;
};

View File

@ -0,0 +1,85 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const compensations = sequelize.define(
'compensations',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
base_pay: {
type: DataTypes.DECIMAL,
},
pay_type: {
type: DataTypes.ENUM,
values: ['Hourly', 'Salary'],
},
pay_frequency: {
type: DataTypes.ENUM,
values: ['Weekly', 'Bi-weekly', 'Monthly'],
},
currency: {
type: DataTypes.TEXT,
},
effective_date: {
type: DataTypes.DATE,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
compensations.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.compensations.belongsTo(db.employees, {
as: 'employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.compensations.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.compensations.belongsTo(db.users, {
as: 'createdBy',
});
db.compensations.belongsTo(db.users, {
as: 'updatedBy',
});
};
return compensations;
};

View File

@ -0,0 +1,79 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const deductions = sequelize.define(
'deductions',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
type: {
type: DataTypes.ENUM,
values: ['Tax', 'Insurance', 'Other'],
},
amount: {
type: DataTypes.DECIMAL,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
deductions.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.deductions.belongsTo(db.payroll_runs, {
as: 'payroll_run',
foreignKey: {
name: 'payroll_runId',
},
constraints: false,
});
db.deductions.belongsTo(db.employees, {
as: 'employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.deductions.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.deductions.belongsTo(db.users, {
as: 'createdBy',
});
db.deductions.belongsTo(db.users, {
as: 'updatedBy',
});
};
return deductions;
};

View File

@ -0,0 +1,106 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const devices = sequelize.define(
'devices',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
type: {
type: DataTypes.ENUM,
values: ['Laptop', 'Desktop', 'Tablet'],
},
platform: {
type: DataTypes.ENUM,
values: ['Windows', 'MacOS', 'Linux'],
},
serial: {
type: DataTypes.TEXT,
},
asset_tag: {
type: DataTypes.TEXT,
},
status: {
type: DataTypes.ENUM,
values: ['Assigned', 'InStock', 'Retired'],
},
encryption: {
type: DataTypes.BOOLEAN,
allowNull: false,
defaultValue: false,
},
os_version: {
type: DataTypes.TEXT,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
devices.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
db.devices.hasMany(db.inventory_events, {
as: 'inventory_events_device',
foreignKey: {
name: 'deviceId',
},
constraints: false,
});
//end loop
db.devices.belongsTo(db.employees, {
as: 'owner',
foreignKey: {
name: 'ownerId',
},
constraints: false,
});
db.devices.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.devices.belongsTo(db.users, {
as: 'createdBy',
});
db.devices.belongsTo(db.users, {
as: 'updatedBy',
});
};
return devices;
};

View File

@ -0,0 +1,91 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const documents = sequelize.define(
'documents',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
doc_type: {
type: DataTypes.ENUM,
values: ['Contract', 'ID', 'Certificate'],
},
country: {
type: DataTypes.TEXT,
},
status: {
type: DataTypes.ENUM,
values: ['Pending', 'Signed', 'Expired'],
},
signed_at: {
type: DataTypes.DATE,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
documents.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.documents.belongsTo(db.employees, {
as: 'owner',
foreignKey: {
name: 'ownerId',
},
constraints: false,
});
db.documents.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.documents.hasMany(db.file, {
as: 'file_ref',
foreignKey: 'belongsToId',
constraints: false,
scope: {
belongsTo: db.documents.getTableName(),
belongsToColumn: 'file_ref',
},
});
db.documents.belongsTo(db.users, {
as: 'createdBy',
});
db.documents.belongsTo(db.users, {
as: 'updatedBy',
});
};
return documents;
};

View File

@ -0,0 +1,96 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const earnings = sequelize.define(
'earnings',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
component: {
type: DataTypes.TEXT,
},
units: {
type: DataTypes.DECIMAL,
},
rate: {
type: DataTypes.DECIMAL,
},
amount: {
type: DataTypes.DECIMAL,
},
currency: {
type: DataTypes.TEXT,
},
taxable: {
type: DataTypes.BOOLEAN,
allowNull: false,
defaultValue: false,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
earnings.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.earnings.belongsTo(db.payroll_runs, {
as: 'payroll_run',
foreignKey: {
name: 'payroll_runId',
},
constraints: false,
});
db.earnings.belongsTo(db.employees, {
as: 'employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.earnings.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.earnings.belongsTo(db.users, {
as: 'createdBy',
});
db.earnings.belongsTo(db.users, {
as: 'updatedBy',
});
};
return earnings;
};

View File

@ -0,0 +1,333 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const employees = sequelize.define(
'employees',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
employees.associate = (db) => {
db.employees.belongsToMany(db.employments, {
as: 'employments',
foreignKey: {
name: 'employees_employmentsId',
},
constraints: false,
through: 'employeesEmploymentsEmployments',
});
db.employees.belongsToMany(db.employments, {
as: 'employments_filter',
foreignKey: {
name: 'employees_employmentsId',
},
constraints: false,
through: 'employeesEmploymentsEmployments',
});
db.employees.belongsToMany(db.positions, {
as: 'positions',
foreignKey: {
name: 'employees_positionsId',
},
constraints: false,
through: 'employeesPositionsPositions',
});
db.employees.belongsToMany(db.positions, {
as: 'positions_filter',
foreignKey: {
name: 'employees_positionsId',
},
constraints: false,
through: 'employeesPositionsPositions',
});
db.employees.belongsToMany(db.compensations, {
as: 'compensations',
foreignKey: {
name: 'employees_compensationsId',
},
constraints: false,
through: 'employeesCompensationsCompensations',
});
db.employees.belongsToMany(db.compensations, {
as: 'compensations_filter',
foreignKey: {
name: 'employees_compensationsId',
},
constraints: false,
through: 'employeesCompensationsCompensations',
});
db.employees.belongsToMany(db.documents, {
as: 'documents',
foreignKey: {
name: 'employees_documentsId',
},
constraints: false,
through: 'employeesDocumentsDocuments',
});
db.employees.belongsToMany(db.documents, {
as: 'documents_filter',
foreignKey: {
name: 'employees_documentsId',
},
constraints: false,
through: 'employeesDocumentsDocuments',
});
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
db.employees.hasMany(db.app_accounts, {
as: 'app_accounts_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.approvals, {
as: 'approvals_approver',
foreignKey: {
name: 'approverId',
},
constraints: false,
});
db.employees.hasMany(db.cards, {
as: 'cards_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.compensations, {
as: 'compensations_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.deductions, {
as: 'deductions_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.devices, {
as: 'devices_owner',
foreignKey: {
name: 'ownerId',
},
constraints: false,
});
db.employees.hasMany(db.documents, {
as: 'documents_owner',
foreignKey: {
name: 'ownerId',
},
constraints: false,
});
db.employees.hasMany(db.earnings, {
as: 'earnings_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.employments, {
as: 'employments_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.enrollment_learnings, {
as: 'enrollment_learnings_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.enrollment_learnings, {
as: 'enrollment_learnings_assigned_by',
foreignKey: {
name: 'assigned_byId',
},
constraints: false,
});
db.employees.hasMany(db.enrollments, {
as: 'enrollments_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.expense_reports, {
as: 'expense_reports_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.goals, {
as: 'goals_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.identity_accounts, {
as: 'identity_accounts_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.interviews, {
as: 'interviews_interviewer',
foreignKey: {
name: 'interviewerId',
},
constraints: false,
});
db.employees.hasMany(db.job_requisitions, {
as: 'job_requisitions_recruiter',
foreignKey: {
name: 'recruiterId',
},
constraints: false,
});
db.employees.hasMany(db.leave_requests, {
as: 'leave_requests_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.positions, {
as: 'positions_manager',
foreignKey: {
name: 'managerId',
},
constraints: false,
});
db.employees.hasMany(db.reviews, {
as: 'reviews_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.reviews, {
as: 'reviews_reviewer',
foreignKey: {
name: 'reviewerId',
},
constraints: false,
});
db.employees.hasMany(db.schedule_shifts, {
as: 'schedule_shifts_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.taxes, {
as: 'taxes_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.timecards, {
as: 'timecards_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employees.hasMany(db.travel_bookings, {
as: 'travel_bookings_employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
//end loop
db.employees.belongsTo(db.users, {
as: 'user',
foreignKey: {
name: 'userId',
},
constraints: false,
});
db.employees.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.employees.belongsTo(db.users, {
as: 'createdBy',
});
db.employees.belongsTo(db.users, {
as: 'updatedBy',
});
};
return employees;
};

View File

@ -0,0 +1,85 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const employments = sequelize.define(
'employments',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
employment_type: {
type: DataTypes.ENUM,
values: ['Full-time', 'Part-time', 'Contractor'],
},
start_date: {
type: DataTypes.DATE,
},
end_date: {
type: DataTypes.DATE,
},
fte: {
type: DataTypes.DECIMAL,
},
status: {
type: DataTypes.ENUM,
values: ['Active', 'Inactive', 'Terminated'],
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
employments.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.employments.belongsTo(db.employees, {
as: 'employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.employments.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.employments.belongsTo(db.users, {
as: 'createdBy',
});
db.employments.belongsTo(db.users, {
as: 'updatedBy',
});
};
return employments;
};

View File

@ -0,0 +1,87 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const enrollment_learnings = sequelize.define(
'enrollment_learnings',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
due_date: {
type: DataTypes.DATE,
},
status: {
type: DataTypes.ENUM,
values: ['Assigned', 'Completed', 'Overdue'],
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
enrollment_learnings.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.enrollment_learnings.belongsTo(db.employees, {
as: 'employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.enrollment_learnings.belongsTo(db.learning_courses, {
as: 'course',
foreignKey: {
name: 'courseId',
},
constraints: false,
});
db.enrollment_learnings.belongsTo(db.employees, {
as: 'assigned_by',
foreignKey: {
name: 'assigned_byId',
},
constraints: false,
});
db.enrollment_learnings.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.enrollment_learnings.belongsTo(db.users, {
as: 'createdBy',
});
db.enrollment_learnings.belongsTo(db.users, {
as: 'updatedBy',
});
};
return enrollment_learnings;
};

View File

@ -0,0 +1,87 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const enrollments = sequelize.define(
'enrollments',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
effective_date: {
type: DataTypes.DATE,
},
premium_employee: {
type: DataTypes.DECIMAL,
},
premium_employer: {
type: DataTypes.DECIMAL,
},
status: {
type: DataTypes.ENUM,
values: ['Active', 'Inactive'],
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
enrollments.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.enrollments.belongsTo(db.employees, {
as: 'employee',
foreignKey: {
name: 'employeeId',
},
constraints: false,
});
db.enrollments.belongsTo(db.benefit_plans, {
as: 'plan',
foreignKey: {
name: 'planId',
},
constraints: false,
});
db.enrollments.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.enrollments.belongsTo(db.users, {
as: 'createdBy',
});
db.enrollments.belongsTo(db.users, {
as: 'updatedBy',
});
};
return enrollments;
};

Some files were not shown because too many files have changed in this diff Show More