30125/backend/src/db/seeders/20231127130745-sample-data.js

const db = require('../models');
const Users = db.users;

const EvaluationCriteria = db.evaluation_criteria;

const Evaluations = db.evaluations;

const IsoRequirements = db.iso_requirements;

const EvaluationCriteriaData = [
  {
    criterion_name: 'Risk Assessment',

    rating: 'partial-conformity',

    // type code here for "relation_one" field
  },

  {
    criterion_name: 'Leadership Involvement',

    rating: 'full-conformity',

    // type code here for "relation_one" field
  },

  {
    criterion_name: 'Resource Allocation',

    rating: 'full-conformity',

    // type code here for "relation_one" field
  },

  {
    criterion_name: 'Process Control',

    rating: 'full-conformity',

    // type code here for "relation_one" field
  },
];

const EvaluationsData = [
  {
    // type code here for "relation_one" field

    // type code here for "relation_many" field

    evaluation_date: new Date('2023-10-01T10:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_many" field

    evaluation_date: new Date('2023-10-02T11:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_many" field

    evaluation_date: new Date('2023-10-03T12:00:00Z'),
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_many" field

    evaluation_date: new Date('2023-10-04T13:00:00Z'),
  },
];

const IsoRequirementsData = [
  {
    requirement_code: '4.1',

    description: 'Understanding the organization and its context.',

    // type code here for "relation_many" field
  },

  {
    requirement_code: '5.1',

    description: 'Leadership and commitment.',

    // type code here for "relation_many" field
  },

  {
    requirement_code: '6.1',

    description: 'Actions to address risks and opportunities.',

    // type code here for "relation_many" field
  },

  {
    requirement_code: '7.1',

    description: 'Resources.',

    // type code here for "relation_many" field
  },
];

// Similar logic for "relation_many"

async function associateEvaluationCriteriumWithIso_requirement() {
  const relatedIso_requirement0 = await IsoRequirements.findOne({
    offset: Math.floor(Math.random() * (await IsoRequirements.count())),
  });
  const EvaluationCriterium0 = await EvaluationCriteria.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EvaluationCriterium0?.setIso_requirement) {
    await EvaluationCriterium0.setIso_requirement(relatedIso_requirement0);
  }

  const relatedIso_requirement1 = await IsoRequirements.findOne({
    offset: Math.floor(Math.random() * (await IsoRequirements.count())),
  });
  const EvaluationCriterium1 = await EvaluationCriteria.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EvaluationCriterium1?.setIso_requirement) {
    await EvaluationCriterium1.setIso_requirement(relatedIso_requirement1);
  }

  const relatedIso_requirement2 = await IsoRequirements.findOne({
    offset: Math.floor(Math.random() * (await IsoRequirements.count())),
  });
  const EvaluationCriterium2 = await EvaluationCriteria.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EvaluationCriterium2?.setIso_requirement) {
    await EvaluationCriterium2.setIso_requirement(relatedIso_requirement2);
  }

  const relatedIso_requirement3 = await IsoRequirements.findOne({
    offset: Math.floor(Math.random() * (await IsoRequirements.count())),
  });
  const EvaluationCriterium3 = await EvaluationCriteria.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (EvaluationCriterium3?.setIso_requirement) {
    await EvaluationCriterium3.setIso_requirement(relatedIso_requirement3);
  }
}

async function associateEvaluationWithUser() {
  const relatedUser0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Evaluation0 = await Evaluations.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Evaluation0?.setUser) {
    await Evaluation0.setUser(relatedUser0);
  }

  const relatedUser1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Evaluation1 = await Evaluations.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Evaluation1?.setUser) {
    await Evaluation1.setUser(relatedUser1);
  }

  const relatedUser2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Evaluation2 = await Evaluations.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Evaluation2?.setUser) {
    await Evaluation2.setUser(relatedUser2);
  }

  const relatedUser3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Evaluation3 = await Evaluations.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Evaluation3?.setUser) {
    await Evaluation3.setUser(relatedUser3);
  }
}

// Similar logic for "relation_many"

// Similar logic for "relation_many"

module.exports = {
  up: async (queryInterface, Sequelize) => {
    await EvaluationCriteria.bulkCreate(EvaluationCriteriaData);

    await Evaluations.bulkCreate(EvaluationsData);

    await IsoRequirements.bulkCreate(IsoRequirementsData);

    await Promise.all([
      // Similar logic for "relation_many"

      await associateEvaluationCriteriumWithIso_requirement(),

      await associateEvaluationWithUser(),

      // Similar logic for "relation_many"

      // Similar logic for "relation_many"
    ]);
  },

  down: async (queryInterface, Sequelize) => {
    await queryInterface.bulkDelete('evaluation_criteria', null, {});

    await queryInterface.bulkDelete('evaluations', null, {});

    await queryInterface.bulkDelete('iso_requirements', null, {});
  },
};