626 lines
14 KiB
JavaScript
626 lines
14 KiB
JavaScript
const db = require('../models');
|
|
const Users = db.users;
|
|
|
|
const Projects = db.projects;
|
|
|
|
const Tasks = db.tasks;
|
|
|
|
const Tenants = db.tenants;
|
|
|
|
const ProjectsData = [
|
|
{
|
|
name: 'Project Alpha',
|
|
|
|
description: 'Development of the new Alpha platform.',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Project Beta',
|
|
|
|
description: 'Enhancement of the Beta application.',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Project Gamma',
|
|
|
|
description: 'Testing and QA for Gamma release.',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Project Delta',
|
|
|
|
description: 'Marketing campaign for Delta launch.',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Project Epsilon',
|
|
|
|
description: 'Maintenance and support for Epsilon.',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const TasksData = [
|
|
{
|
|
title: 'Design UI for Alpha',
|
|
|
|
status: 'InProgress',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
start_date: new Date('2023-11-01T09:00:00Z'),
|
|
|
|
end_date: new Date('2023-11-10T17:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'Implement API for Beta',
|
|
|
|
status: 'Done',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
start_date: new Date('2023-11-05T09:00:00Z'),
|
|
|
|
end_date: new Date('2023-11-15T17:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'Test Gamma features',
|
|
|
|
status: 'Done',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
start_date: new Date('2023-11-08T09:00:00Z'),
|
|
|
|
end_date: new Date('2023-11-18T17:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'Launch Delta campaign',
|
|
|
|
status: 'ToDo',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
start_date: new Date('2023-11-10T09:00:00Z'),
|
|
|
|
end_date: new Date('2023-11-20T17:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'Update Epsilon documentation',
|
|
|
|
status: 'Done',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
start_date: new Date('2023-11-12T09:00:00Z'),
|
|
|
|
end_date: new Date('2023-11-22T17:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const TenantsData = [
|
|
{
|
|
name: 'Tech Innovators',
|
|
},
|
|
|
|
{
|
|
name: 'Quality Assured',
|
|
},
|
|
|
|
{
|
|
name: 'Market Leaders',
|
|
},
|
|
|
|
{
|
|
name: 'Support Squad',
|
|
},
|
|
|
|
{
|
|
name: 'Development Hub',
|
|
},
|
|
];
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
async function associateUserWithTenant() {
|
|
const relatedTenant0 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const User0 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (User0?.setTenant) {
|
|
await User0.setTenant(relatedTenant0);
|
|
}
|
|
|
|
const relatedTenant1 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const User1 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (User1?.setTenant) {
|
|
await User1.setTenant(relatedTenant1);
|
|
}
|
|
|
|
const relatedTenant2 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const User2 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (User2?.setTenant) {
|
|
await User2.setTenant(relatedTenant2);
|
|
}
|
|
|
|
const relatedTenant3 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const User3 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (User3?.setTenant) {
|
|
await User3.setTenant(relatedTenant3);
|
|
}
|
|
|
|
const relatedTenant4 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const User4 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (User4?.setTenant) {
|
|
await User4.setTenant(relatedTenant4);
|
|
}
|
|
}
|
|
|
|
async function associateProjectWithManager() {
|
|
const relatedManager0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Project0 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Project0?.setManager) {
|
|
await Project0.setManager(relatedManager0);
|
|
}
|
|
|
|
const relatedManager1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Project1 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Project1?.setManager) {
|
|
await Project1.setManager(relatedManager1);
|
|
}
|
|
|
|
const relatedManager2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Project2 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Project2?.setManager) {
|
|
await Project2.setManager(relatedManager2);
|
|
}
|
|
|
|
const relatedManager3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Project3 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Project3?.setManager) {
|
|
await Project3.setManager(relatedManager3);
|
|
}
|
|
|
|
const relatedManager4 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Project4 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Project4?.setManager) {
|
|
await Project4.setManager(relatedManager4);
|
|
}
|
|
}
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
async function associateProjectWithTenant() {
|
|
const relatedTenant0 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project0 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Project0?.setTenant) {
|
|
await Project0.setTenant(relatedTenant0);
|
|
}
|
|
|
|
const relatedTenant1 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project1 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Project1?.setTenant) {
|
|
await Project1.setTenant(relatedTenant1);
|
|
}
|
|
|
|
const relatedTenant2 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project2 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Project2?.setTenant) {
|
|
await Project2.setTenant(relatedTenant2);
|
|
}
|
|
|
|
const relatedTenant3 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project3 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Project3?.setTenant) {
|
|
await Project3.setTenant(relatedTenant3);
|
|
}
|
|
|
|
const relatedTenant4 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project4 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Project4?.setTenant) {
|
|
await Project4.setTenant(relatedTenant4);
|
|
}
|
|
}
|
|
|
|
async function associateProjectWithTenant() {
|
|
const relatedTenant0 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project0 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Project0?.setTenant) {
|
|
await Project0.setTenant(relatedTenant0);
|
|
}
|
|
|
|
const relatedTenant1 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project1 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Project1?.setTenant) {
|
|
await Project1.setTenant(relatedTenant1);
|
|
}
|
|
|
|
const relatedTenant2 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project2 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Project2?.setTenant) {
|
|
await Project2.setTenant(relatedTenant2);
|
|
}
|
|
|
|
const relatedTenant3 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project3 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Project3?.setTenant) {
|
|
await Project3.setTenant(relatedTenant3);
|
|
}
|
|
|
|
const relatedTenant4 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Project4 = await Projects.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Project4?.setTenant) {
|
|
await Project4.setTenant(relatedTenant4);
|
|
}
|
|
}
|
|
|
|
async function associateTaskWithAssignee() {
|
|
const relatedAssignee0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Task0 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Task0?.setAssignee) {
|
|
await Task0.setAssignee(relatedAssignee0);
|
|
}
|
|
|
|
const relatedAssignee1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Task1 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Task1?.setAssignee) {
|
|
await Task1.setAssignee(relatedAssignee1);
|
|
}
|
|
|
|
const relatedAssignee2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Task2 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Task2?.setAssignee) {
|
|
await Task2.setAssignee(relatedAssignee2);
|
|
}
|
|
|
|
const relatedAssignee3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Task3 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Task3?.setAssignee) {
|
|
await Task3.setAssignee(relatedAssignee3);
|
|
}
|
|
|
|
const relatedAssignee4 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Task4 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Task4?.setAssignee) {
|
|
await Task4.setAssignee(relatedAssignee4);
|
|
}
|
|
}
|
|
|
|
async function associateTaskWithProject() {
|
|
const relatedProject0 = await Projects.findOne({
|
|
offset: Math.floor(Math.random() * (await Projects.count())),
|
|
});
|
|
const Task0 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Task0?.setProject) {
|
|
await Task0.setProject(relatedProject0);
|
|
}
|
|
|
|
const relatedProject1 = await Projects.findOne({
|
|
offset: Math.floor(Math.random() * (await Projects.count())),
|
|
});
|
|
const Task1 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Task1?.setProject) {
|
|
await Task1.setProject(relatedProject1);
|
|
}
|
|
|
|
const relatedProject2 = await Projects.findOne({
|
|
offset: Math.floor(Math.random() * (await Projects.count())),
|
|
});
|
|
const Task2 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Task2?.setProject) {
|
|
await Task2.setProject(relatedProject2);
|
|
}
|
|
|
|
const relatedProject3 = await Projects.findOne({
|
|
offset: Math.floor(Math.random() * (await Projects.count())),
|
|
});
|
|
const Task3 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Task3?.setProject) {
|
|
await Task3.setProject(relatedProject3);
|
|
}
|
|
|
|
const relatedProject4 = await Projects.findOne({
|
|
offset: Math.floor(Math.random() * (await Projects.count())),
|
|
});
|
|
const Task4 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Task4?.setProject) {
|
|
await Task4.setProject(relatedProject4);
|
|
}
|
|
}
|
|
|
|
async function associateTaskWithTenant() {
|
|
const relatedTenant0 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Task0 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Task0?.setTenant) {
|
|
await Task0.setTenant(relatedTenant0);
|
|
}
|
|
|
|
const relatedTenant1 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Task1 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Task1?.setTenant) {
|
|
await Task1.setTenant(relatedTenant1);
|
|
}
|
|
|
|
const relatedTenant2 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Task2 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Task2?.setTenant) {
|
|
await Task2.setTenant(relatedTenant2);
|
|
}
|
|
|
|
const relatedTenant3 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Task3 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Task3?.setTenant) {
|
|
await Task3.setTenant(relatedTenant3);
|
|
}
|
|
|
|
const relatedTenant4 = await Tenants.findOne({
|
|
offset: Math.floor(Math.random() * (await Tenants.count())),
|
|
});
|
|
const Task4 = await Tasks.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Task4?.setTenant) {
|
|
await Task4.setTenant(relatedTenant4);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
up: async (queryInterface, Sequelize) => {
|
|
await Projects.bulkCreate(ProjectsData);
|
|
|
|
await Tasks.bulkCreate(TasksData);
|
|
|
|
await Tenants.bulkCreate(TenantsData);
|
|
|
|
await Promise.all([
|
|
// Similar logic for "relation_many"
|
|
|
|
await associateUserWithTenant(),
|
|
|
|
await associateProjectWithManager(),
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
await associateProjectWithTenant(),
|
|
|
|
await associateProjectWithTenant(),
|
|
|
|
await associateTaskWithAssignee(),
|
|
|
|
await associateTaskWithProject(),
|
|
|
|
await associateTaskWithTenant(),
|
|
]);
|
|
},
|
|
|
|
down: async (queryInterface, Sequelize) => {
|
|
await queryInterface.bulkDelete('projects', null, {});
|
|
|
|
await queryInterface.bulkDelete('tasks', null, {});
|
|
|
|
await queryInterface.bulkDelete('tenants', null, {});
|
|
},
|
|
};
|