1331 lines
32 KiB
JavaScript
1331 lines
32 KiB
JavaScript
const db = require('../models');
|
|
const Users = db.users;
|
|
|
|
const Deliveries = db.deliveries;
|
|
|
|
const Medicines = db.medicines;
|
|
|
|
const OrderItems = db.order_items;
|
|
|
|
const Orders = db.orders;
|
|
|
|
const Payments = db.payments;
|
|
|
|
const Pharmacies = db.pharmacies;
|
|
|
|
const Prescriptions = db.prescriptions;
|
|
|
|
const Organizations = db.organizations;
|
|
|
|
const DeliveriesData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
address: '123 Main St, City A',
|
|
|
|
tracking_status: 'processing',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
address: '456 Elm St, City B',
|
|
|
|
tracking_status: 'delivered',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
address: '789 Oak St, City C',
|
|
|
|
tracking_status: 'delivered',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
address: '101 Pine St, City D',
|
|
|
|
tracking_status: 'processing',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const MedicinesData = [
|
|
{
|
|
name: 'Paracetamol',
|
|
|
|
generic_name: 'Acetaminophen',
|
|
|
|
brand: 'Tylenol',
|
|
|
|
price: 2.5,
|
|
|
|
stock: 100,
|
|
|
|
category: 'OTC',
|
|
|
|
schedule: 'H1',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Amoxicillin',
|
|
|
|
generic_name: 'Amoxicillin',
|
|
|
|
brand: 'Amoxil',
|
|
|
|
price: 5,
|
|
|
|
stock: 50,
|
|
|
|
category: 'Prescription',
|
|
|
|
schedule: 'X',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Ibuprofen',
|
|
|
|
generic_name: 'Ibuprofen',
|
|
|
|
brand: 'Advil',
|
|
|
|
price: 3,
|
|
|
|
stock: 200,
|
|
|
|
category: 'Prescription',
|
|
|
|
schedule: 'X',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Metformin',
|
|
|
|
generic_name: 'Metformin',
|
|
|
|
brand: 'Glucophage',
|
|
|
|
price: 4,
|
|
|
|
stock: 150,
|
|
|
|
category: 'Prescription',
|
|
|
|
schedule: 'H',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const OrderItemsData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
quantity: 2,
|
|
|
|
price: 5,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
quantity: 1,
|
|
|
|
price: 5,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
quantity: 3,
|
|
|
|
price: 9,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
quantity: 2,
|
|
|
|
price: 8,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const OrdersData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
status: 'pending',
|
|
|
|
order_date: new Date('2023-10-01T10:00:00Z'),
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
status: 'pending',
|
|
|
|
order_date: new Date('2023-10-02T11:00:00Z'),
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
status: 'delivered',
|
|
|
|
order_date: new Date('2023-10-03T12:00:00Z'),
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
status: 'dispatched',
|
|
|
|
order_date: new Date('2023-10-04T13:00:00Z'),
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const PaymentsData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
amount: 10,
|
|
|
|
method: 'Wallet',
|
|
|
|
status: 'completed',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
amount: 5,
|
|
|
|
method: 'UPI',
|
|
|
|
status: 'completed',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
amount: 9,
|
|
|
|
method: 'UPI',
|
|
|
|
status: 'completed',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
amount: 8,
|
|
|
|
method: 'Wallet',
|
|
|
|
status: 'pending',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const PharmaciesData = [
|
|
{
|
|
name: 'HealthPlus Pharmacy',
|
|
|
|
license_number: 'LIC123456',
|
|
|
|
// type code here for "files" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'MediCare Store',
|
|
|
|
license_number: 'LIC654321',
|
|
|
|
// type code here for "files" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Wellness Pharmacy',
|
|
|
|
license_number: 'LIC112233',
|
|
|
|
// type code here for "files" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'CareWell Drugs',
|
|
|
|
license_number: 'LIC445566',
|
|
|
|
// type code here for "files" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const PrescriptionsData = [
|
|
{
|
|
// type code here for "files" field
|
|
|
|
verified: true,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "files" field
|
|
|
|
verified: false,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "files" field
|
|
|
|
verified: true,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "files" field
|
|
|
|
verified: true,
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const OrganizationsData = [
|
|
{
|
|
name: 'Hans Selye',
|
|
},
|
|
|
|
{
|
|
name: 'Charles Lyell',
|
|
},
|
|
|
|
{
|
|
name: 'Comte de Buffon',
|
|
},
|
|
|
|
{
|
|
name: 'Comte de Buffon',
|
|
},
|
|
];
|
|
|
|
// 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 associateDeliveryWithOrder() {
|
|
const relatedOrder0 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Delivery0 = await Deliveries.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Delivery0?.setOrder) {
|
|
await Delivery0.setOrder(relatedOrder0);
|
|
}
|
|
|
|
const relatedOrder1 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Delivery1 = await Deliveries.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Delivery1?.setOrder) {
|
|
await Delivery1.setOrder(relatedOrder1);
|
|
}
|
|
|
|
const relatedOrder2 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Delivery2 = await Deliveries.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Delivery2?.setOrder) {
|
|
await Delivery2.setOrder(relatedOrder2);
|
|
}
|
|
|
|
const relatedOrder3 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Delivery3 = await Deliveries.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Delivery3?.setOrder) {
|
|
await Delivery3.setOrder(relatedOrder3);
|
|
}
|
|
}
|
|
|
|
async function associateDeliveryWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Delivery0 = await Deliveries.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Delivery0?.setOrganization) {
|
|
await Delivery0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Delivery1 = await Deliveries.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Delivery1?.setOrganization) {
|
|
await Delivery1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Delivery2 = await Deliveries.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Delivery2?.setOrganization) {
|
|
await Delivery2.setOrganization(relatedOrganization2);
|
|
}
|
|
|
|
const relatedOrganization3 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Delivery3 = await Deliveries.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Delivery3?.setOrganization) {
|
|
await Delivery3.setOrganization(relatedOrganization3);
|
|
}
|
|
}
|
|
|
|
async function associateMedicineWithPharmacy() {
|
|
const relatedPharmacy0 = await Pharmacies.findOne({
|
|
offset: Math.floor(Math.random() * (await Pharmacies.count())),
|
|
});
|
|
const Medicine0 = await Medicines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Medicine0?.setPharmacy) {
|
|
await Medicine0.setPharmacy(relatedPharmacy0);
|
|
}
|
|
|
|
const relatedPharmacy1 = await Pharmacies.findOne({
|
|
offset: Math.floor(Math.random() * (await Pharmacies.count())),
|
|
});
|
|
const Medicine1 = await Medicines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Medicine1?.setPharmacy) {
|
|
await Medicine1.setPharmacy(relatedPharmacy1);
|
|
}
|
|
|
|
const relatedPharmacy2 = await Pharmacies.findOne({
|
|
offset: Math.floor(Math.random() * (await Pharmacies.count())),
|
|
});
|
|
const Medicine2 = await Medicines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Medicine2?.setPharmacy) {
|
|
await Medicine2.setPharmacy(relatedPharmacy2);
|
|
}
|
|
|
|
const relatedPharmacy3 = await Pharmacies.findOne({
|
|
offset: Math.floor(Math.random() * (await Pharmacies.count())),
|
|
});
|
|
const Medicine3 = await Medicines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Medicine3?.setPharmacy) {
|
|
await Medicine3.setPharmacy(relatedPharmacy3);
|
|
}
|
|
}
|
|
|
|
async function associateMedicineWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Medicine0 = await Medicines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Medicine0?.setOrganization) {
|
|
await Medicine0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Medicine1 = await Medicines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Medicine1?.setOrganization) {
|
|
await Medicine1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Medicine2 = await Medicines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Medicine2?.setOrganization) {
|
|
await Medicine2.setOrganization(relatedOrganization2);
|
|
}
|
|
|
|
const relatedOrganization3 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Medicine3 = await Medicines.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Medicine3?.setOrganization) {
|
|
await Medicine3.setOrganization(relatedOrganization3);
|
|
}
|
|
}
|
|
|
|
async function associateOrderItemWithMedicine() {
|
|
const relatedMedicine0 = await Medicines.findOne({
|
|
offset: Math.floor(Math.random() * (await Medicines.count())),
|
|
});
|
|
const OrderItem0 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (OrderItem0?.setMedicine) {
|
|
await OrderItem0.setMedicine(relatedMedicine0);
|
|
}
|
|
|
|
const relatedMedicine1 = await Medicines.findOne({
|
|
offset: Math.floor(Math.random() * (await Medicines.count())),
|
|
});
|
|
const OrderItem1 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (OrderItem1?.setMedicine) {
|
|
await OrderItem1.setMedicine(relatedMedicine1);
|
|
}
|
|
|
|
const relatedMedicine2 = await Medicines.findOne({
|
|
offset: Math.floor(Math.random() * (await Medicines.count())),
|
|
});
|
|
const OrderItem2 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (OrderItem2?.setMedicine) {
|
|
await OrderItem2.setMedicine(relatedMedicine2);
|
|
}
|
|
|
|
const relatedMedicine3 = await Medicines.findOne({
|
|
offset: Math.floor(Math.random() * (await Medicines.count())),
|
|
});
|
|
const OrderItem3 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (OrderItem3?.setMedicine) {
|
|
await OrderItem3.setMedicine(relatedMedicine3);
|
|
}
|
|
}
|
|
|
|
async function associateOrderItemWithOrder() {
|
|
const relatedOrder0 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const OrderItem0 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (OrderItem0?.setOrder) {
|
|
await OrderItem0.setOrder(relatedOrder0);
|
|
}
|
|
|
|
const relatedOrder1 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const OrderItem1 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (OrderItem1?.setOrder) {
|
|
await OrderItem1.setOrder(relatedOrder1);
|
|
}
|
|
|
|
const relatedOrder2 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const OrderItem2 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (OrderItem2?.setOrder) {
|
|
await OrderItem2.setOrder(relatedOrder2);
|
|
}
|
|
|
|
const relatedOrder3 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const OrderItem3 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (OrderItem3?.setOrder) {
|
|
await OrderItem3.setOrder(relatedOrder3);
|
|
}
|
|
}
|
|
|
|
async function associateOrderItemWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const OrderItem0 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (OrderItem0?.setOrganization) {
|
|
await OrderItem0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const OrderItem1 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (OrderItem1?.setOrganization) {
|
|
await OrderItem1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const OrderItem2 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (OrderItem2?.setOrganization) {
|
|
await OrderItem2.setOrganization(relatedOrganization2);
|
|
}
|
|
|
|
const relatedOrganization3 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const OrderItem3 = await OrderItems.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (OrderItem3?.setOrganization) {
|
|
await OrderItem3.setOrganization(relatedOrganization3);
|
|
}
|
|
}
|
|
|
|
async function associateOrderWithCustomer() {
|
|
const relatedCustomer0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Order0 = await Orders.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Order0?.setCustomer) {
|
|
await Order0.setCustomer(relatedCustomer0);
|
|
}
|
|
|
|
const relatedCustomer1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Order1 = await Orders.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Order1?.setCustomer) {
|
|
await Order1.setCustomer(relatedCustomer1);
|
|
}
|
|
|
|
const relatedCustomer2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Order2 = await Orders.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Order2?.setCustomer) {
|
|
await Order2.setCustomer(relatedCustomer2);
|
|
}
|
|
|
|
const relatedCustomer3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Order3 = await Orders.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Order3?.setCustomer) {
|
|
await Order3.setCustomer(relatedCustomer3);
|
|
}
|
|
}
|
|
|
|
async function associateOrderWithPharmacy() {
|
|
const relatedPharmacy0 = await Pharmacies.findOne({
|
|
offset: Math.floor(Math.random() * (await Pharmacies.count())),
|
|
});
|
|
const Order0 = await Orders.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Order0?.setPharmacy) {
|
|
await Order0.setPharmacy(relatedPharmacy0);
|
|
}
|
|
|
|
const relatedPharmacy1 = await Pharmacies.findOne({
|
|
offset: Math.floor(Math.random() * (await Pharmacies.count())),
|
|
});
|
|
const Order1 = await Orders.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Order1?.setPharmacy) {
|
|
await Order1.setPharmacy(relatedPharmacy1);
|
|
}
|
|
|
|
const relatedPharmacy2 = await Pharmacies.findOne({
|
|
offset: Math.floor(Math.random() * (await Pharmacies.count())),
|
|
});
|
|
const Order2 = await Orders.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Order2?.setPharmacy) {
|
|
await Order2.setPharmacy(relatedPharmacy2);
|
|
}
|
|
|
|
const relatedPharmacy3 = await Pharmacies.findOne({
|
|
offset: Math.floor(Math.random() * (await Pharmacies.count())),
|
|
});
|
|
const Order3 = await Orders.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Order3?.setPharmacy) {
|
|
await Order3.setPharmacy(relatedPharmacy3);
|
|
}
|
|
}
|
|
|
|
// 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 associatePaymentWithOrder() {
|
|
const relatedOrder0 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Payment0 = await Payments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Payment0?.setOrder) {
|
|
await Payment0.setOrder(relatedOrder0);
|
|
}
|
|
|
|
const relatedOrder1 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Payment1 = await Payments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Payment1?.setOrder) {
|
|
await Payment1.setOrder(relatedOrder1);
|
|
}
|
|
|
|
const relatedOrder2 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Payment2 = await Payments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Payment2?.setOrder) {
|
|
await Payment2.setOrder(relatedOrder2);
|
|
}
|
|
|
|
const relatedOrder3 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Payment3 = await Payments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Payment3?.setOrder) {
|
|
await Payment3.setOrder(relatedOrder3);
|
|
}
|
|
}
|
|
|
|
async function associatePaymentWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Payment0 = await Payments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Payment0?.setOrganization) {
|
|
await Payment0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Payment1 = await Payments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Payment1?.setOrganization) {
|
|
await Payment1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Payment2 = await Payments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Payment2?.setOrganization) {
|
|
await Payment2.setOrganization(relatedOrganization2);
|
|
}
|
|
|
|
const relatedOrganization3 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Payment3 = await Payments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Payment3?.setOrganization) {
|
|
await Payment3.setOrganization(relatedOrganization3);
|
|
}
|
|
}
|
|
|
|
async function associatePharmacyWithOwner() {
|
|
const relatedOwner0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Pharmacy0 = await Pharmacies.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Pharmacy0?.setOwner) {
|
|
await Pharmacy0.setOwner(relatedOwner0);
|
|
}
|
|
|
|
const relatedOwner1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Pharmacy1 = await Pharmacies.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Pharmacy1?.setOwner) {
|
|
await Pharmacy1.setOwner(relatedOwner1);
|
|
}
|
|
|
|
const relatedOwner2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Pharmacy2 = await Pharmacies.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Pharmacy2?.setOwner) {
|
|
await Pharmacy2.setOwner(relatedOwner2);
|
|
}
|
|
|
|
const relatedOwner3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Pharmacy3 = await Pharmacies.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Pharmacy3?.setOwner) {
|
|
await Pharmacy3.setOwner(relatedOwner3);
|
|
}
|
|
}
|
|
|
|
async function associatePharmacyWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Pharmacy0 = await Pharmacies.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Pharmacy0?.setOrganization) {
|
|
await Pharmacy0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Pharmacy1 = await Pharmacies.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Pharmacy1?.setOrganization) {
|
|
await Pharmacy1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Pharmacy2 = await Pharmacies.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Pharmacy2?.setOrganization) {
|
|
await Pharmacy2.setOrganization(relatedOrganization2);
|
|
}
|
|
|
|
const relatedOrganization3 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Pharmacy3 = await Pharmacies.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Pharmacy3?.setOrganization) {
|
|
await Pharmacy3.setOrganization(relatedOrganization3);
|
|
}
|
|
}
|
|
|
|
async function associatePrescriptionWithCustomer() {
|
|
const relatedCustomer0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Prescription0 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Prescription0?.setCustomer) {
|
|
await Prescription0.setCustomer(relatedCustomer0);
|
|
}
|
|
|
|
const relatedCustomer1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Prescription1 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Prescription1?.setCustomer) {
|
|
await Prescription1.setCustomer(relatedCustomer1);
|
|
}
|
|
|
|
const relatedCustomer2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Prescription2 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Prescription2?.setCustomer) {
|
|
await Prescription2.setCustomer(relatedCustomer2);
|
|
}
|
|
|
|
const relatedCustomer3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Prescription3 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Prescription3?.setCustomer) {
|
|
await Prescription3.setCustomer(relatedCustomer3);
|
|
}
|
|
}
|
|
|
|
async function associatePrescriptionWithOrder() {
|
|
const relatedOrder0 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Prescription0 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Prescription0?.setOrder) {
|
|
await Prescription0.setOrder(relatedOrder0);
|
|
}
|
|
|
|
const relatedOrder1 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Prescription1 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Prescription1?.setOrder) {
|
|
await Prescription1.setOrder(relatedOrder1);
|
|
}
|
|
|
|
const relatedOrder2 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Prescription2 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Prescription2?.setOrder) {
|
|
await Prescription2.setOrder(relatedOrder2);
|
|
}
|
|
|
|
const relatedOrder3 = await Orders.findOne({
|
|
offset: Math.floor(Math.random() * (await Orders.count())),
|
|
});
|
|
const Prescription3 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Prescription3?.setOrder) {
|
|
await Prescription3.setOrder(relatedOrder3);
|
|
}
|
|
}
|
|
|
|
async function associatePrescriptionWithOrganization() {
|
|
const relatedOrganization0 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Prescription0 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Prescription0?.setOrganization) {
|
|
await Prescription0.setOrganization(relatedOrganization0);
|
|
}
|
|
|
|
const relatedOrganization1 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Prescription1 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Prescription1?.setOrganization) {
|
|
await Prescription1.setOrganization(relatedOrganization1);
|
|
}
|
|
|
|
const relatedOrganization2 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Prescription2 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Prescription2?.setOrganization) {
|
|
await Prescription2.setOrganization(relatedOrganization2);
|
|
}
|
|
|
|
const relatedOrganization3 = await Organizations.findOne({
|
|
offset: Math.floor(Math.random() * (await Organizations.count())),
|
|
});
|
|
const Prescription3 = await Prescriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Prescription3?.setOrganization) {
|
|
await Prescription3.setOrganization(relatedOrganization3);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
up: async (queryInterface, Sequelize) => {
|
|
await Deliveries.bulkCreate(DeliveriesData);
|
|
|
|
await Medicines.bulkCreate(MedicinesData);
|
|
|
|
await OrderItems.bulkCreate(OrderItemsData);
|
|
|
|
await Orders.bulkCreate(OrdersData);
|
|
|
|
await Payments.bulkCreate(PaymentsData);
|
|
|
|
await Pharmacies.bulkCreate(PharmaciesData);
|
|
|
|
await Prescriptions.bulkCreate(PrescriptionsData);
|
|
|
|
await Organizations.bulkCreate(OrganizationsData);
|
|
|
|
await Promise.all([
|
|
// Similar logic for "relation_many"
|
|
|
|
await associateUserWithOrganization(),
|
|
|
|
await associateDeliveryWithOrder(),
|
|
|
|
await associateDeliveryWithOrganization(),
|
|
|
|
await associateMedicineWithPharmacy(),
|
|
|
|
await associateMedicineWithOrganization(),
|
|
|
|
await associateOrderItemWithMedicine(),
|
|
|
|
await associateOrderItemWithOrder(),
|
|
|
|
await associateOrderItemWithOrganization(),
|
|
|
|
await associateOrderWithCustomer(),
|
|
|
|
await associateOrderWithPharmacy(),
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
await associateOrderWithOrganization(),
|
|
|
|
await associatePaymentWithOrder(),
|
|
|
|
await associatePaymentWithOrganization(),
|
|
|
|
await associatePharmacyWithOwner(),
|
|
|
|
await associatePharmacyWithOrganization(),
|
|
|
|
await associatePrescriptionWithCustomer(),
|
|
|
|
await associatePrescriptionWithOrder(),
|
|
|
|
await associatePrescriptionWithOrganization(),
|
|
]);
|
|
},
|
|
|
|
down: async (queryInterface, Sequelize) => {
|
|
await queryInterface.bulkDelete('deliveries', null, {});
|
|
|
|
await queryInterface.bulkDelete('medicines', null, {});
|
|
|
|
await queryInterface.bulkDelete('order_items', null, {});
|
|
|
|
await queryInterface.bulkDelete('orders', null, {});
|
|
|
|
await queryInterface.bulkDelete('payments', null, {});
|
|
|
|
await queryInterface.bulkDelete('pharmacies', null, {});
|
|
|
|
await queryInterface.bulkDelete('prescriptions', null, {});
|
|
|
|
await queryInterface.bulkDelete('organizations', null, {});
|
|
},
|
|
};
|