Introduction

Consider the class diagram below. This assignment will map the following classes to an equivalent Mongo database: Student , Answer , Question , MultipleChoice , TrueFalse , Question , QuizWidget . Ignore all other classes. Feel free to add additional fields, but do not rename the existing variable names.

Create and connect to a MongoDB database

In file /data/db.js use Mongoose.js to connect to a database called white-board .

Implement Mongoose schemas

It is a good practice to implement Mongoose schemas in their own files allowing them to be reused by and defined in terms of other schemas. Create the following schemas in directory /data/models/ based on the class diagram provided. Instead of letting MongoDB create the _id unique identifiers for you, instead declare your own _id attribute in your schemas as Number. This will allow using our own IDs which will simplify testing. Use equivalent JavaScript and Mongoose data types where appropriate. Feel free to make any changes/additions where necessary.

Implement inheritance schema

Implement base class Question and derived classes TrueFalse and MultipleChoice as an inheritance relationship implemented using a denormalized strategy, i.e., use a single schema to represent all three classes in file /data/models/question.schema.server.js . Use a discrimination field called questionType with required enumerated values MULTIPLE_CHOICE and TRUE_FALSE to distinguish between the question types. Instead of the schema for the Question class having the fields of MultipleChoice and TrueFalse classes, model these as embedded schemas accessible through schema properties multipleChoice and trueFalse . Store question instances in a collection called questions. Note the schema is declaring an _id attribute to allow providing our own ID for testing. Feel free to use/modify/ignore the example below as an implementation of the schema.

Implement one to many relationship

In schema file /data/models/quiz-widget.schema.server.js , implement the one to many relationship between QuizWidget and Question classes. Use an array of ObjectIds to hold the IDs of the questions that make up the widget. Feel free to use/modify/ignore the example below as an implementation of the schema.

const questionSchema = require( ./question.schema.server ) const questionWidgetSchema = mongoose . Schema ({

questions : [{

type : mongoose . Schema . Types . ObjectId ,

ref : QuestionModel

}]

}, { collection : questionwidgets })

Implement many to many

Implement class Answer as a many to many association between classes Student and Question in Mongoose schema file /data/models/answer.schema.server.js . Feel free to use/modify/ignore the example below as an implementation of the schema.

Implement Mongoose data models

It is a good practice to implement Mongoose models for each collection in a separate file. This allow models to be used by and defined in terms of other models. In directory /data/models/ implement mongoose models for the following classes.

Feel free to use/modify/ignore the example below as an implementation of the student model.

Create DAOs for each of the data models

DAOs (Data Access Objects) encapsulate and modularize interaction with a database by providing a high level interface to the database. DAOs allow other parts of the application to interact with the database without bothering with the idiosyncrasies and minutiae of a particular database implementation or vendor.

In file called /data/daos/university.dao.server.js , create a DAO that implements the following API. If you prefer, feel free to breakup the DAO into several DAO files. The DAOs must use the Mongoose models implemented earlier. Feel free to modify the signature of the methods if appropriate and create additional methods if needed, i.e., you might prefer to pass the IDs of existing documents instead of document instances. Implement the following API:

1. truncateDatabase() removes all the data from the database. Note that you might need to remove documents in a particular order
2. populateDatabase() populates the database with test data as described in a later section
3. createStudent(student) inserts a student document
4. deleteStudent(id) removes student whose ID is id
5. createQuestion(question) inserts a question document
6. deleteQuestion(id) removes question whose ID is id
7. answerQuestion(studentId, questionId, answer) inserts an answer by student student for question question
8. deleteAnswer(id) removes answer whose ID is id

Implement the following finder methods

1. findAllStudents() retrieves all students
2. findStudentById(id) retrieves a single student document whose ID is id
3. findAllQuestions() retrieves all questions
4. findQuestionById(id) retrieves a single question document whose ID is id
5. findAllAnswers() retrieves all the answers
6. findAnswerById(id) retrieves a single answer document whose ID is id
7. findAnswersByStudent(studentId) retrieves all the answers for a student whose ID is studentId
8. findAnswersByQuestion(questionId) retrieves all the answers for a question whose ID is questionId

Feel free to use/modify/ignore the example below as an implementation of the student related DAO functions

createStudent = student => studentModel . save (student)

findAllStudents = () => studentModel . find ()

findStudentById = studentId => studentModel . findById (studentId) updateStudent = (studentId, student) => studentModel . update ({_id : studentId}, { $set : student}) deleteStudent = studentId => studentModel . remove ({_id : studentId}) module. exports = {

createStudent , findAllStudents , findStudentById , updateStudent , deleteStudent }

Populate the database with test data

In DAO function populateDatabase() , populate the database with the data described in the following sections

Create students

Use the DAO functions to create the following students. Use the IDs in the _id column as the IDs for the documents inserted.

Create questions

Use the DAO functions to create the following questions. Use the IDs in the _id column as the IDs for the documents inserted.

Create answers

Use the DAO functions to create the following questions. Use the IDs in the _id column as the IDs for the documents inserted. Use the IDs for students and questions listed in the table below.

Create a test suite

In a file called /test.js , create tests that validate your DAO, schemas, and models. The test suite should use the DAO functions truncateBatabase() and populateDatabase() to initialize the database to an initial state. It then should implement and use the following functions to validate the database is in the valid state The test.js implement and invoke the following functions in the right order. Note that you might need to use promises to ensure the order of operation.

1. truncateDatabase() uses DAOs truncateDatabase() function to remove all the data from the database
2. populateDatabase() uses DAOs populateDatabase() function to populate the database with test data
3. testStudentsInitialCount() uses DAO to validate there are 2 students initially
4. testQuestionsInitialCount() uses DAO to validate there are 4 questions initially
5. testAnswersInitialCount() uses DAO to validate there are 8 answers initially
6. testDeleteAnswer() uses DAO to remove Bobs answer for the multiple choice question What does ORM stand for? and validates the total number of questions is 7 and Bobs total number of questions is 3
7. testDeleteQuestion() uses DAO to remove true false question Is the following schema valid? and validates the total number of questions is 3
8. testDeleteStudent() uses DAO to remove student Bob and validates the total number of students

is 1