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

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

const Orders = db.orders;

const Returns = db.returns;

const Shipments = db.shipments;

const Organizations = db.organizations;

const OrdersData = [
  {
    order_number: 'ORD001',

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

    total_amount: 150.75,

    status: 'pending',

    // type code here for "relation_one" field

    // type code here for "relation_many" field

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

  {
    order_number: 'ORD002',

    order_date: new Date('2023-10-02T11:30:00Z'),

    total_amount: 200,

    status: 'returned',

    // type code here for "relation_one" field

    // type code here for "relation_many" field

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

  {
    order_number: 'ORD003',

    order_date: new Date('2023-10-03T09:15:00Z'),

    total_amount: 99.99,

    status: 'delivered',

    // type code here for "relation_one" field

    // type code here for "relation_many" field

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

  {
    order_number: 'ORD004',

    order_date: new Date('2023-10-04T14:45:00Z'),

    total_amount: 250.5,

    status: 'pending',

    // type code here for "relation_one" field

    // type code here for "relation_many" field

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

const ReturnsData = [
  {
    return_id: 'RET001',

    return_date: new Date('2023-10-07T10:00:00Z'),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

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

  {
    return_id: 'RET002',

    return_date: new Date('2023-10-08T11:30:00Z'),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

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

  {
    return_id: 'Pierre Simon de Laplace',

    return_date: new Date(Date.now()),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

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

  {
    return_id: 'Johannes Kepler',

    return_date: new Date(Date.now()),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

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

const ShipmentsData = [
  {
    tracking_number: 'TRK001',

    shipment_date: new Date('2023-10-02T12:00:00Z'),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    carrier: 'Jean Baptiste Lamarck',

    destination: 'Alfred Binet',
  },

  {
    tracking_number: 'TRK002',

    shipment_date: new Date('2023-10-03T13:30:00Z'),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    carrier: 'George Gaylord Simpson',

    destination: 'Albrecht von Haller',
  },

  {
    tracking_number: 'TRK003',

    shipment_date: new Date('2023-10-05T15:00:00Z'),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    carrier: 'Louis Pasteur',

    destination: 'Marcello Malpighi',
  },

  {
    tracking_number: 'Noam Chomsky',

    shipment_date: new Date(Date.now()),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    carrier: 'George Gaylord Simpson',

    destination: 'Gustav Kirchhoff',
  },
];

const OrganizationsData = [
  {
    name: 'Shopify Store',
  },

  {
    name: 'WooCommerce Store',
  },

  {
    name: 'Magento2 Store',
  },

  {
    name: 'Lucretius',
  },
];

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

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User3 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (User3?.setOrganization) {
    await User3.setOrganization(relatedOrganization3);
  }
}

async function associateOrderWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Order0 = await Orders.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Order0?.setOrganization) {
    await Order0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Order1 = await Orders.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Order1?.setOrganization) {
    await Order1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Order2 = await Orders.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Order2?.setOrganization) {
    await Order2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Order3 = await Orders.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Order3?.setOrganization) {
    await Order3.setOrganization(relatedOrganization3);
  }
}

// Similar logic for "relation_many"

async function associateOrderWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Order0 = await Orders.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Order0?.setOrganization) {
    await Order0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Order1 = await Orders.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Order1?.setOrganization) {
    await Order1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Order2 = await Orders.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Order2?.setOrganization) {
    await Order2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Order3 = await Orders.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Order3?.setOrganization) {
    await Order3.setOrganization(relatedOrganization3);
  }
}

async function associateReturnWithOrder() {
  const relatedOrder0 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const Return0 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Return0?.setOrder) {
    await Return0.setOrder(relatedOrder0);
  }

  const relatedOrder1 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const Return1 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Return1?.setOrder) {
    await Return1.setOrder(relatedOrder1);
  }

  const relatedOrder2 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const Return2 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Return2?.setOrder) {
    await Return2.setOrder(relatedOrder2);
  }

  const relatedOrder3 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const Return3 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Return3?.setOrder) {
    await Return3.setOrder(relatedOrder3);
  }
}

async function associateReturnWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Return0 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Return0?.setOrganization) {
    await Return0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Return1 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Return1?.setOrganization) {
    await Return1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Return2 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Return2?.setOrganization) {
    await Return2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Return3 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Return3?.setOrganization) {
    await Return3.setOrganization(relatedOrganization3);
  }
}

async function associateReturnWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Return0 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Return0?.setOrganization) {
    await Return0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Return1 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Return1?.setOrganization) {
    await Return1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Return2 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Return2?.setOrganization) {
    await Return2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Return3 = await Returns.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Return3?.setOrganization) {
    await Return3.setOrganization(relatedOrganization3);
  }
}

async function associateShipmentWithOrder() {
  const relatedOrder0 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const Shipment0 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Shipment0?.setOrder) {
    await Shipment0.setOrder(relatedOrder0);
  }

  const relatedOrder1 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const Shipment1 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Shipment1?.setOrder) {
    await Shipment1.setOrder(relatedOrder1);
  }

  const relatedOrder2 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const Shipment2 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Shipment2?.setOrder) {
    await Shipment2.setOrder(relatedOrder2);
  }

  const relatedOrder3 = await Orders.findOne({
    offset: Math.floor(Math.random() * (await Orders.count())),
  });
  const Shipment3 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Shipment3?.setOrder) {
    await Shipment3.setOrder(relatedOrder3);
  }
}

async function associateShipmentWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Shipment0 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Shipment0?.setOrganization) {
    await Shipment0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Shipment1 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Shipment1?.setOrganization) {
    await Shipment1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Shipment2 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Shipment2?.setOrganization) {
    await Shipment2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Shipment3 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Shipment3?.setOrganization) {
    await Shipment3.setOrganization(relatedOrganization3);
  }
}

async function associateShipmentWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Shipment0 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Shipment0?.setOrganization) {
    await Shipment0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Shipment1 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Shipment1?.setOrganization) {
    await Shipment1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Shipment2 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Shipment2?.setOrganization) {
    await Shipment2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Shipment3 = await Shipments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Shipment3?.setOrganization) {
    await Shipment3.setOrganization(relatedOrganization3);
  }
}

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

    await Returns.bulkCreate(ReturnsData);

    await Shipments.bulkCreate(ShipmentsData);

    await Organizations.bulkCreate(OrganizationsData);

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

      await associateUserWithOrganization(),

      await associateOrderWithOrganization(),

      // Similar logic for "relation_many"

      await associateOrderWithOrganization(),

      await associateReturnWithOrder(),

      await associateReturnWithOrganization(),

      await associateReturnWithOrganization(),

      await associateShipmentWithOrder(),

      await associateShipmentWithOrganization(),

      await associateShipmentWithOrganization(),
    ]);
  },

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

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

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

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