backend/.prettierrc.yaml

+trailingComma: "all"
+tabWidth: 2
+semi: true
+singleQuote: true

backend/package-lock.json

@@ -606,6 +606,7 @@
       "dependencies": {
         "anymatch": "~3.1.1",
         "braces": "~3.0.2",
+        "fsevents": "~2.3.1",
         "glob-parent": "~5.1.0",
         "is-binary-path": "~2.1.0",
         "is-glob": "~4.0.1",

backend/package.json

@@ -6,7 +6,8 @@
   "scripts": {
     "linux-test": "NODE_ENV=test && ./node_modules/mocha/bin/mocha src/test",
     "linux-start": "NODE_ENV=development && node src/index.js",
-    "windows-start": "set NODE_ENV=development && node src/index.js"
+    "windows-start": "set NODE_ENV=development && node src/index.js",
+    "prettify": "npx prettier --write \"**/*.js\""
   },
   "author": "Group B",
   "license": "MIT",
@@ -15,7 +16,6 @@
     "chai": "^4.3.0",
     "chai-as-promised": "^7.1.1",
     "chai-http": "^4.3.0",
-    "chart.js": "^3.0.2",
     "cors": "^2.8.5",
     "dotenv": "^8.2.0",
     "express": "^4.17.1",

backend/src/controllers/auth.js

@@ -4,7 +4,6 @@ const saltRounds = require(__dirname + '/../config/hash.json')['saltRounds'];
 const https = require('https');
 const parseString = require('xml2js').parseString;
 
-
 const User = require('../models/index')['User'];
 const Lecturer = require('../models/index')['Lecturer'];
 const Student = require('../models/index')['Student'];
@@ -12,7 +11,7 @@ const Student = require('../models/index')['Student'];
 const { getJWTToken } = require('../util/jwt');
 const { getUser } = require('../util/db');
 
-const hashPassword = async function(req){
+const hashPassword = async function (req) {
   return new Promise((resolve) => {
     bcrypt.genSalt(saltRounds, (err, salt) => {
       bcrypt.hash(req.body.password, salt, (err2, hash) => {
@@ -26,64 +25,65 @@ const hashPassword = async function(req){
   });
 };
 
-exports.register = async function(req, res) {
+exports.register = async function (req, res) {
   let roles = ['student', 'lecturer'];
   let newPass = await hashPassword(req);
-  if (roles.includes(req.body.role)){
+  if (roles.includes(req.body.role)) {
     const [user, created] = await User.findOrCreate({
-      where: {email: req.body.email},
-      defaults: {hashed_password: newPass.hashed, salt: newPass.salt},
+      where: { email: req.body.email },
+      defaults: { hashed_password: newPass.hashed, salt: newPass.salt },
     });
 
-    if (!created){
+    if (!created) {
       console.log(user.id);
-      if (req.body.role.toString() === 'student'){
-        const [student, studentCreated] = await Student.findOrCreate({where: {userId: user.id}});
+      if (req.body.role.toString() === 'student') {
+        const [student, studentCreated] = await Student.findOrCreate({
+          where: { userId: user.id },
+        });
         if (!studentCreated) {
           console.log('Student with id:' + student.id + ' exist');
           res.status(400);
-          res.json({status: 400, message: 'Student exist'});
+          res.json({ status: 400, message: 'Student exist' });
         } else {
           console.log('Student registered.');
-          res.json({status: 200, message: 'Register student successful.'});
+          res.json({ status: 200, message: 'Register student successful.' });
         }
       } else {
-        const [lecturer, lecturerCreated] = await Lecturer.findOrCreate({where: {userId: user.id}});
+        const [lecturer, lecturerCreated] = await Lecturer.findOrCreate({
+          where: { userId: user.id },
+        });
         if (!lecturerCreated) {
           console.log('Lecturer with id:' + lecturer.id + ' exist');
           res.status(400);
-          res.json({status: 400, message: 'Lecturer exist'});
+          res.json({ status: 400, message: 'Lecturer exist' });
         } else {
           console.log('Lecturer registered.');
-          res.json({status: 200, message: 'Register lecturer successful.'});
+          res.json({ status: 200, message: 'Register lecturer successful.' });
         }
       }
-
     } else {
-
       if (req.body.role.toString() === 'student') {
-        const student = await Student.create({userId: user.id});
+        const student = await Student.create({ userId: user.id });
         if (student) {
           console.log('Student registered.');
-          res.json({status: 200, message: 'Register student successful.'});
+          res.json({ status: 200, message: 'Register student successful.' });
         } else {
           console.log('Student creation failed.');
           res.status(500);
-          res.json({status: 500, message: 'Register student failed.'});
+          res.json({ status: 500, message: 'Register student failed.' });
         }
       } else {
-        const lecturer = await Lecturer.create({userId: user.id});
+        const lecturer = await Lecturer.create({ userId: user.id });
         if (lecturer) {
           console.log('Lecturer registered.');
-          res.json({status: 200, message: 'Register lecturer successful.'});
+          res.json({ status: 200, message: 'Register lecturer successful.' });
         } else {
           console.log('Lecturer creation failed.');
           res.status(500);
-          res.json({status: 500, message: 'Register lecturer failed.'});
+          res.json({ status: 500, message: 'Register lecturer failed.' });
         }
       }
     }
-
   } else {
     res.status(400);
     res.json({
@@ -93,19 +93,12 @@ exports.register = async function(req, res) {
   }
 };
 
-exports.verifyUser = async(req, res) => {
-  const {
-    email,
-    password,
-  } = req.body;
+exports.verifyUser = async (req, res) => {
+  const { email, password } = req.body;
 
   try {
     const user = await getUser(email, password);
-    const {
-      id,
-      email: userEmail,
-      role,
-    } = user;
+    const { id, email: userEmail, role } = user;
 
     const tokenElement = {
       id,
@@ -134,44 +127,51 @@ exports.verifyUser = async(req, res) => {
   }
 };
 
-exports.casSSO = async(req, res) => {
+exports.casSSO = async (req, res) => {
   if (req.query.ticket) {
-    https.get('https://login.itb.ac.id/cas/serviceValidate?ticket=' + req.query.ticket + '&service=' + req.query.service, (resp) => {
-      let data = '';
-
-      resp.on('data', (chunk) => {
-        parseString(chunk, function (err, result) {
-          data = JSON.parse(JSON.stringify(result).replace(/cas:/g, ''));
-        });
+    https
+      .get(
+        'https://login.itb.ac.id/cas/serviceValidate?ticket=' +
+          req.query.ticket +
+          '&service=' +
+          req.query.service,
+        (resp) => {
+          let data = '';
+
+          resp.on('data', (chunk) => {
+            parseString(chunk, function (err, result) {
+              data = JSON.parse(JSON.stringify(result).replace(/cas:/g, ''));
+            });
+          });
+
+          resp.on('end', () => {
+            let processedData = {};
+
+            if (data.serviceResponse.authenticationSuccess) {
+              let successData = data.serviceResponse.authenticationSuccess[0];
+
+              processedData = {
+                username: successData.user[0],
+                email: successData.attributes[0].mail[0],
+                nim: successData.attributes[0].itbNIM[0],
+                prodi: successData.attributes[0].ou[0],
+                fullName: successData.attributes[0].cn[0],
+                status: successData.attributes[0].itbStatus[0],
+              };
+            } else {
+              processedData = {
+                username: null,
+              };
+            }
+
+            res.json(processedData);
+          });
+        },
+      )
+      .on('error', (err) => {
+        console.log('Error: ' + err.message);
       });
-
-      resp.on('end', () => {
-        let processedData = {};
-
-        if (data.serviceResponse.authenticationSuccess) {
-          let successData = data.serviceResponse.authenticationSuccess[0];
-          
-          processedData = {
-            username: successData.user[0],
-            email: successData.attributes[0].mail[0],
-            nim: successData.attributes[0].itbNIM[0],
-            prodi: successData.attributes[0].ou[0],
-            fullName: successData.attributes[0].cn[0],
-            status: successData.attributes[0].itbStatus[0]
-          };
-        } else {
-          processedData = {
-            username: null
-          };
-        } 
-
-        res.json(processedData);
-      });
-
-    }).on("error", (err) => {
-      console.log("Error: " + err.message);
-    });
   } else {
-    res.json("Invalid ticket");
+    res.json('Invalid ticket');
   }
-};
\ No newline at end of file
+};

backend/src/controllers/course-class-meeting.js

 'use strict';
 const {
-    handleRequestWithInternalServerError,
-    handleRequestWithResourceItemNotFound,
+  handleRequestWithInternalServerError,
+  handleRequestWithResourceItemNotFound,
 } = require('../util/common');
 
 const {
-    getCourseClassMeetingById,
-    getCourseClassMeetingByStudentId,
-    getCourseClassMeetingByLecturerId,
-    updateCourseClassMeeting
+  getCourseClassMeetingById,
+  getCourseClassMeetingByStudentId,
+  getCourseClassMeetingByLecturerId,
+  updateCourseClassMeeting,
 } = require('../util/db/course-class-meeting');
 
-const {
-    NotExistError,
-} = require('../util/error');
+const { NotExistError } = require('../util/error');
 
 exports.getCourseClassMeeting = async (req, res) => {
-    const {
-        opts,
-    } = req.body;
-
-    const {
-        courseClassMeetingId,
-        studentId,
-        lecturerId
-    } = req.query;
-
-    try {
-        let response;
-        if (courseClassMeetingId) {
-            response = await getCourseClassMeetingById(opts);
-        } else if (studentId) {
-            response = await getCourseClassMeetingByStudentId(opts);
-        } else if (lecturerId) {
-            response = await getCourseClassMeetingByLecturerId(opts);
-        }
-
-        res.json(response);
-    } catch (error) {
-        if (error instanceof NotExistError) {
-            handleRequestWithResourceItemNotFound(res, error);
-        } else {
-            handleRequestWithInternalServerError(res, error);
-        }
+  const { opts } = req.body;
+
+  const { courseClassMeetingId, studentId, lecturerId } = req.query;
+
+  try {
+    let response;
+    if (courseClassMeetingId) {
+      response = await getCourseClassMeetingById(opts);
+    } else if (studentId) {
+      response = await getCourseClassMeetingByStudentId(opts);
+    } else if (lecturerId) {
+      response = await getCourseClassMeetingByLecturerId(opts);
+    }
+
+    res.json(response);
+  } catch (error) {
+    if (error instanceof NotExistError) {
+      handleRequestWithResourceItemNotFound(res, error);
+    } else {
+      handleRequestWithInternalServerError(res, error);
     }
+  }
 };
 
 exports.updateCourseClassMeeting = async (req, res) => {
   try {
-    const {
-      courseClassMeeting,
-      changeset
-    } = req.body;
+    const { courseClassMeeting, changeset } = req.body;
 
-    const updatedCourseClassMeeting = await updateCourseClassMeeting(courseClassMeeting, changeset);
+    const updatedCourseClassMeeting = await updateCourseClassMeeting(
+      courseClassMeeting,
+      changeset,
+    );
     res.json(updatedCourseClassMeeting);
   } catch (error) {
     handleRequestWithInternalServerError(res, error);

backend/src/controllers/course.js

-const {
-    Course,
-    Major,
-    Faculty
-} = require('../models/index');
+const { Course, Major, Faculty } = require('../models/index');
 
 const {
-    handleRequestWithInvalidRequestBody,
-    handleRequestWithResourceItemNotFound
+  handleRequestWithInvalidRequestBody,
+  handleRequestWithResourceItemNotFound,
 } = require('../util/common');
 
-const {
-    NotExistError
-} = require('../util/error');
+const { NotExistError } = require('../util/error');
 
-exports.getAllCourseData = async(req, res) => {
-    let courses = await Course.findAll();
-    res.json(courses);
+exports.getAllCourseData = async (req, res) => {
+  let courses = await Course.findAll();
+  res.json(courses);
 };
 
-exports.getCourseData = async(req, res) => {
-    const foundCourse = await Course.findOne({
-        where: {
-            id: req.params.id,
-        },
-        include: [
-            {
-                model: Major,
-                include: Faculty,
-            },
-        ],
-    }).catch(err => {
-        handleRequestWithInvalidRequestBody(res, err);
-    });
+exports.getCourseData = async (req, res) => {
+  const foundCourse = await Course.findOne({
+    where: {
+      id: req.params.id,
+    },
+    include: [
+      {
+        model: Major,
+        include: Faculty,
+      },
+    ],
+  }).catch((err) => {
+    handleRequestWithInvalidRequestBody(res, err);
+  });
 
-    if (foundCourse){
-        res.json(foundCourse);
-    } else {
-        handleRequestWithResourceItemNotFound(res, new NotExistError());
-    }
+  if (foundCourse) {
+    res.json(foundCourse);
+  } else {
+    handleRequestWithResourceItemNotFound(res, new NotExistError());
+  }
 };

backend/src/controllers/courseclass.js

 'use strict';
 
 const {
-    handleRequestWithInvalidRequestBody,
-    handleRequestWithInternalServerError,
-    handleRequestWithResourceItemNotFound,
-} = require("../util/common");
+  handleRequestWithInvalidRequestBody,
+  handleRequestWithInternalServerError,
+  handleRequestWithResourceItemNotFound,
+} = require('../util/common');
 
 const {
   getCourseClass,
   createCourseClass,
-  updateCourseClass
+  updateCourseClass,
 } = require('../util/db/course-class');
 
-const {
-    NotExistError,
-} = require("../util/error");
+const { NotExistError } = require('../util/error');
 
-exports.getCourseClassData = async(req, res) => {
-    let getMany = true;
+exports.getCourseClassData = async (req, res) => {
+  let getMany = true;
 
-    if (req.params.id) {
-        getMany = false;
-    }
+  if (req.params.id) {
+    getMany = false;
+  }
 
-    try {
-        const courseClasses = await getCourseClass(req, getMany);
-        res.json(courseClasses);
-    } catch (error){
-        console.error(error);
+  try {
+    const courseClasses = await getCourseClass(req, getMany);
+    res.json(courseClasses);
+  } catch (error) {
+    console.error(error);
 
-        if (error instanceof NotExistError) {
-            handleRequestWithResourceItemNotFound(res, error);
-        } else {
-            handleRequestWithInternalServerError(res, error);
-        }
+    if (error instanceof NotExistError) {
+      handleRequestWithResourceItemNotFound(res, error);
+    } else {
+      handleRequestWithInternalServerError(res, error);
     }
+  }
 };
 
-exports.createCourseClassData = async(req, res) => {
+exports.createCourseClassData = async (req, res) => {
   const {
     courseId,
     lecturerId,
@@ -46,7 +44,7 @@ exports.createCourseClassData = async(req, res) => {
     participantCount,
     semester,
     status,
-    courseClassDefaultSchedules
+    courseClassDefaultSchedules,
   } = req.body;
 
   const newCourseClass = {
@@ -57,7 +55,7 @@ exports.createCourseClassData = async(req, res) => {
     participantCount,
     semester,
     status,
-    courseClassDefaultSchedules
+    courseClassDefaultSchedules,
   };
 
   try {
@@ -70,15 +68,12 @@ exports.createCourseClassData = async(req, res) => {
 };
 
 exports.updateCourseClass = async (req, res) => {
-    try {
-        const {
-            courseClass,
-            changeset
-        } = req.body;
+  try {
+    const { courseClass, changeset } = req.body;
 
-        const updatedStudyPlan = await updateCourseClass(courseClass, changeset);
-        res.json(updatedStudyPlan);
-    } catch (error) {
-        handleRequestWithInternalServerError(res, error);
-    }
-};
\ No newline at end of file
+    const updatedStudyPlan = await updateCourseClass(courseClass, changeset);
+    res.json(updatedStudyPlan);
+  } catch (error) {
+    handleRequestWithInternalServerError(res, error);
+  }
+};

backend/src/controllers/faculty.js

 const Faculty = require('../models/index')['Faculty'];
 
-exports.getAllFacultyData = async(req, res) => {
+exports.getAllFacultyData = async (req, res) => {
   let faculties = await Faculty.findAll();
   res.json(faculties);
 };

backend/src/controllers/lecturer.js

-const {
-  Lecturer,
-  SkillGroup,
-  Student,
-  Major,
-} = require('../models/index');
+const { Lecturer, SkillGroup, Student, Major } = require('../models/index');
 const { getAllLecturers } = require('../util/db/lecturer');
 const { LecturerNotFoundError } = require('../util/error');
 const {
   handleRequestWithResourceItemNotFound,
-  handleRequestWithInternalServerError
+  handleRequestWithInternalServerError,
 } = require('../util/common');
 
-exports.getAllLecturer = async(req, res) => {
+exports.getAllLecturer = async (req, res) => {
   const { opts } = req.body;
 
   try {
@@ -27,7 +22,7 @@ exports.getAllLecturer = async(req, res) => {
   }
 };
 
-exports.getLecturerData = async(req, res) => {
+exports.getLecturerData = async (req, res) => {
   const foundLecturer = await Lecturer.findOne({
     where: {
       userId: req.params.id,
@@ -39,32 +34,31 @@ exports.getLecturerData = async(req, res) => {
       },
       {
         model: Student,
-        as: 'advisedStudents'
-      }
+        as: 'advisedStudents',
+      },
     ],
-  }).catch(err => {
+  }).catch((err) => {
     handleRequestWithInternalServerError(res, err);
   });
 
-  if (foundLecturer){
+  if (foundLecturer) {
     res.json(foundLecturer);
   } else {
-    handleRequestWithResourceItemNotFound(res, new LecturerNotFoundError())
+    handleRequestWithResourceItemNotFound(res, new LecturerNotFoundError());
   }
 };
 
-exports.updateLecturerData = async(req, res) => {
+exports.updateLecturerData = async (req, res) => {
   const foundLecturer = await Lecturer.update(req.body, {
     where: {
       userId: req.params.id,
     },
     returning: true,
-  }).catch(err => {
-    res.status(400)
-        .json({
-          status: 400,
-          message: 'Something wrong with your payload.',
-        });
+  }).catch((err) => {
+    res.status(400).json({
+      status: 400,
+      message: 'Something wrong with your payload.',
+    });
   });
 
   if (!foundLecturer.includes(0)) {
@@ -73,10 +67,9 @@ exports.updateLecturerData = async(req, res) => {
       message: 'Lecturer data updated.',
     });
   } else {
-    res.status(400)
-        .json({
-        status: 400,
-        message: 'Lecturer doesn\'t exist.',
-      });
+    res.status(400).json({
+      status: 400,
+      message: "Lecturer doesn't exist.",
+    });
   }
 };

backend/src/controllers/major.js

 const Major = require('../models/index')['Major'];
 
-exports.getAllMajorData = async(req, res) => {
+exports.getAllMajorData = async (req, res) => {
   let majors;
 
-  if (req.query.facultyId){
+  if (req.query.facultyId) {
     majors = await Major.findAll({
       where: {
         facultyId: req.query.facultyId,

backend/src/controllers/skillgroup.js

 const SkillGroup = require('../models/index')['SkillGroup'];
 
-exports.getAllSkillGroupData = async(req, res) => {
+exports.getAllSkillGroupData = async (req, res) => {
   let skillGroups;
 
-  if (req.query.majorId){
+  if (req.query.majorId) {
     skillGroups = await SkillGroup.findAll({
       where: {
         majorId: req.query.majorId,

backend/src/controllers/student.js

 'use strict';
-const {
-  Student,
-} = require('../models/index');
+const { Student } = require('../models/index');
 const { updateStudyPlanCourse } = require('../util/db/study-plan');
 
-const {
-  NotExistError
-} = require('../util/error');
+const { NotExistError } = require('../util/error');
 
 const {
   handleRequestWithInternalServerError,
-  handleRequestWithResourceItemNotFound
+  handleRequestWithResourceItemNotFound,
 } = require('../util/common');
 
 const {
@@ -19,31 +15,31 @@ const {
   getHistoricalTranscript,
   getStudentIP,
   getStudentIPK,
-  getStudentNR
+  getStudentNR,
 } = require('../util/db/student');
 
-exports.getStudentData = async(req, res) => {
+exports.getStudentData = async (req, res) => {
   const { opts } = req;
 
   try {
     const student = await getStudent(opts);
 
-    if (req.includeTranscript.toLowerCase() === "true"){
+    if (req.includeTranscript.toLowerCase() === 'true') {
       student.dataValues.studyPlans = await getHistoricalTranscript(student.id);
     }
 
-    if (req.includeScore.toLowerCase() === "true"){
+    if (req.includeScore.toLowerCase() === 'true') {
       const nr = await getStudentNR(student);
       const ip = await getStudentIP(student);
       const ipk = await getStudentIPK(student);
       student.dataValues.score = {
         nr,
         ip,
-        ipk
+        ipk,
       };
     }
 
-    if (req.includeCredits.toLowerCase() === "true"){
+    if (req.includeCredits.toLowerCase() === 'true') {
       student.dataValues.creditsTotal = await getCreditsTotal(student);
     }
 
@@ -57,18 +53,17 @@ exports.getStudentData = async(req, res) => {
   }
 };
 
-exports.updateStudentData = async(req, res) => {
+exports.updateStudentData = async (req, res) => {
   const foundStudent = await Student.update(req.body, {
     where: {
       userId: req.params.id,
     },
     returning: true,
-  }).catch(err => {
-    res.status(400)
-        .json({
-          status: 400,
-          message: 'Something wrong with your payload.',
-        });
+  }).catch((err) => {
+    res.status(400).json({
+      status: 400,
+      message: 'Something wrong with your payload.',
+    });
   });
 
   if (!foundStudent.includes(0)) {
@@ -77,11 +72,10 @@ exports.updateStudentData = async(req, res) => {
       message: 'Student data updated.',
     });
   } else {
-    res.status(400)
-        .json({
-          status: 400,
-          message: 'Student doesn\'t exist.',
-        });
+    res.status(400).json({
+      status: 400,
+      message: "Student doesn't exist.",
+    });
   }
 };
 
@@ -91,7 +85,7 @@ exports.updateStudentScore = async (req, res) => {
 
     const updatedStudyPlanCourse = await updateStudyPlanCourse(
       studyPlanCourse,
-      changeset
+      changeset,
     );
     res.json(updatedStudyPlanCourse);
   } catch (error) {

backend/src/controllers/study-plan.js

@@ -3,7 +3,7 @@ const {
   handleRequestWithInvalidRequestBody,
   handleRequestWithInternalServerError,
   handleRequestWithResourceItemNotFound,
-  checkRequiredParameter
+  checkRequiredParameter,
 } = require('../util/common');
 
 const {
@@ -18,7 +18,7 @@ const {
   NotExistError,
   StudyPlanExistError,
   ClassUnavailableError,
-  RequiredParameterUndefinedError
+  RequiredParameterUndefinedError,
 } = require('../util/error');
 
 exports.getStudyPlan = async (req, res) => {
@@ -37,7 +37,7 @@ exports.getStudyPlan = async (req, res) => {
   }
 };
 
-exports.createStudyPlanData = async(req, res) => {
+exports.createStudyPlanData = async (req, res) => {
   let newStudyPlan;
 
   try {
@@ -47,21 +47,21 @@ exports.createStudyPlanData = async(req, res) => {
       semester,
       status,
       notes,
-      studyPlanCourses
+      studyPlanCourses,
     } = req.body;
 
-    checkRequiredParameter({studentId, startYear, semester});
+    checkRequiredParameter({ studentId, startYear, semester });
 
     newStudyPlan = {
       studentId,
       startYear,
       semester,
       status,
-      notes
+      notes,
     };
 
     let creditsTotal = 0;
-    if (studyPlanCourses){
+    if (studyPlanCourses) {
       await checkClassAvailability(semester, startYear, studyPlanCourses);
       creditsTotal = await countTotalCredits(studyPlanCourses);
       newStudyPlan['studyPlanCourses'] = studyPlanCourses;
@@ -71,27 +71,24 @@ exports.createStudyPlanData = async(req, res) => {
 
     const studyPlans = await createStudyPlan(newStudyPlan);
     res.json(studyPlans);
-
   } catch (error) {
-    if (error instanceof NotExistError){
+    if (error instanceof NotExistError) {
       handleRequestWithResourceItemNotFound(res, error);
-    } else if (error instanceof StudyPlanExistError ||
-               error instanceof ClassUnavailableError ||
-               error instanceof RequiredParameterUndefinedError) {
+    } else if (
+      error instanceof StudyPlanExistError ||
+      error instanceof ClassUnavailableError ||
+      error instanceof RequiredParameterUndefinedError
+    ) {
       handleRequestWithInvalidRequestBody(res, error);
     } else {
       handleRequestWithInternalServerError(res, error);
     }
   }
-
-}
+};
 
 exports.updateStudyPlan = async (req, res) => {
   try {
-    const {
-      studyPlan,
-      changeset
-    } = req.body;
+    const { studyPlan, changeset } = req.body;
 
     const updatedStudyPlan = await updateStudyPlan(studyPlan, changeset);
     res.json(updatedStudyPlan);

backend/src/enums/attendance-status.js

 const AttendanceStatusEnum = Object.freeze({
-    name: 'AttendanceStatusEnum',
-    enums: {
-        PRESENT: 'PRESENT',
-        ABSENT: 'ABSENT',
-        SICK: 'SICK',
-        PERMITTED: 'PERMITTED',
-    }
-})
+  name: 'AttendanceStatusEnum',
+  enums: {
+    PRESENT: 'PRESENT',
+    ABSENT: 'ABSENT',
+    SICK: 'SICK',
+    PERMITTED: 'PERMITTED',
+  },
+});
 
 module.exports = AttendanceStatusEnum;

backend/src/enums/course-type.js

 const CourseTypeEnum = Object.freeze({
-    name: 'CourseTypeEnum',
-    enums: {
-        MANDATORY: 'WAJIB',
-        OPTIONAL: 'PILIHAN',
-    }
-})
+  name: 'CourseTypeEnum',
+  enums: {
+    MANDATORY: 'WAJIB',
+    OPTIONAL: 'PILIHAN',
+  },
+});
 
 module.exports = CourseTypeEnum;

backend/src/enums/courseclass-status.js

 const CourseClassStatusEnum = Object.freeze({
-    name: 'CourseClassStatusEnum',
-    enums: {
-        OPEN: 'OPEN',
-        CLOSED: 'CLOSED',
-    }
-})
-module.exports = CourseClassStatusEnum;
\ No newline at end of file
+  name: 'CourseClassStatusEnum',
+  enums: {
+    OPEN: 'OPEN',
+    CLOSED: 'CLOSED',
+  },
+});
+module.exports = CourseClassStatusEnum;

backend/src/enums/day.js

 const DayEnum = Object.freeze({
-    name: 'DayEnum',
-    enums: {
-        SUNDAY: {value: 0, name: 'SUNDAY'},
-        MONDAY: {value: 1, name: 'MONDAY'},
-        TUESDAY: {value: 2, name: 'TUESDAY'},
-        WEDNESDAY: {value: 3, name: 'WEDNESDAY'},
-        THURSDAY: {value: 4, name: 'THURSDAY'},
-        FRIDAY: {value: 5, name: 'FRIDAY'},
-        SATURDAY: {value: 6, name: 'SATURDAY'},
-    }
-})
+  name: 'DayEnum',
+  enums: {
+    SUNDAY: { value: 0, name: 'SUNDAY' },
+    MONDAY: { value: 1, name: 'MONDAY' },
+    TUESDAY: { value: 2, name: 'TUESDAY' },
+    WEDNESDAY: { value: 3, name: 'WEDNESDAY' },
+    THURSDAY: { value: 4, name: 'THURSDAY' },
+    FRIDAY: { value: 5, name: 'FRIDAY' },
+    SATURDAY: { value: 6, name: 'SATURDAY' },
+  },
+});
 module.exports = DayEnum;

backend/src/enums/endpoint.js

 const EndpointEnum = Object.freeze({
-  name: "EndpointEnum",
+  name: 'EndpointEnum',
   enums: {
-    AUTH: "/auth",
-    LECTURER: "/lecturer",
-    STUDENT: "/student",
-    FACULTY: "/faculty",
-    MAJOR: "/major",
-    SKILL_GROUP: "/skillgroup",
-    COURSE_CLASS: "/course-class",
-    COURSE: "/course",
-    STUDY_PLAN: "/study-plan",
-    COURSE_CLASS_MEETING: "/course-class-meeting",
-    SCORE: "/score",
+    AUTH: '/auth',
+    LECTURER: '/lecturer',
+    STUDENT: '/student',
+    FACULTY: '/faculty',
+    MAJOR: '/major',
+    SKILL_GROUP: '/skillgroup',
+    COURSE_CLASS: '/course-class',
+    COURSE: '/course',
+    STUDY_PLAN: '/study-plan',
+    COURSE_CLASS_MEETING: '/course-class-meeting',
+    SCORE: '/score',
   },
 });
 

backend/src/enums/gender.js

 const GenderEnum = Object.freeze({
-    name: 'GenderEnum',
-    enums: {
-        MALE: {short: 'M', name: 'MALE'},
-        FEMALE: {short: 'F', name: 'FEMALE'},
-    }
-})
-module.exports = GenderEnum;
\ No newline at end of file
+  name: 'GenderEnum',
+  enums: {
+    MALE: { short: 'M', name: 'MALE' },
+    FEMALE: { short: 'F', name: 'FEMALE' },
+  },
+});
+module.exports = GenderEnum;

backend/src/enums/index.js

@@ -5,15 +5,15 @@ const path = require('path');
 const basename = path.basename(__filename);
 const enums = {};
 
-fs
-    .readdirSync(__dirname)
-    .filter(file => {
-        return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
-    })
-    .forEach(file => {
-        const enumFile = require(path.join(__dirname, file));
-        enums[enumFile.name] = enumFile.enums;
-    });
+fs.readdirSync(__dirname)
+  .filter((file) => {
+    return (
+      file.indexOf('.') !== 0 && file !== basename && file.slice(-3) === '.js'
+    );
+  })
+  .forEach((file) => {
+    const enumFile = require(path.join(__dirname, file));
+    enums[enumFile.name] = enumFile.enums;
+  });
 
 module.exports = enums;
-