Merge branch 'development' into 20233110_docker_compose_refining

Author: TejasNair9977

.env.example

@@ -0,0 +1,10 @@
+PORT=4000
+TOKEN_SECRET=mysecret
+ENVIRONMENT=local
+DB_URL=mongodb://mongo1:30001,mongo2:30002,mongo3:30003/?replicaSet=my-replica-set
+EMAIL_HOST=
+EMAIL_PORT=
+EMAIL_USER=
+EMAIL_PASS=
+
+# get email stuff from mailtrap

app.js

@@ -31,6 +31,7 @@ import performarouter from "#routes/performance";
 import notificationRouter from "#routes/notification";
 import topicRouter from "#routes/topic";
 import courseRouter from "#routes/course";
+import activityBlueprintRouter from "#routes/activityBlueprint";
 
 const app = express();
 const currDirName = dirname(fileURLToPath(import.meta.url));
@@ -76,5 +77,6 @@ app.use("/performance", performarouter);
 app.use("/notification", notificationRouter);
 app.use("/topic", topicRouter);
 app.use("/course", courseRouter);
+app.use("/activityBlueprint", activityBlueprintRouter);
 
 export default app;

controller/activity.js

@@ -10,7 +10,6 @@ async function addActivity(req, res) {
   const {
     activityBlueprint,
     startTime,
-    duration,
     course,
     faculty,
     type,
@@ -22,7 +21,6 @@ async function addActivity(req, res) {
     const newActivity = await createActivity(
       activityBlueprint,
       startTime,
-      duration,
       course,
       faculty,
       type,

controller/activityBlueprint.js

@@ -0,0 +1,88 @@
+import {
+  createActivityBP,
+  updateActivityBlueprintById,
+  deleteActivityBlueprintById,
+  activityBlueprintList,
+} from "#services/activityBlueprint";
+import { logger } from "#util";
+
+async function addActivityBP(req, res) {
+  const {
+    number,
+    academicYear,
+    day,
+    startTime,
+    duration,
+    infra,
+    course,
+    faculty,
+    type,
+    group,
+  } = req.body;
+  try {
+    const newActivityBP = await createActivityBP(
+      number,
+      academicYear,
+      day,
+      startTime,
+      duration,
+      infra,
+      course,
+      faculty,
+      type,
+      group,
+    );
+    return res.json({
+      res: `added activity ${newActivityBP.id}`,
+      id: newActivityBP.id,
+    });
+  } catch (error) {
+    logger.error("Error while inserting", error);
+    res.status(500);
+    return res.json({ err: "Error while inserting in DB" });
+  }
+}
+
+async function updateActivityBP(req, res) {
+  const { id } = req.params;
+  const { ...data } = req.body;
+  try {
+    await updateActivityBlueprintById(id, data);
+    return res.json({ res: `updated activity with id ${id}` });
+  } catch (error) {
+    logger.error("Error while updating", error);
+    res.status(500);
+    return res.json({ err: "Error while updating in DB" });
+  }
+}
+
+async function getActivityBP(req, res) {
+  try {
+    const filter = req.body;
+    const { limit, page } = req.query;
+    const activitylist = await activityBlueprintList(filter, limit, page);
+    return res.json({ res: activitylist });
+  } catch (error) {
+    logger.error("Error while fetching", error);
+    res.status(500);
+    return res.json({ err: "Error while fetching the data" });
+  }
+}
+
+async function deleteActivityBP(res, req) {
+  const { id } = req.params;
+  try {
+    await deleteActivityBlueprintById(id);
+    return res.json({ res: `Deleted activity with ID ${id}` });
+  } catch (error) {
+    logger.error("Error while deleting", error);
+    return res.status(500).json({ error: "Error while deleting from DB" });
+  }
+}
+
+export default {
+  addActivityBP,
+  deleteActivityBP,
+  getActivityBP,
+  updateActivityBP,
+};

jest.config.js

@@ -1,8 +1,10 @@
 const config = {
-  transform: {
-  },
+  transform: {},
   testTimeout: 15000,
-  setupFiles: [
+  globalSetup: "./test/config/globalSetup.js",
+  globalTeardown: "./test/config/globalTeardown.js",
+  setupFilesAfterEnv: [
+    // "<rootDir>/test/setupFile.ts",
     "./test/config/setup.js",
     "./test/config/teardown.js",
   ],

misc/initDB.js

@@ -9,6 +9,18 @@ import Tutorial from "#models/tutorial";
 import Practical from "#models/practical";
 import Semester from "#models/semester";
 import Course from "#models/course";
+import Faculty from "#models/faculty";
+import Student from "#models/student";
+import Attendance from "#models/attendance";
+import Notification from "#models/notification";
+import User from "#models/user";
+import Group from "#models/group";
+import ActivityBlueprint from "#models/activityBlueprint";
+import Activity from "#models/activity";
+import Exam from "#models/exam";
+import Paper from "#models/paper";
+import Coursework from "#models/coursework";
+import Timetable from "#models/timetable";
 import generateOrganizations from "#mockDB/orgMock";
 import ACCREDS from "#mockDB/accredMock";
 import TOPICS from "#mockDB/topicMock";
@@ -19,6 +31,18 @@ import generatePracticals from "#mockDB/pracMock";
 import generateTutorials from "#mockDB/tutMock";
 import generateSemesters from "#mockDB/semMock";
 import generateCourses from "#mockDB/courseMock";
+import generateFaculty from "#mockDB/facultyMock";
+import generateStudents from "#mockDB/studentMock";
+import generateAttendance from "#mockDB/attendanceMock";
+import generateNotifications from "#mockDB/notificationMock";
+import generateUsers from "#mockDB/userMock"; // eslint-disable-line no-unused-vars
+import generateGroups from "#mockDB/groupMock";
+import generateActivityBP from "#mockDB/activityBPMock";
+import generateActivity from "#mockDB/activityMock";
+import generateExams from "#mockDB/examMock";
+import generatePaper from "#mockDB/paperMock";
+import generateCoursework from "#mockDB/courseworkMock";
+import generateTimetables from "#mockDB/timetableMock";
 /* eslint-disable no-underscore-dangle */
 const createdAccreds = await Accreditation.createMultiple(ACCREDS);
 
@@ -60,7 +84,7 @@ const createdDepts = await Department.createMultiple(DEPTS);
 
 const createdTopics = await Topics.createMultiple(TOPICS);
 
-const MODULES = await generateModules(
+const MODULES = generateModules(
   createdTopics.map((createdTopic) => createdTopic._id),
 );
 
@@ -86,6 +110,119 @@ const COURSES = generateCourses(
   createdDepts.map((createdDept) => createdDept._id),
 );
 
-const createdCourses = await Course.createMultiple(COURSES); // eslint-disable-line no-unused-vars
+const createdCourses = await Course.createMultiple(COURSES);
+
+const FACULTY = generateFaculty(
+  createdDepts.map((createdDept) => createdDept._id),
+  createdCourses.map((createdCourse) => createdCourse._id),
+);
+
+const createdFaculty = await Faculty.createMultiple(FACULTY);
+
+const STUDENTS = generateStudents(
+  createdDepts.map((createdDept) => createdDept._id),
+  createdCourses.map((createdCourse) => createdCourse._id),
+);
+
+const createdStudents = await Student.createMultiple(STUDENTS);
+
+const studentCourseList = createdStudents.map((student) => {
+  const studentId = student._id.toString();
+  const coursesOpted = student.coursesOpted.map((courseId) =>
+    courseId.toString(),
+  );
+  return { studentId, coursesOpted };
+});
+
+const ATTENDANCE = generateAttendance(studentCourseList);
+
+const createdAttendance = await Attendance.createMultiple(ATTENDANCE); // eslint-disable-line no-unused-vars
+
+// const USERS = generateUsers(                                         // TODO this takes forever bruhh
+//   createdStudents.map((createdStudent) => createdStudent.ERPID),
+//   createdFaculty.map((createdFaculty) => createdFaculty.ERPID),
+// )
+
+// const createdUsers = await User.createMultiple(USERS)
+
+const createdUsers = await User.read(); // use this after you initialized Users at least once, or wait for years every time
+
+const NOTIFS = generateNotifications(
+  createdUsers.data // remove data from each of these if you are initializing users for the first time
+    .filter((user) => user.userType === "STUDENT")
+    .map((student) => student._id),
+  createdUsers.data
+    .filter((user) => user.userType === "FACULTY")
+    .map((faculty) => faculty._id),
+  createdUsers.data
+    .filter((user) => user.userType === "ADMIN")
+    .map((admin) => admin._id),
+);
+
+const createdNotifications = await Notification.createMultiple(NOTIFS); // eslint-disable-line no-unused-vars
+
+const GROUPS = generateGroups(
+  createdUsers.data
+    .filter((user) => user.userType === "STUDENT")
+    .map((student) => student._id),
+);
+
+const createdGroups = await Group.createMultiple(GROUPS);
+
+const ACTIVITYBP = generateActivityBP(
+  createdInfras.map((createdInfra) => createdInfra._id),
+  createdCourses.map((createdCourse) => createdCourse._id),
+  createdFaculty.map((faculty) => faculty._id),
+  createdGroups.map((createdGroup) => createdGroup._id),
+);
+
+const createdActivityBP = await ActivityBlueprint.createMultiple(ACTIVITYBP);
+
+const ACTIVITY = generateActivity(
+  createdActivityBP.map((activityBP) => activityBP._id),
+  createdCourses.map((createdCourse) => createdCourse._id),
+  createdFaculty.map((faculty) => faculty._id),
+  createdGroups.map((createdGroup) => createdGroup._id),
+  createdTuts.map((createdTut) => createdTut._id),
+  createdPracs.map((createdPrac) => createdPrac._id),
+  createdTopics.map((createdTopic) => createdTopic._id),
+  createdStudents.map((createdStudent) => createdStudent._id),
+);
+
+const createdActivity = await Activity.createMultiple(ACTIVITY);
+
+const EXAMS = generateExams(
+  createdInfras.map((createdInfra) => createdInfra._id),
+  createdCourses.map((createdCourse) => createdCourse._id),
+  createdFaculty.map((faculty) => faculty._id),
+);
+
+const createdExams = await Exam.createMultiple(EXAMS);
+
+const PAPERS = generatePaper(
+  createdStudents.map((createdStudent) => createdStudent._id),
+  createdExams.map((createdExam) => createdExam._id),
+  createdFaculty.map((faculty) => faculty._id),
+);
+
+const createdPapers = await Paper.createMultiple(PAPERS); // eslint-disable-line no-unused-vars
+
+const COURSEWORK = generateCoursework(
+  createdStudents.map((createdStudent) => createdStudent._id),
+  createdCourses.map((createdCourse) => createdCourse._id),
+  createdTuts.map((createdTut) => createdTut._id),
+  createdPracs.map((createdPrac) => createdPrac._id),
+  createdActivity.map((activity) => activity._id),
+);
+
+const createdCoursework = await Coursework.createMultiple(COURSEWORK); // eslint-disable-line no-unused-vars
+
+const TIMETABLE = generateTimetables(
+  createdActivityBP.map((activityBP) => activityBP._id),
+  createdGroups.map((createdGroup) => createdGroup._id),
+  createdFaculty.map((faculty) => faculty._id),
+);
+
+const createdTimetables = await Timetable.createMultiple(TIMETABLE); // eslint-disable-line no-unused-vars
 
 process.exit(0);

misc/mockDB/activityBPMock.js

@@ -0,0 +1,48 @@
+import { faker } from "@faker-js/faker"; // eslint-disable-line import/no-extraneous-dependencies
+// TODO, not accurate to IRL!!
+const generateRandomActivityBP = (
+  randomInfra,
+  randomCourse,
+  randomFaculty,
+  randomGroup,
+) => ({
+  number: faker.number.int(),
+  academicYear: "2023",
+  day: faker.helpers.arrayElement([
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+  ]),
+  startTime: faker.helpers.arrayElement([
+    "09:00",
+    "11:00",
+    "13:00",
+    "15:00",
+    "17:00",
+  ]),
+  duration: faker.number.int({ min: 1, max: 2 }),
+  infra: randomInfra,
+  course: randomCourse,
+  faculty: randomFaculty,
+  type: faker.helpers.arrayElement(["lecture", "practical", "tutorial"]),
+  group: randomGroup,
+});
+
+const generateActivityBP = (infraList, courseList, facultyList, groupList) => {
+  const activityBP = [];
+  for (let i = 0; i < 1000; i += 1) {
+    activityBP.push(
+      generateRandomActivityBP(
+        faker.helpers.arrayElement(infraList),
+        faker.helpers.arrayElement(courseList),
+        faker.helpers.arrayElement(facultyList),
+        faker.helpers.arrayElement(groupList),
+      ),
+    );
+  }
+  return activityBP;
+};
+
+export default generateActivityBP;