878 lines
20 KiB
JavaScript
878 lines
20 KiB
JavaScript
const db = require('../models');
|
|
const Users = db.users;
|
|
|
|
const Anime = db.anime;
|
|
|
|
const Comments = db.comments;
|
|
|
|
const Episodes = db.episodes;
|
|
|
|
const Subscriptions = db.subscriptions;
|
|
|
|
const Aniplay = db.aniplay;
|
|
|
|
const AnimeData = [
|
|
{
|
|
title: 'Naruto',
|
|
|
|
synopsis: 'A young ninja seeks recognition.',
|
|
|
|
genre: 'mystery',
|
|
|
|
rating: 8.5,
|
|
|
|
release_year: 2002,
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'Attack on Titan',
|
|
|
|
synopsis: 'Humans fight against giant Titans.',
|
|
|
|
genre: 'fantasy',
|
|
|
|
rating: 9,
|
|
|
|
release_year: 2013,
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'One Piece',
|
|
|
|
synopsis: 'Pirates search for the ultimate treasure.',
|
|
|
|
genre: 'comedy',
|
|
|
|
rating: 8.9,
|
|
|
|
release_year: 1999,
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'My Hero Academia',
|
|
|
|
synopsis: 'Students train to become heroes.',
|
|
|
|
genre: 'fantasy',
|
|
|
|
rating: 8.4,
|
|
|
|
release_year: 2016,
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'Demon Slayer',
|
|
|
|
synopsis: 'A boy fights demons to save his sister.',
|
|
|
|
genre: 'sci-fi',
|
|
|
|
rating: 8.7,
|
|
|
|
release_year: 2019,
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const CommentsData = [
|
|
{
|
|
content: 'Amazing episode!',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
content: "Can't wait for the next one!",
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
content: 'This show is a masterpiece.',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
content: 'Loved the character development.',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
content: 'The animation is top-notch.',
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const EpisodesData = [
|
|
{
|
|
title: 'Enter: Naruto Uzumaki!',
|
|
|
|
release_date: new Date('2002-10-03T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'To You, in 2000 Years: The Fall of Shiganshina, Part 1',
|
|
|
|
release_date: new Date('2013-04-07T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: "I'm Luffy! The Man Who's Gonna Be King of the Pirates!",
|
|
|
|
release_date: new Date('1999-10-20T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'Izuku Midoriya: Origin',
|
|
|
|
release_date: new Date('2016-04-03T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
title: 'Cruelty',
|
|
|
|
release_date: new Date('2019-04-06T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_many" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const SubscriptionsData = [
|
|
{
|
|
plan: 'free',
|
|
|
|
start_date: new Date('2023-01-01T00:00:00Z'),
|
|
|
|
end_date: new Date('2024-01-01T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
plan: 'premium',
|
|
|
|
start_date: new Date('2023-01-01T00:00:00Z'),
|
|
|
|
end_date: new Date('2023-12-31T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
plan: 'free',
|
|
|
|
start_date: new Date('2023-06-01T00:00:00Z'),
|
|
|
|
end_date: new Date('2024-06-01T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
plan: 'premium',
|
|
|
|
start_date: new Date('2023-03-01T00:00:00Z'),
|
|
|
|
end_date: new Date('2024-03-01T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
|
|
{
|
|
plan: 'free',
|
|
|
|
start_date: new Date('2023-09-01T00:00:00Z'),
|
|
|
|
end_date: new Date('2024-09-01T00:00:00Z'),
|
|
|
|
// type code here for "relation_one" field
|
|
|
|
// type code here for "relation_one" field
|
|
},
|
|
];
|
|
|
|
const AniplayData = [
|
|
{
|
|
name: 'Anime World',
|
|
},
|
|
|
|
{
|
|
name: 'Otaku Hub',
|
|
},
|
|
|
|
{
|
|
name: 'Anime Universe',
|
|
},
|
|
|
|
{
|
|
name: 'Manga Stream',
|
|
},
|
|
|
|
{
|
|
name: 'Anime Central',
|
|
},
|
|
];
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
async function associateUserWithAniplay() {
|
|
const relatedAniplay0 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const User0 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (User0?.setAniplay) {
|
|
await User0.setAniplay(relatedAniplay0);
|
|
}
|
|
|
|
const relatedAniplay1 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const User1 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (User1?.setAniplay) {
|
|
await User1.setAniplay(relatedAniplay1);
|
|
}
|
|
|
|
const relatedAniplay2 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const User2 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (User2?.setAniplay) {
|
|
await User2.setAniplay(relatedAniplay2);
|
|
}
|
|
|
|
const relatedAniplay3 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const User3 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (User3?.setAniplay) {
|
|
await User3.setAniplay(relatedAniplay3);
|
|
}
|
|
|
|
const relatedAniplay4 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const User4 = await Users.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (User4?.setAniplay) {
|
|
await User4.setAniplay(relatedAniplay4);
|
|
}
|
|
}
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
async function associateAnimeWithAniplay() {
|
|
const relatedAniplay0 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Anime0 = await Anime.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Anime0?.setAniplay) {
|
|
await Anime0.setAniplay(relatedAniplay0);
|
|
}
|
|
|
|
const relatedAniplay1 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Anime1 = await Anime.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Anime1?.setAniplay) {
|
|
await Anime1.setAniplay(relatedAniplay1);
|
|
}
|
|
|
|
const relatedAniplay2 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Anime2 = await Anime.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Anime2?.setAniplay) {
|
|
await Anime2.setAniplay(relatedAniplay2);
|
|
}
|
|
|
|
const relatedAniplay3 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Anime3 = await Anime.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Anime3?.setAniplay) {
|
|
await Anime3.setAniplay(relatedAniplay3);
|
|
}
|
|
|
|
const relatedAniplay4 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Anime4 = await Anime.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Anime4?.setAniplay) {
|
|
await Anime4.setAniplay(relatedAniplay4);
|
|
}
|
|
}
|
|
|
|
async function associateCommentWithUser() {
|
|
const relatedUser0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Comment0 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Comment0?.setUser) {
|
|
await Comment0.setUser(relatedUser0);
|
|
}
|
|
|
|
const relatedUser1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Comment1 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Comment1?.setUser) {
|
|
await Comment1.setUser(relatedUser1);
|
|
}
|
|
|
|
const relatedUser2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Comment2 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Comment2?.setUser) {
|
|
await Comment2.setUser(relatedUser2);
|
|
}
|
|
|
|
const relatedUser3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Comment3 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Comment3?.setUser) {
|
|
await Comment3.setUser(relatedUser3);
|
|
}
|
|
|
|
const relatedUser4 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Comment4 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Comment4?.setUser) {
|
|
await Comment4.setUser(relatedUser4);
|
|
}
|
|
}
|
|
|
|
async function associateCommentWithAnime() {
|
|
const relatedAnime0 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Comment0 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Comment0?.setAnime) {
|
|
await Comment0.setAnime(relatedAnime0);
|
|
}
|
|
|
|
const relatedAnime1 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Comment1 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Comment1?.setAnime) {
|
|
await Comment1.setAnime(relatedAnime1);
|
|
}
|
|
|
|
const relatedAnime2 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Comment2 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Comment2?.setAnime) {
|
|
await Comment2.setAnime(relatedAnime2);
|
|
}
|
|
|
|
const relatedAnime3 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Comment3 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Comment3?.setAnime) {
|
|
await Comment3.setAnime(relatedAnime3);
|
|
}
|
|
|
|
const relatedAnime4 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Comment4 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Comment4?.setAnime) {
|
|
await Comment4.setAnime(relatedAnime4);
|
|
}
|
|
}
|
|
|
|
async function associateCommentWithAniplay() {
|
|
const relatedAniplay0 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Comment0 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Comment0?.setAniplay) {
|
|
await Comment0.setAniplay(relatedAniplay0);
|
|
}
|
|
|
|
const relatedAniplay1 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Comment1 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Comment1?.setAniplay) {
|
|
await Comment1.setAniplay(relatedAniplay1);
|
|
}
|
|
|
|
const relatedAniplay2 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Comment2 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Comment2?.setAniplay) {
|
|
await Comment2.setAniplay(relatedAniplay2);
|
|
}
|
|
|
|
const relatedAniplay3 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Comment3 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Comment3?.setAniplay) {
|
|
await Comment3.setAniplay(relatedAniplay3);
|
|
}
|
|
|
|
const relatedAniplay4 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Comment4 = await Comments.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Comment4?.setAniplay) {
|
|
await Comment4.setAniplay(relatedAniplay4);
|
|
}
|
|
}
|
|
|
|
async function associateEpisodeWithAnime() {
|
|
const relatedAnime0 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Episode0 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Episode0?.setAnime) {
|
|
await Episode0.setAnime(relatedAnime0);
|
|
}
|
|
|
|
const relatedAnime1 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Episode1 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Episode1?.setAnime) {
|
|
await Episode1.setAnime(relatedAnime1);
|
|
}
|
|
|
|
const relatedAnime2 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Episode2 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Episode2?.setAnime) {
|
|
await Episode2.setAnime(relatedAnime2);
|
|
}
|
|
|
|
const relatedAnime3 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Episode3 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Episode3?.setAnime) {
|
|
await Episode3.setAnime(relatedAnime3);
|
|
}
|
|
|
|
const relatedAnime4 = await Anime.findOne({
|
|
offset: Math.floor(Math.random() * (await Anime.count())),
|
|
});
|
|
const Episode4 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Episode4?.setAnime) {
|
|
await Episode4.setAnime(relatedAnime4);
|
|
}
|
|
}
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
async function associateEpisodeWithAniplay() {
|
|
const relatedAniplay0 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Episode0 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Episode0?.setAniplay) {
|
|
await Episode0.setAniplay(relatedAniplay0);
|
|
}
|
|
|
|
const relatedAniplay1 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Episode1 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Episode1?.setAniplay) {
|
|
await Episode1.setAniplay(relatedAniplay1);
|
|
}
|
|
|
|
const relatedAniplay2 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Episode2 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Episode2?.setAniplay) {
|
|
await Episode2.setAniplay(relatedAniplay2);
|
|
}
|
|
|
|
const relatedAniplay3 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Episode3 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Episode3?.setAniplay) {
|
|
await Episode3.setAniplay(relatedAniplay3);
|
|
}
|
|
|
|
const relatedAniplay4 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Episode4 = await Episodes.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Episode4?.setAniplay) {
|
|
await Episode4.setAniplay(relatedAniplay4);
|
|
}
|
|
}
|
|
|
|
async function associateSubscriptionWithUser() {
|
|
const relatedUser0 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Subscription0 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Subscription0?.setUser) {
|
|
await Subscription0.setUser(relatedUser0);
|
|
}
|
|
|
|
const relatedUser1 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Subscription1 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Subscription1?.setUser) {
|
|
await Subscription1.setUser(relatedUser1);
|
|
}
|
|
|
|
const relatedUser2 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Subscription2 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Subscription2?.setUser) {
|
|
await Subscription2.setUser(relatedUser2);
|
|
}
|
|
|
|
const relatedUser3 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Subscription3 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Subscription3?.setUser) {
|
|
await Subscription3.setUser(relatedUser3);
|
|
}
|
|
|
|
const relatedUser4 = await Users.findOne({
|
|
offset: Math.floor(Math.random() * (await Users.count())),
|
|
});
|
|
const Subscription4 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Subscription4?.setUser) {
|
|
await Subscription4.setUser(relatedUser4);
|
|
}
|
|
}
|
|
|
|
async function associateSubscriptionWithAniplay() {
|
|
const relatedAniplay0 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Subscription0 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 0,
|
|
});
|
|
if (Subscription0?.setAniplay) {
|
|
await Subscription0.setAniplay(relatedAniplay0);
|
|
}
|
|
|
|
const relatedAniplay1 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Subscription1 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 1,
|
|
});
|
|
if (Subscription1?.setAniplay) {
|
|
await Subscription1.setAniplay(relatedAniplay1);
|
|
}
|
|
|
|
const relatedAniplay2 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Subscription2 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 2,
|
|
});
|
|
if (Subscription2?.setAniplay) {
|
|
await Subscription2.setAniplay(relatedAniplay2);
|
|
}
|
|
|
|
const relatedAniplay3 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Subscription3 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 3,
|
|
});
|
|
if (Subscription3?.setAniplay) {
|
|
await Subscription3.setAniplay(relatedAniplay3);
|
|
}
|
|
|
|
const relatedAniplay4 = await Aniplay.findOne({
|
|
offset: Math.floor(Math.random() * (await Aniplay.count())),
|
|
});
|
|
const Subscription4 = await Subscriptions.findOne({
|
|
order: [['id', 'ASC']],
|
|
offset: 4,
|
|
});
|
|
if (Subscription4?.setAniplay) {
|
|
await Subscription4.setAniplay(relatedAniplay4);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
up: async (queryInterface, Sequelize) => {
|
|
await Anime.bulkCreate(AnimeData);
|
|
|
|
await Comments.bulkCreate(CommentsData);
|
|
|
|
await Episodes.bulkCreate(EpisodesData);
|
|
|
|
await Subscriptions.bulkCreate(SubscriptionsData);
|
|
|
|
await Aniplay.bulkCreate(AniplayData);
|
|
|
|
await Promise.all([
|
|
// Similar logic for "relation_many"
|
|
|
|
await associateUserWithAniplay(),
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
await associateAnimeWithAniplay(),
|
|
|
|
await associateCommentWithUser(),
|
|
|
|
await associateCommentWithAnime(),
|
|
|
|
await associateCommentWithAniplay(),
|
|
|
|
await associateEpisodeWithAnime(),
|
|
|
|
// Similar logic for "relation_many"
|
|
|
|
await associateEpisodeWithAniplay(),
|
|
|
|
await associateSubscriptionWithUser(),
|
|
|
|
await associateSubscriptionWithAniplay(),
|
|
]);
|
|
},
|
|
|
|
down: async (queryInterface, Sequelize) => {
|
|
await queryInterface.bulkDelete('anime', null, {});
|
|
|
|
await queryInterface.bulkDelete('comments', null, {});
|
|
|
|
await queryInterface.bulkDelete('episodes', null, {});
|
|
|
|
await queryInterface.bulkDelete('subscriptions', null, {});
|
|
|
|
await queryInterface.bulkDelete('aniplay', null, {});
|
|
},
|
|
};
|