1097 lines
27 KiB
JavaScript
1097 lines
27 KiB
JavaScript
const db = require('../models');
|
|
const Users = db.users;
|
|
|
|
const Absences = db.absences;
|
|
|
|
const EmployeeStatus = db.employee_status;
|
|
|
|
const Employees = db.employees;
|
|
|
|
const Machines = db.machines;
|
|
|
|
const PerformanceCategories = db.performance_categories;
|
|
|
|
const Projects = db.projects;
|
|
|
|
const Sectors = db.sectors;
|
|
|
|
const Shifts = db.shifts;
|
|
|
|
const Vacations = db.vacations;
|
|
|
|
const Organizations = db.organizations;
|
|
|
|
const AbsencesData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
absence_type: 'Custom1',
|
|
|
|
start_date: new Date('2023-07-01T08:00:00Z'),
|
|
|
|
end_date: new Date('2023-07-03T08:00:00Z'),
|
|
|
|
notes: 'Flu symptoms',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
absence_type: 'Custom1',
|
|
|
|
start_date: new Date('2023-06-01T08:00:00Z'),
|
|
|
|
end_date: new Date('2023-06-02T08:00:00Z'),
|
|
|
|
notes: 'Family emergency',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
absence_type: 'Vacation',
|
|
|
|
start_date: new Date('2023-05-01T08:00:00Z'),
|
|
|
|
end_date: new Date('2023-05-05T08:00:00Z'),
|
|
|
|
notes: 'Personal leave',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const EmployeeStatusData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
vacation_status: 'OnVacation',
|
|
|
|
performance_rating: 5,
|
|
|
|
absences_count: 2,
|
|
|
|
warnings_count: 0,
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
vacation_status: 'Available',
|
|
|
|
performance_rating: 7,
|
|
|
|
absences_count: 1,
|
|
|
|
warnings_count: 1,
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
vacation_status: 'Available',
|
|
|
|
performance_rating: 6,
|
|
|
|
absences_count: 0,
|
|
|
|
warnings_count: 0,
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const EmployeesData = [
|
|
{
|
|
full_name: 'John Doe',
|
|
|
|
role: 'Operator',
|
|
|
|
registration_number: 'EMP001',
|
|
|
|
cost_center: 'CC1001',
|
|
|
|
hire_date: new Date('2022-01-15T08:00:00Z'),
|
|
|
|
phone: '555-0101',
|
|
|
|
address: '123 Main St, Springfield',
|
|
|
|
// type code here for "images" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
full_name: 'Jane Smith',
|
|
|
|
role: 'Supervisor',
|
|
|
|
registration_number: 'EMP002',
|
|
|
|
cost_center: 'CC1002',
|
|
|
|
hire_date: new Date('2021-06-20T08:00:00Z'),
|
|
|
|
phone: '555-0102',
|
|
|
|
address: '456 Elm St, Springfield',
|
|
|
|
// type code here for "images" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
full_name: 'Alice Johnson',
|
|
|
|
role: 'Technician',
|
|
|
|
registration_number: 'EMP003',
|
|
|
|
cost_center: 'CC1003',
|
|
|
|
hire_date: new Date('2020-11-05T08:00:00Z'),
|
|
|
|
phone: '555-0103',
|
|
|
|
address: '789 Oak St, Springfield',
|
|
|
|
// type code here for "images" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const MachinesData = [
|
|
{
|
|
machine_name: 'CNC Machine 1',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
machine_name: '3D Printer',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
machine_name: 'Inspection Station',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const PerformanceCategoriesData = [
|
|
{
|
|
stars: 1,
|
|
|
|
category_name: 'Beginner',
|
|
|
|
description: 'New to the role, requires supervision.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
stars: 2,
|
|
|
|
category_name: 'Beginner Apprentice',
|
|
|
|
description: 'Gaining experience, still learning.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
stars: 3,
|
|
|
|
category_name: 'Average Apprentice',
|
|
|
|
description: 'Moderate experience, performs tasks with some guidance.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const ProjectsData = [
|
|
{
|
|
project_name: 'Project Alpha',
|
|
|
|
description: 'Initial phase of the new product line.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
project_name: 'Project Beta',
|
|
|
|
description: 'Expansion of the existing product line.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
project_name: 'Project Gamma',
|
|
|
|
description: 'Research and development for new technologies.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const SectorsData = [
|
|
{
|
|
sector_name: 'Manufacturing',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
sector_name: 'Research',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
sector_name: 'Quality Control',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const ShiftsData = [
|
|
{
|
|
shift_name: 'Morning Shift',
|
|
|
|
shift_type: '95B',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
shift_name: 'Afternoon Shift',
|
|
|
|
shift_type: '49A',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
shift_name: 'Night Shift',
|
|
|
|
shift_type: '49A',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const VacationsData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
start_date: new Date('2023-12-01T08:00:00Z'),
|
|
|
|
end_date: new Date('2023-12-15T08:00:00Z'),
|
|
|
|
thirteenth_advance: true,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
start_date: new Date('2023-11-01T08:00:00Z'),
|
|
|
|
end_date: new Date('2023-11-10T08:00:00Z'),
|
|
|
|
thirteenth_advance: false,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
start_date: new Date('2023-10-01T08:00:00Z'),
|
|
|
|
end_date: new Date('2023-10-14T08:00:00Z'),
|
|
|
|
thirteenth_advance: true,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const OrganizationsData = [
|
|
{
|
|
name: 'J. Robert Oppenheimer',
|
|
},
|
|
|
|
{
|
|
name: 'William Harvey',
|
|
},
|
|
|
|
{
|
|
name: 'Max Born',
|
|
},
|
|
];
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
async function associateUserWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const User0 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (User0?.setOrganization) {
|
|
await User0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const User1 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (User1?.setOrganization) {
|
|
await User1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const User2 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (User2?.setOrganization) {
|
|
await User2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
async function associateAbsenceWithEmployee() {
|
|
const relatedEmployee0 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const Absence0 = await Absences.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Absence0?.setEmployee) {
|
|
await Absence0.setEmployee(relatedEmployee0);
|
|
}
|
|
|
|
const relatedEmployee1 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const Absence1 = await Absences.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Absence1?.setEmployee) {
|
|
await Absence1.setEmployee(relatedEmployee1);
|
|
}
|
|
|
|
const relatedEmployee2 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const Absence2 = await Absences.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Absence2?.setEmployee) {
|
|
await Absence2.setEmployee(relatedEmployee2);
|
|
}
|
|
}
|
|
|
|
async function associateAbsenceWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Absence0 = await Absences.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Absence0?.setOrganization) {
|
|
await Absence0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Absence1 = await Absences.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Absence1?.setOrganization) {
|
|
await Absence1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Absence2 = await Absences.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Absence2?.setOrganization) {
|
|
await Absence2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
async function associateEmployeeStatusWithEmployee() {
|
|
const relatedEmployee0 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const EmployeeStatus0 = await EmployeeStatus.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (EmployeeStatus0?.setEmployee) {
|
|
await EmployeeStatus0.setEmployee(relatedEmployee0);
|
|
}
|
|
|
|
const relatedEmployee1 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const EmployeeStatus1 = await EmployeeStatus.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (EmployeeStatus1?.setEmployee) {
|
|
await EmployeeStatus1.setEmployee(relatedEmployee1);
|
|
}
|
|
|
|
const relatedEmployee2 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const EmployeeStatus2 = await EmployeeStatus.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (EmployeeStatus2?.setEmployee) {
|
|
await EmployeeStatus2.setEmployee(relatedEmployee2);
|
|
}
|
|
}
|
|
|
|
async function associateEmployeeStatusWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const EmployeeStatus0 = await EmployeeStatus.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (EmployeeStatus0?.setOrganization) {
|
|
await EmployeeStatus0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const EmployeeStatus1 = await EmployeeStatus.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (EmployeeStatus1?.setOrganization) {
|
|
await EmployeeStatus1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const EmployeeStatus2 = await EmployeeStatus.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (EmployeeStatus2?.setOrganization) {
|
|
await EmployeeStatus2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
async function associateEmployeeWithShift() {
|
|
const relatedShift0 = await Shifts.findOne({
|
|
offset: Math.floor(Math.random() * (await Shifts.count())),
|
|
});
|
|
const Employee0 = await Employees.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Employee0?.setShift) {
|
|
await Employee0.setShift(relatedShift0);
|
|
}
|
|
|
|
const relatedShift1 = await Shifts.findOne({
|
|
offset: Math.floor(Math.random() * (await Shifts.count())),
|
|
});
|
|
const Employee1 = await Employees.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Employee1?.setShift) {
|
|
await Employee1.setShift(relatedShift1);
|
|
}
|
|
|
|
const relatedShift2 = await Shifts.findOne({
|
|
offset: Math.floor(Math.random() * (await Shifts.count())),
|
|
});
|
|
const Employee2 = await Employees.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Employee2?.setShift) {
|
|
await Employee2.setShift(relatedShift2);
|
|
}
|
|
}
|
|
|
|
async function associateEmployeeWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Employee0 = await Employees.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Employee0?.setOrganization) {
|
|
await Employee0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Employee1 = await Employees.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Employee1?.setOrganization) {
|
|
await Employee1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Employee2 = await Employees.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Employee2?.setOrganization) {
|
|
await Employee2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
async function associateMachineWithSector() {
|
|
const relatedSector0 = await Sectors.findOne({
|
|
offset: Math.floor(Math.random() * (await Sectors.count())),
|
|
});
|
|
const Machine0 = await Machines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Machine0?.setSector) {
|
|
await Machine0.setSector(relatedSector0);
|
|
}
|
|
|
|
const relatedSector1 = await Sectors.findOne({
|
|
offset: Math.floor(Math.random() * (await Sectors.count())),
|
|
});
|
|
const Machine1 = await Machines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Machine1?.setSector) {
|
|
await Machine1.setSector(relatedSector1);
|
|
}
|
|
|
|
const relatedSector2 = await Sectors.findOne({
|
|
offset: Math.floor(Math.random() * (await Sectors.count())),
|
|
});
|
|
const Machine2 = await Machines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Machine2?.setSector) {
|
|
await Machine2.setSector(relatedSector2);
|
|
}
|
|
}
|
|
|
|
async function associateMachineWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Machine0 = await Machines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Machine0?.setOrganization) {
|
|
await Machine0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Machine1 = await Machines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Machine1?.setOrganization) {
|
|
await Machine1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Machine2 = await Machines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Machine2?.setOrganization) {
|
|
await Machine2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
async function associatePerformanceCategoryWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const PerformanceCategory0 = await PerformanceCategories.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (PerformanceCategory0?.setOrganization) {
|
|
await PerformanceCategory0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const PerformanceCategory1 = await PerformanceCategories.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (PerformanceCategory1?.setOrganization) {
|
|
await PerformanceCategory1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const PerformanceCategory2 = await PerformanceCategories.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (PerformanceCategory2?.setOrganization) {
|
|
await PerformanceCategory2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
async function associateProjectWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Project0 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Project0?.setOrganization) {
|
|
await Project0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Project1 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Project1?.setOrganization) {
|
|
await Project1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Project2 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Project2?.setOrganization) {
|
|
await Project2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
async function associateSectorWithProject() {
|
|
const relatedProject0 = await Projects.findOne({
|
|
offset: Math.floor(Math.random() * (await Projects.count())),
|
|
});
|
|
const Sector0 = await Sectors.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Sector0?.setProject) {
|
|
await Sector0.setProject(relatedProject0);
|
|
}
|
|
|
|
const relatedProject1 = await Projects.findOne({
|
|
offset: Math.floor(Math.random() * (await Projects.count())),
|
|
});
|
|
const Sector1 = await Sectors.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Sector1?.setProject) {
|
|
await Sector1.setProject(relatedProject1);
|
|
}
|
|
|
|
const relatedProject2 = await Projects.findOne({
|
|
offset: Math.floor(Math.random() * (await Projects.count())),
|
|
});
|
|
const Sector2 = await Sectors.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Sector2?.setProject) {
|
|
await Sector2.setProject(relatedProject2);
|
|
}
|
|
}
|
|
|
|
async function associateSectorWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Sector0 = await Sectors.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Sector0?.setOrganization) {
|
|
await Sector0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Sector1 = await Sectors.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Sector1?.setOrganization) {
|
|
await Sector1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Sector2 = await Sectors.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Sector2?.setOrganization) {
|
|
await Sector2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
async function associateShiftWithMachine() {
|
|
const relatedMachine0 = await Machines.findOne({
|
|
offset: Math.floor(Math.random() * (await Machines.count())),
|
|
});
|
|
const Shift0 = await Shifts.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Shift0?.setMachine) {
|
|
await Shift0.setMachine(relatedMachine0);
|
|
}
|
|
|
|
const relatedMachine1 = await Machines.findOne({
|
|
offset: Math.floor(Math.random() * (await Machines.count())),
|
|
});
|
|
const Shift1 = await Shifts.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Shift1?.setMachine) {
|
|
await Shift1.setMachine(relatedMachine1);
|
|
}
|
|
|
|
const relatedMachine2 = await Machines.findOne({
|
|
offset: Math.floor(Math.random() * (await Machines.count())),
|
|
});
|
|
const Shift2 = await Shifts.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Shift2?.setMachine) {
|
|
await Shift2.setMachine(relatedMachine2);
|
|
}
|
|
}
|
|
|
|
async function associateShiftWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Shift0 = await Shifts.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Shift0?.setOrganization) {
|
|
await Shift0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Shift1 = await Shifts.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Shift1?.setOrganization) {
|
|
await Shift1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Shift2 = await Shifts.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Shift2?.setOrganization) {
|
|
await Shift2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
async function associateVacationWithEmployee() {
|
|
const relatedEmployee0 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const Vacation0 = await Vacations.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Vacation0?.setEmployee) {
|
|
await Vacation0.setEmployee(relatedEmployee0);
|
|
}
|
|
|
|
const relatedEmployee1 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const Vacation1 = await Vacations.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Vacation1?.setEmployee) {
|
|
await Vacation1.setEmployee(relatedEmployee1);
|
|
}
|
|
|
|
const relatedEmployee2 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const Vacation2 = await Vacations.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Vacation2?.setEmployee) {
|
|
await Vacation2.setEmployee(relatedEmployee2);
|
|
}
|
|
}
|
|
|
|
async function associateVacationWithSubstitute_employee() {
|
|
const relatedSubstitute_employee0 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const Vacation0 = await Vacations.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Vacation0?.setSubstitute_employee) {
|
|
await Vacation0.setSubstitute_employee(relatedSubstitute_employee0);
|
|
}
|
|
|
|
const relatedSubstitute_employee1 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const Vacation1 = await Vacations.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Vacation1?.setSubstitute_employee) {
|
|
await Vacation1.setSubstitute_employee(relatedSubstitute_employee1);
|
|
}
|
|
|
|
const relatedSubstitute_employee2 = await Employees.findOne({
|
|
offset: Math.floor(Math.random() * (await Employees.count())),
|
|
});
|
|
const Vacation2 = await Vacations.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Vacation2?.setSubstitute_employee) {
|
|
await Vacation2.setSubstitute_employee(relatedSubstitute_employee2);
|
|
}
|
|
}
|
|
|
|
async function associateVacationWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Vacation0 = await Vacations.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Vacation0?.setOrganization) {
|
|
await Vacation0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Vacation1 = await Vacations.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Vacation1?.setOrganization) {
|
|
await Vacation1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Vacation2 = await Vacations.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Vacation2?.setOrganization) {
|
|
await Vacation2.setOrganization(relatedOrganization2);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
up: async (queryInterface, Sequelize) => {
|
|
await Absences.bulkCreate(AbsencesData);
|
|
|
|
await EmployeeStatus.bulkCreate(EmployeeStatusData);
|
|
|
|
await Employees.bulkCreate(EmployeesData);
|
|
|
|
await Machines.bulkCreate(MachinesData);
|
|
|
|
await PerformanceCategories.bulkCreate(PerformanceCategoriesData);
|
|
|
|
await Projects.bulkCreate(ProjectsData);
|
|
|
|
await Sectors.bulkCreate(SectorsData);
|
|
|
|
await Shifts.bulkCreate(ShiftsData);
|
|
|
|
await Vacations.bulkCreate(VacationsData);
|
|
|
|
await Organizations.bulkCreate(OrganizationsData);
|
|
|
|
await Promise.all([
|
|
// Similar logic for "relation_many"
|
|
|
|
await associateUserWithOrganization(),
|
|
|
|
await associateAbsenceWithEmployee(),
|
|
|
|
await associateAbsenceWithOrganization(),
|
|
|
|
await associateEmployeeStatusWithEmployee(),
|
|
|
|
await associateEmployeeStatusWithOrganization(),
|
|
|
|
await associateEmployeeWithShift(),
|
|
|
|
await associateEmployeeWithOrganization(),
|
|
|
|
await associateMachineWithSector(),
|
|
|
|
await associateMachineWithOrganization(),
|
|
|
|
await associatePerformanceCategoryWithOrganization(),
|
|
|
|
await associateProjectWithOrganization(),
|
|
|
|
await associateSectorWithProject(),
|
|
|
|
await associateSectorWithOrganization(),
|
|
|
|
await associateShiftWithMachine(),
|
|
|
|
await associateShiftWithOrganization(),
|
|
|
|
await associateVacationWithEmployee(),
|
|
|
|
await associateVacationWithSubstitute_employee(),
|
|
|
|
await associateVacationWithOrganization(),
|
|
]);
|
|
},
|
|
|
|
down: async (queryInterface, Sequelize) => {
|
|
await queryInterface.bulkDelete('absences', null, {});
|
|
|
|
await queryInterface.bulkDelete('employee_status', null, {});
|
|
|
|
await queryInterface.bulkDelete('employees', null, {});
|
|
|
|
await queryInterface.bulkDelete('machines', null, {});
|
|
|
|
await queryInterface.bulkDelete('performance_categories', null, {});
|
|
|
|
await queryInterface.bulkDelete('projects', null, {});
|
|
|
|
await queryInterface.bulkDelete('sectors', null, {});
|
|
|
|
await queryInterface.bulkDelete('shifts', null, {});
|
|
|
|
await queryInterface.bulkDelete('vacations', null, {});
|
|
|
|
await queryInterface.bulkDelete('organizations', null, {});
|
|
},
|
|
};
|