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

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

const Exercises = db.exercises;

const WorkoutLogs = db.workout_logs;

const WorkoutPlans = db.workout_plans;

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

    day_index: 1,

    name: 'Bench Press',

    muscle_group: 'Chest',

    start_weight: 135,

    rep_range_min: 8,

    rep_range_max: 10,

    rir_target: 2,
  },

  {
    // type code here for "relation_one" field

    day_index: 1,

    name: 'Running',

    muscle_group: 'Legs',

    start_weight: 0,

    rep_range_min: 30,

    rep_range_max: 45,

    rir_target: 0,
  },

  {
    // type code here for "relation_one" field

    day_index: 1,

    name: 'Squats',

    muscle_group: 'Legs',

    start_weight: 100,

    rep_range_min: 10,

    rep_range_max: 12,

    rir_target: 1,
  },

  {
    // type code here for "relation_one" field

    day_index: 1,

    name: 'Sun Salutation',

    muscle_group: 'Full Body',

    start_weight: 0,

    rep_range_min: 5,

    rep_range_max: 10,

    rir_target: 0,
  },
];

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

    date: new Date('2023-10-01T08:00:00Z'),

    // type code here for "relation_one" field

    week_number: 1,

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

  {
    // type code here for "relation_one" field

    date: new Date('2023-10-02T08:00:00Z'),

    // type code here for "relation_one" field

    week_number: 1,

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

  {
    // type code here for "relation_one" field

    date: new Date('2023-10-03T08:00:00Z'),

    // type code here for "relation_one" field

    week_number: 1,

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

  {
    // type code here for "relation_one" field

    date: new Date('2023-10-04T08:00:00Z'),

    // type code here for "relation_one" field

    week_number: 1,

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

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

    name: 'Strength Training',

    days: 4,
  },

  {
    // type code here for "relation_one" field

    name: 'Cardio Blast',

    days: 3,
  },

  {
    // type code here for "relation_one" field

    name: 'Full Body Workout',

    days: 5,
  },

  {
    // type code here for "relation_one" field

    name: 'Yoga Routine',

    days: 2,
  },
];

// Similar logic for "relation_many"

async function associateExerciseWithWorkout_plan() {
  const relatedWorkout_plan0 = await WorkoutPlans.findOne({
    offset: Math.floor(Math.random() * (await WorkoutPlans.count())),
  });
  const Exercise0 = await Exercises.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Exercise0?.setWorkout_plan) {
    await Exercise0.setWorkout_plan(relatedWorkout_plan0);
  }

  const relatedWorkout_plan1 = await WorkoutPlans.findOne({
    offset: Math.floor(Math.random() * (await WorkoutPlans.count())),
  });
  const Exercise1 = await Exercises.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Exercise1?.setWorkout_plan) {
    await Exercise1.setWorkout_plan(relatedWorkout_plan1);
  }

  const relatedWorkout_plan2 = await WorkoutPlans.findOne({
    offset: Math.floor(Math.random() * (await WorkoutPlans.count())),
  });
  const Exercise2 = await Exercises.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Exercise2?.setWorkout_plan) {
    await Exercise2.setWorkout_plan(relatedWorkout_plan2);
  }

  const relatedWorkout_plan3 = await WorkoutPlans.findOne({
    offset: Math.floor(Math.random() * (await WorkoutPlans.count())),
  });
  const Exercise3 = await Exercises.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Exercise3?.setWorkout_plan) {
    await Exercise3.setWorkout_plan(relatedWorkout_plan3);
  }
}

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

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

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

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

async function associateWorkoutLogWithWorkout_plan() {
  const relatedWorkout_plan0 = await WorkoutPlans.findOne({
    offset: Math.floor(Math.random() * (await WorkoutPlans.count())),
  });
  const WorkoutLog0 = await WorkoutLogs.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (WorkoutLog0?.setWorkout_plan) {
    await WorkoutLog0.setWorkout_plan(relatedWorkout_plan0);
  }

  const relatedWorkout_plan1 = await WorkoutPlans.findOne({
    offset: Math.floor(Math.random() * (await WorkoutPlans.count())),
  });
  const WorkoutLog1 = await WorkoutLogs.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (WorkoutLog1?.setWorkout_plan) {
    await WorkoutLog1.setWorkout_plan(relatedWorkout_plan1);
  }

  const relatedWorkout_plan2 = await WorkoutPlans.findOne({
    offset: Math.floor(Math.random() * (await WorkoutPlans.count())),
  });
  const WorkoutLog2 = await WorkoutLogs.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (WorkoutLog2?.setWorkout_plan) {
    await WorkoutLog2.setWorkout_plan(relatedWorkout_plan2);
  }

  const relatedWorkout_plan3 = await WorkoutPlans.findOne({
    offset: Math.floor(Math.random() * (await WorkoutPlans.count())),
  });
  const WorkoutLog3 = await WorkoutLogs.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (WorkoutLog3?.setWorkout_plan) {
    await WorkoutLog3.setWorkout_plan(relatedWorkout_plan3);
  }
}

// Similar logic for "relation_many"

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

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

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

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

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

    await WorkoutLogs.bulkCreate(WorkoutLogsData);

    await WorkoutPlans.bulkCreate(WorkoutPlansData);

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

      await associateExerciseWithWorkout_plan(),

      await associateWorkoutLogWithUser(),

      await associateWorkoutLogWithWorkout_plan(),

      // Similar logic for "relation_many"

      await associateWorkoutPlanWithUser(),
    ]);
  },

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

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

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