919 lines
23 KiB
JavaScript
919 lines
23 KiB
JavaScript
const db = require('../models');
|
|
const Users = db.users;
|
|
|
|
const Bookings = db.bookings;
|
|
|
|
const Reviews = db.reviews;
|
|
|
|
const ServiceCategories = db.service_categories;
|
|
|
|
const Services = db.services;
|
|
|
|
const Providerspace = db.providerspace;
|
|
|
|
const BookingsData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
date_time: new Date('2023-10-10T09:00:00Z'),
|
|
|
|
status: 'Confirmed',
|
|
|
|
payment_status: 'Pending',
|
|
|
|
// 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 "relation_one" field
|
|
|
|
date_time: new Date('2023-10-11T10:00:00Z'),
|
|
|
|
status: 'Confirmed',
|
|
|
|
payment_status: 'Refunded',
|
|
|
|
// 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 "relation_one" field
|
|
|
|
date_time: new Date('2023-10-12T11:00:00Z'),
|
|
|
|
status: 'Cancelled',
|
|
|
|
payment_status: 'Paid',
|
|
|
|
// 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 "relation_one" field
|
|
|
|
date_time: new Date('2023-10-13T12:00:00Z'),
|
|
|
|
status: 'Completed',
|
|
|
|
payment_status: 'Paid',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const ReviewsData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
rating: 5,
|
|
|
|
comment: 'Excellent service, very professional.',
|
|
|
|
// 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 "relation_one" field
|
|
|
|
rating: 4,
|
|
|
|
comment: 'Good job, but could be more thorough.',
|
|
|
|
// 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 "relation_one" field
|
|
|
|
rating: 5,
|
|
|
|
comment: 'Quick and efficient installation.',
|
|
|
|
// 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 "relation_one" field
|
|
|
|
rating: 3,
|
|
|
|
comment: 'Average service, not very punctual.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const ServiceCategoriesData = [
|
|
{
|
|
name: 'Plumbing',
|
|
|
|
description: 'Services related to plumbing and pipe repairs.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Cleaning',
|
|
|
|
description: 'House and office cleaning services.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Electrical',
|
|
|
|
description: 'Electrical installation and repair services.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
name: 'Gardening',
|
|
|
|
description: 'Lawn mowing and garden maintenance services.',
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const ServicesData = [
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
title: 'Leak Repair',
|
|
|
|
description: 'Fixing leaks in pipes and faucets.',
|
|
|
|
price: 50,
|
|
|
|
availability: '{Monday: 9am-5pm, Wednesday: 9am-5pm}',
|
|
|
|
rating: 4.5,
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
title: 'House Cleaning',
|
|
|
|
description: 'Comprehensive house cleaning services.',
|
|
|
|
price: 75,
|
|
|
|
availability: '{Tuesday: 10am-6pm, Thursday: 10am-6pm}',
|
|
|
|
rating: 4.7,
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
title: 'Light Installation',
|
|
|
|
description: 'Installing new light fixtures.',
|
|
|
|
price: 100,
|
|
|
|
availability: '{Friday: 8am-4pm, Saturday: 8am-4pm}',
|
|
|
|
rating: 4.8,
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
title: 'Lawn Mowing',
|
|
|
|
description: 'Regular lawn mowing services.',
|
|
|
|
price: 40,
|
|
|
|
availability: '{Monday: 7am-3pm, Wednesday: 7am-3pm}',
|
|
|
|
rating: 4.6,
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const ProviderspaceData = [
|
|
{
|
|
name: 'Stephen Hawking',
|
|
},
|
|
|
|
{
|
|
name: 'Ernest Rutherford',
|
|
},
|
|
|
|
{
|
|
name: 'Leonard Euler',
|
|
},
|
|
|
|
{
|
|
name: 'Stephen Hawking',
|
|
},
|
|
];
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
async function associateUserWithProviderspace() {
|
|
const relatedProviderspace0 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const User0 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (User0?.setProviderspace) {
|
|
await User0.setProviderspace(relatedProviderspace0);
|
|
}
|
|
|
|
const relatedProviderspace1 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const User1 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (User1?.setProviderspace) {
|
|
await User1.setProviderspace(relatedProviderspace1);
|
|
}
|
|
|
|
const relatedProviderspace2 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const User2 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (User2?.setProviderspace) {
|
|
await User2.setProviderspace(relatedProviderspace2);
|
|
}
|
|
|
|
const relatedProviderspace3 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const User3 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (User3?.setProviderspace) {
|
|
await User3.setProviderspace(relatedProviderspace3);
|
|
}
|
|
}
|
|
|
|
async function associateBookingWithCustomer() {
|
|
const relatedCustomer0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Booking0 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Booking0?.setCustomer) {
|
|
await Booking0.setCustomer(relatedCustomer0);
|
|
}
|
|
|
|
const relatedCustomer1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Booking1 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Booking1?.setCustomer) {
|
|
await Booking1.setCustomer(relatedCustomer1);
|
|
}
|
|
|
|
const relatedCustomer2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Booking2 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Booking2?.setCustomer) {
|
|
await Booking2.setCustomer(relatedCustomer2);
|
|
}
|
|
|
|
const relatedCustomer3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Booking3 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Booking3?.setCustomer) {
|
|
await Booking3.setCustomer(relatedCustomer3);
|
|
}
|
|
}
|
|
|
|
async function associateBookingWithProvider() {
|
|
const relatedProvider0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Booking0 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Booking0?.setProvider) {
|
|
await Booking0.setProvider(relatedProvider0);
|
|
}
|
|
|
|
const relatedProvider1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Booking1 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Booking1?.setProvider) {
|
|
await Booking1.setProvider(relatedProvider1);
|
|
}
|
|
|
|
const relatedProvider2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Booking2 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Booking2?.setProvider) {
|
|
await Booking2.setProvider(relatedProvider2);
|
|
}
|
|
|
|
const relatedProvider3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Booking3 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Booking3?.setProvider) {
|
|
await Booking3.setProvider(relatedProvider3);
|
|
}
|
|
}
|
|
|
|
async function associateBookingWithService() {
|
|
const relatedService0 = await Services.findOne({
|
|
offset: Math.floor(Math.random() * (await Services.count())),
|
|
});
|
|
const Booking0 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Booking0?.setService) {
|
|
await Booking0.setService(relatedService0);
|
|
}
|
|
|
|
const relatedService1 = await Services.findOne({
|
|
offset: Math.floor(Math.random() * (await Services.count())),
|
|
});
|
|
const Booking1 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Booking1?.setService) {
|
|
await Booking1.setService(relatedService1);
|
|
}
|
|
|
|
const relatedService2 = await Services.findOne({
|
|
offset: Math.floor(Math.random() * (await Services.count())),
|
|
});
|
|
const Booking2 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Booking2?.setService) {
|
|
await Booking2.setService(relatedService2);
|
|
}
|
|
|
|
const relatedService3 = await Services.findOne({
|
|
offset: Math.floor(Math.random() * (await Services.count())),
|
|
});
|
|
const Booking3 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Booking3?.setService) {
|
|
await Booking3.setService(relatedService3);
|
|
}
|
|
}
|
|
|
|
async function associateBookingWithProviderspace() {
|
|
const relatedProviderspace0 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Booking0 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Booking0?.setProviderspace) {
|
|
await Booking0.setProviderspace(relatedProviderspace0);
|
|
}
|
|
|
|
const relatedProviderspace1 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Booking1 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Booking1?.setProviderspace) {
|
|
await Booking1.setProviderspace(relatedProviderspace1);
|
|
}
|
|
|
|
const relatedProviderspace2 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Booking2 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Booking2?.setProviderspace) {
|
|
await Booking2.setProviderspace(relatedProviderspace2);
|
|
}
|
|
|
|
const relatedProviderspace3 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Booking3 = await Bookings.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Booking3?.setProviderspace) {
|
|
await Booking3.setProviderspace(relatedProviderspace3);
|
|
}
|
|
}
|
|
|
|
async function associateReviewWithBooking() {
|
|
const relatedBooking0 = await Bookings.findOne({
|
|
offset: Math.floor(Math.random() * (await Bookings.count())),
|
|
});
|
|
const Review0 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Review0?.setBooking) {
|
|
await Review0.setBooking(relatedBooking0);
|
|
}
|
|
|
|
const relatedBooking1 = await Bookings.findOne({
|
|
offset: Math.floor(Math.random() * (await Bookings.count())),
|
|
});
|
|
const Review1 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Review1?.setBooking) {
|
|
await Review1.setBooking(relatedBooking1);
|
|
}
|
|
|
|
const relatedBooking2 = await Bookings.findOne({
|
|
offset: Math.floor(Math.random() * (await Bookings.count())),
|
|
});
|
|
const Review2 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Review2?.setBooking) {
|
|
await Review2.setBooking(relatedBooking2);
|
|
}
|
|
|
|
const relatedBooking3 = await Bookings.findOne({
|
|
offset: Math.floor(Math.random() * (await Bookings.count())),
|
|
});
|
|
const Review3 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Review3?.setBooking) {
|
|
await Review3.setBooking(relatedBooking3);
|
|
}
|
|
}
|
|
|
|
async function associateReviewWithCustomer() {
|
|
const relatedCustomer0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Review0 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Review0?.setCustomer) {
|
|
await Review0.setCustomer(relatedCustomer0);
|
|
}
|
|
|
|
const relatedCustomer1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Review1 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Review1?.setCustomer) {
|
|
await Review1.setCustomer(relatedCustomer1);
|
|
}
|
|
|
|
const relatedCustomer2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Review2 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Review2?.setCustomer) {
|
|
await Review2.setCustomer(relatedCustomer2);
|
|
}
|
|
|
|
const relatedCustomer3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Review3 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Review3?.setCustomer) {
|
|
await Review3.setCustomer(relatedCustomer3);
|
|
}
|
|
}
|
|
|
|
async function associateReviewWithProvider() {
|
|
const relatedProvider0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Review0 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Review0?.setProvider) {
|
|
await Review0.setProvider(relatedProvider0);
|
|
}
|
|
|
|
const relatedProvider1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Review1 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Review1?.setProvider) {
|
|
await Review1.setProvider(relatedProvider1);
|
|
}
|
|
|
|
const relatedProvider2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Review2 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Review2?.setProvider) {
|
|
await Review2.setProvider(relatedProvider2);
|
|
}
|
|
|
|
const relatedProvider3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Review3 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Review3?.setProvider) {
|
|
await Review3.setProvider(relatedProvider3);
|
|
}
|
|
}
|
|
|
|
async function associateReviewWithProviderspace() {
|
|
const relatedProviderspace0 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Review0 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Review0?.setProviderspace) {
|
|
await Review0.setProviderspace(relatedProviderspace0);
|
|
}
|
|
|
|
const relatedProviderspace1 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Review1 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Review1?.setProviderspace) {
|
|
await Review1.setProviderspace(relatedProviderspace1);
|
|
}
|
|
|
|
const relatedProviderspace2 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Review2 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Review2?.setProviderspace) {
|
|
await Review2.setProviderspace(relatedProviderspace2);
|
|
}
|
|
|
|
const relatedProviderspace3 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Review3 = await Reviews.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Review3?.setProviderspace) {
|
|
await Review3.setProviderspace(relatedProviderspace3);
|
|
}
|
|
}
|
|
|
|
async function associateServiceCategoryWithProviderspace() {
|
|
const relatedProviderspace0 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const ServiceCategory0 = await ServiceCategories.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (ServiceCategory0?.setProviderspace) {
|
|
await ServiceCategory0.setProviderspace(relatedProviderspace0);
|
|
}
|
|
|
|
const relatedProviderspace1 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const ServiceCategory1 = await ServiceCategories.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (ServiceCategory1?.setProviderspace) {
|
|
await ServiceCategory1.setProviderspace(relatedProviderspace1);
|
|
}
|
|
|
|
const relatedProviderspace2 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const ServiceCategory2 = await ServiceCategories.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (ServiceCategory2?.setProviderspace) {
|
|
await ServiceCategory2.setProviderspace(relatedProviderspace2);
|
|
}
|
|
|
|
const relatedProviderspace3 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const ServiceCategory3 = await ServiceCategories.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (ServiceCategory3?.setProviderspace) {
|
|
await ServiceCategory3.setProviderspace(relatedProviderspace3);
|
|
}
|
|
}
|
|
|
|
async function associateServiceWithProvider() {
|
|
const relatedProvider0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Service0 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Service0?.setProvider) {
|
|
await Service0.setProvider(relatedProvider0);
|
|
}
|
|
|
|
const relatedProvider1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Service1 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Service1?.setProvider) {
|
|
await Service1.setProvider(relatedProvider1);
|
|
}
|
|
|
|
const relatedProvider2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Service2 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Service2?.setProvider) {
|
|
await Service2.setProvider(relatedProvider2);
|
|
}
|
|
|
|
const relatedProvider3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Service3 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Service3?.setProvider) {
|
|
await Service3.setProvider(relatedProvider3);
|
|
}
|
|
}
|
|
|
|
async function associateServiceWithCategory() {
|
|
const relatedCategory0 = await ServiceCategories.findOne({
|
|
offset: Math.floor(Math.random() * (await ServiceCategories.count())),
|
|
});
|
|
const Service0 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Service0?.setCategory) {
|
|
await Service0.setCategory(relatedCategory0);
|
|
}
|
|
|
|
const relatedCategory1 = await ServiceCategories.findOne({
|
|
offset: Math.floor(Math.random() * (await ServiceCategories.count())),
|
|
});
|
|
const Service1 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Service1?.setCategory) {
|
|
await Service1.setCategory(relatedCategory1);
|
|
}
|
|
|
|
const relatedCategory2 = await ServiceCategories.findOne({
|
|
offset: Math.floor(Math.random() * (await ServiceCategories.count())),
|
|
});
|
|
const Service2 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Service2?.setCategory) {
|
|
await Service2.setCategory(relatedCategory2);
|
|
}
|
|
|
|
const relatedCategory3 = await ServiceCategories.findOne({
|
|
offset: Math.floor(Math.random() * (await ServiceCategories.count())),
|
|
});
|
|
const Service3 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Service3?.setCategory) {
|
|
await Service3.setCategory(relatedCategory3);
|
|
}
|
|
}
|
|
|
|
async function associateServiceWithProviderspace() {
|
|
const relatedProviderspace0 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Service0 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Service0?.setProviderspace) {
|
|
await Service0.setProviderspace(relatedProviderspace0);
|
|
}
|
|
|
|
const relatedProviderspace1 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Service1 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Service1?.setProviderspace) {
|
|
await Service1.setProviderspace(relatedProviderspace1);
|
|
}
|
|
|
|
const relatedProviderspace2 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Service2 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Service2?.setProviderspace) {
|
|
await Service2.setProviderspace(relatedProviderspace2);
|
|
}
|
|
|
|
const relatedProviderspace3 = await Providerspace.findOne({
|
|
offset: Math.floor(Math.random() * (await Providerspace.count())),
|
|
});
|
|
const Service3 = await Services.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Service3?.setProviderspace) {
|
|
await Service3.setProviderspace(relatedProviderspace3);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
up: async (queryInterface, Sequelize) => {
|
|
await Bookings.bulkCreate(BookingsData);
|
|
|
|
await Reviews.bulkCreate(ReviewsData);
|
|
|
|
await ServiceCategories.bulkCreate(ServiceCategoriesData);
|
|
|
|
await Services.bulkCreate(ServicesData);
|
|
|
|
await Providerspace.bulkCreate(ProviderspaceData);
|
|
|
|
await Promise.all([
|
|
// Similar logic for "relation_many"
|
|
|
|
await associateUserWithProviderspace(),
|
|
|
|
await associateBookingWithCustomer(),
|
|
|
|
await associateBookingWithProvider(),
|
|
|
|
await associateBookingWithService(),
|
|
|
|
await associateBookingWithProviderspace(),
|
|
|
|
await associateReviewWithBooking(),
|
|
|
|
await associateReviewWithCustomer(),
|
|
|
|
await associateReviewWithProvider(),
|
|
|
|
await associateReviewWithProviderspace(),
|
|
|
|
await associateServiceCategoryWithProviderspace(),
|
|
|
|
await associateServiceWithProvider(),
|
|
|
|
await associateServiceWithCategory(),
|
|
|
|
await associateServiceWithProviderspace(),
|
|
]);
|
|
},
|
|
|
|
down: async (queryInterface, Sequelize) => {
|
|
await queryInterface.bulkDelete('bookings', null, {});
|
|
|
|
await queryInterface.bulkDelete('reviews', null, {});
|
|
|
|
await queryInterface.bulkDelete('service_categories', null, {});
|
|
|
|
await queryInterface.bulkDelete('services', null, {});
|
|
|
|
await queryInterface.bulkDelete('providerspace', null, {});
|
|
},
|
|
};
|