Add Check For Empty Fields in Questions

- Now instead of a Bool, an Array is returned for Add and Update Question Methods. If the length of this array is 0, that means addition or update of the Question was successful without any errors.
- If length > 0, All the errors/causes can be iterated through, and the first one can be shown to the user
- Updated Formatting

Author: Jai2501

peer-prep/src/Components/QuestionList/QuestionForm.jsx

@@ -11,7 +11,9 @@ export const QuestionForm = ({qId, addQuestion, setAddQ, setQId, questionNumber}
   const handleSubmit = (toggleAddQ, addQ) => e => {
     e.preventDefault();
     toggleAddQ(false);
-    addQ(title, difficulty, topic, description)
+
+    const response = addQ(title, difficulty, topic, description);
+    return response; // If array length is 0, then successful, else can index through it for errors
   }
   return (
     <div className="form-container">

peer-prep/src/Components/QuestionList/QuestionList.jsx

@@ -25,7 +25,8 @@ export const Questions = () => {
     updateLocalDatabase();
     updateStates();
 
-    console.log("Is Additon Successful: " + isAddedSuccessfully);
+    console.log("Is Additon Successful: " + (isAddedSuccessfully.length === 0));
+    console.log("Errors While Adding: " + (isAddedSuccessfully.length === 0 ? "None" : isAddedSuccessfully))
 
     return isAddedSuccessfully;
   }
@@ -50,7 +51,8 @@ export const Questions = () => {
     updateLocalDatabase();
     updateStates();
 
-    console.log("Is Update Successful: " + isUpdateSuccessful);
+    console.log("Is Update Successful: " + (isUpdateSuccessful.length === 0));
+    console.log("Errors While Updating: " + (isUpdateSuccessful.length === 0 ? "None" : isUpdateSuccessful))
 
     return isUpdateSuccessful;
   }

peer-prep/src/DataModel/QuestionDatabase.js

@@ -1,85 +1,100 @@
 // A Class that stores and encapsulates Database Features
 
 class QuestionDatabase {
-    constructor() {
-        this.database = new Map();
-    }
+  static DUPLICATE_QUESTION_MESSAGE = "The Entered Question Already Exists";
+
+  constructor() {
+    this.database = new Map();
+  }
+
+  setDatabase(database) {
+    this.database = database;
+  }
+
+  clearDatabase() {
+    this.database = new Map();
+  }
+
+  addQuestion(questionToAdd) {
+    const emptyFields = questionToAdd.isQuestionValid();
 
-    setDatabase(database) {
-        this.database = database;
+    if (emptyFields.length !== 0) {
+      return emptyFields; // Question Has Empty Fields
     }
 
-    clearDatabase() {
-        this.database = new Map();
+    if (!this.isDuplicateQuestion(questionToAdd, true)) {
+      this.database.set(questionToAdd.id, questionToAdd);
+
+      return []; // Implies Question Added Successfully
     }
 
-    addQuestion(questionToAdd) {
-        if (!this.isDuplicateQuestion(questionToAdd, true)) {
-            this.database.set(questionToAdd.id, questionToAdd);
+    return [QuestionDatabase.DUPLICATE_QUESTION_MESSAGE]; // Question is Duplicate
+  }
 
-            return true;
-        }
+  deleteQuestion(questionId) {
+    if (this.database.has(questionId)) {
+      this.database.delete(questionId);
 
-        return false
+      return true;
     }
 
-    deleteQuestion(questionId) {
-        if (this.database.has(questionId)) {
-            this.database.delete(questionId);
+    return false;
+  }
 
-            return true;
-        }
+  updateQuestion(questionToUpdate) {
+    const emptyFields = questionToUpdate.isQuestionValid();
 
-        return false;
+    if (emptyFields.length !== 0) {
+      return emptyFields; // Question Has Empty Fields
     }
 
-    updateQuestion(questionToUpdate) {
-        if (!this.isDuplicateQuestion(questionToUpdate, false)) {
-            this.database.set(questionToUpdate.id, questionToUpdate);
-            return true;
-        }
+    if (!this.isDuplicateQuestion(questionToUpdate, false)) {
+      this.database.set(questionToUpdate.id, questionToUpdate);
 
-        return false;
+      return []; // Implies Question Updated Successfully
     }
 
-    getAllQuestions() {
-        var questionList = [];
+    return [QuestionDatabase.DUPLICATE_QUESTION_MESSAGE]; // Question is Duplicate
+  }
 
-        for (const [key, value] of this.database) {
-            questionList.push(value);
-        }
+  getAllQuestions() {
+    var questionList = [];
 
-        return questionList;
+    for (const [key, value] of this.database) {
+      questionList.push(value);
     }
 
-    isDuplicateQuestion(questionToCheck, toCheckId) {
-        // Ensure Unique ID when adding questions
-        if (this.database.has(questionToCheck.id) && toCheckId) {
-            return true;
-        }
+    return questionList;
+  }
 
-        var questionList = this.getAllQuestions();
+  isDuplicateQuestion(questionToCheck, toCheckId) {
+    // Ensure Unique ID when adding questions
+    if (this.database.has(questionToCheck.id) && toCheckId) {
+      return true;
+    }
 
-        for (var i = 0; i < questionList.length; i++) {
-            if (questionToCheck.id === questionList[i].id) {
-                continue;
-            }
+    var questionList = this.getAllQuestions();
 
-            if (questionToCheck.title === questionList[i].title) {
-                return true;
-            }
+    for (var i = 0; i < questionList.length; i++) {
+      if (questionToCheck.id === questionList[i].id) {
+        continue;
+      }
 
-            if (questionToCheck.description === questionList[i].description) {
-                return true;
-            }
-        }
+      if (questionToCheck.title === questionList[i].title) {
+        return true;
+      }
 
-        return false;
+      if (questionToCheck.description === questionList[i].description) {
+        return true;
+      }
     }
 
-    toJSON() {
-        return this.database;
-    }
+    return false;
+  }
+
+  toJSON() {
+    return this.database;
+  }
 }
 
 export default QuestionDatabase;

peer-prep/src/DataModel/QuestionModel.js

@@ -1,39 +1,69 @@
 // Class that stores and encapsulates the Question and its related fields
 
 class QuestionModel {
-    constructor(id, title, description, complexity, category) {
-      this.id = id;
-      this.title = title;
-      this.description = description;
-      this.complexity = complexity;
-      this.category= category;
-    }
+  static QUESTION_FIELDS = {
+    ID: "Id",
+    TITLE: "Title",
+    DESCRIPTION: "Description",
+    COMPLEXITY: "Complexity",
+    CATEGORY: "Category",
+  };
 
-    updateQuestionTitle(newQuestionTitle) {
-        this.title = newQuestionTitle;
-    }
+  static ERROR_MESSAGE = " Is Empty";
 
-    updateQuestionDescription(newQuestionDescription) {
-        this.description = newQuestionDescription;
-    }
+  constructor(id, title, description, complexity, category) {
+    this.id = id;
+    this.title = title;
+    this.description = description;
+    this.complexity = complexity;
+    this.category = category;
+  }
 
-    updateQuestionComplexity(newQuestionComplexity) {
-        this.complexity = newQuestionComplexity;
-    }
+  isQuestionValid() {
+    let errors = [];
 
-    updateQuestionCategory(newQuestionCategory) {
-        this.category = newQuestionCategory;
-    }
+    for (const qField in QuestionModel.QUESTION_FIELDS) {
+      const fieldName = QuestionModel.QUESTION_FIELDS[qField].toLowerCase();
 
-    toJSON() {
-        return {
-            id: this.id,
-            title: this.title,
-            description: this.description,
-            complexity: this.complexity,
-            category: this.category,
-        };
+      if (
+        (typeof this[fieldName] === "string" &&
+          this[fieldName].trim() === "") ||
+        !this[fieldName]
+      ) {
+        errors.push(
+          QuestionModel.QUESTION_FIELDS[qField] + QuestionModel.ERROR_MESSAGE
+        );
+      }
     }
+
+    return errors;
+  }
+
+  updateQuestionTitle(newQuestionTitle) {
+    this.title = newQuestionTitle;
+  }
+
+  updateQuestionDescription(newQuestionDescription) {
+    this.description = newQuestionDescription;
+  }
+
+  updateQuestionComplexity(newQuestionComplexity) {
+    this.complexity = newQuestionComplexity;
+  }
+
+  updateQuestionCategory(newQuestionCategory) {
+    this.category = newQuestionCategory;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      title: this.title,
+      description: this.description,
+      complexity: this.complexity,
+      category: this.category,
+    };
+  }
 }
-  
+
 export default QuestionModel;