Feature/quiz module

both/collections/_schemas.js

@@ -1 +1,2 @@
 Schema = {};
+QuizzesSchema = {};

both/collections/questions.js

@@ -0,0 +1,91 @@
+Questions = new Mongo.Collection('questions');
+
+QuestionSchema = new SimpleSchema({
+    id: {
+        type: String,
+        optional: false,
+        unique: true
+    },
+    questionType: {
+        type:String,
+        optional: false
+    },
+    quizId: {
+        type:String,
+        optional: false
+    },
+    title: {
+        type:String,
+        optional: false
+    },
+    description : {
+        type:String,
+        optional: false
+    },
+    numberOfOptions: {
+
+        type: Number,
+        optional: true,
+        max: 10,
+        min: 2
+    },
+    optionTitles: {
+        label: "Options",
+        type: [Object],
+        optional: false,
+        autoform: {
+            type: "radio-with-text-input",
+            options: function(){
+                var optionsArray = [];
+
+                for ( var i=0; i < 8; i++){
+                    var option = Quiz.generateAnswerOption("", false, i)
+                    optionsArray.push(option);
+                }
+                return optionsArray;
+            }
+        },
+        custom: function() {
+            // This custom function renders an error, if this field is not equal to
+            // the new Password field supplied in the form.
+            var titlesValid = true;
+            var selectionFound = false;
+            for (var i = 0; i < this.value.length; i++){
+                var obj = this.value[i];
+                if (!obj.title){
+                    titlesValid = false;
+                    return "invalidQuestionTitles";
+                }
+                if (obj.isSelected){
+                    selectionFound = true;
+                }
+            }
+            if (!selectionFound){
+                return "invalidQuestionSelection";
+            }
+        }
+    },
+
+    "optionTitles.$.title": {
+        type:String,
+        optional: false
+    },
+
+    "optionTitles.$.isSelected": {
+        type:Boolean,
+        optional: false
+    },
+    "optionTitles.$.index":{
+        type:Number,
+        optional: false
+    },
+
+
+    options:{
+        label: "Options",
+        type: [Object],
+    }
+})
+
+
+Questions.attachSchema(QuestionSchema);

both/collections/quizzes.js

@@ -0,0 +1,35 @@
+Quizzes = new Mongo.Collection('quizzes');
+
+QuizzesSchema.AnswerOptionSchema = new SimpleSchema({
+    title: {
+        type:String,
+        optional: true,
+        defaultValue: ""
+    },
+    isCorrect: {
+        type: Boolean,
+        defaultValue: false
+    },
+});
+
+//This schema will validate the initial creation of a quiz
+QuizzesSchema.QuizzesSchema = new SimpleSchema({
+    title: {
+        type:String,
+        label: "Quiz Title",
+        min: 4,
+        max: 140
+    },
+    questions: {
+        type: [Object],
+        optional: true
+    },
+
+    lessonID: {
+        type:String,
+    },
+});
+
+Quizzes.attachSchema(QuizzesSchema.QuizzesSchema);
+
+

both/common.js

@@ -1,3 +1,6 @@
 SimpleSchema.messages({
-    "passwordMismatch": "Passwords do not match"
+    "passwordMismatch": "Passwords do not match",
+    "invalidQuestionSettings": "Invalid question settings",
+    "invalidQuestionTitles": "All options should be filled in",
+    "invalidQuestionSelection": "Please select an answer"
 });

both/quizModel.js

@@ -0,0 +1,197 @@
+Quiz = function(){
+    var quiz = this;
+    this.addNewQuestion = function(val){
+        //check if the question already exists
+        if (quiz.questions == undefined){
+            quiz.questions = [];
+        }
+        for (var q in quiz.questions){
+
+        };
+
+        quiz.questions.push(val);
+    };
+
+};
+
+Quiz.convertToQuizObject = function(object){
+
+    if (object == undefined) return;
+    var quiz = new Quiz();
+
+    quiz._id = object._id;
+    quiz.title = object.title;
+    quiz.lessonID = object.lessonID;
+    quiz.questions = object.questions;
+    quiz.userAttempts = object.userAttempts;
+
+    return quiz;
+};
+
+Quiz.generateQuestion = function(questionType, quizId ){
+    var question = new Object();
+    question.quizId = quizId;
+    question.id = Random.id(); //assign an id to the question - need this for checking and validating answers
+    question.questionType = questionType;
+
+    //if the question type is true-or-false, populate the answer options
+    if (question.questionType == QuizOptions.TRUE_OR_FALSE){
+        question.optionTitles = [];
+        var trueOption = Quiz.generateAnswerOption("True", false, 0);
+
+        question.optionTitles.push(trueOption);
+        var falseOption = Quiz.generateAnswerOption("False", false, 1);
+        question.optionTitles.push(falseOption);
+    };
+
+    question.description = "";
+    question.title = "";
+    question.options = [];
+    return question;
+};
+
+Quiz.generateAnswerOption = function (title, isSelected, index){
+    var option = {};
+    option.title = title;
+    option.isSelected = isSelected;
+    option.index = index;
+
+    return option
+}
+
+
+Object.defineProperty(Quiz, "_title", {
+    get: function title(){
+        return this._title;
+    },
+    set: function title(val){
+        this._title = val;
+    }
+});
+Object.defineProperty(Quiz, "_questions", {
+    get: function question(){
+        return this._questions;
+    },
+    set: function questions(val){
+        this._questions = val;
+    }
+});
+
+Object.defineProperty(Quiz, "_lessonID", {
+    get: function lessonID(){
+        return this._lessonIDs
+    },
+    set: function lessonID(val){
+        this._lessonID = val;
+    }
+});
+
+Object.defineProperty(Quiz, "_userAttempts", { //an array of objects containig user ids, date and result
+    get: function userAttempts(){
+        return this._userAttempts;
+    },
+    set: function userAttempts(val){
+        this._userAttempts = val;
+    }
+})
+
+
+
+
+QuizOptions = {};
+
+QuizOptions.MULTIPLE_CHOICE_SINGLE_ANSWER = "Multiple Choice - single answer";
+QuizOptions.MULTIPLE_CHOICE_MULTIPLE_ANSWERS = "Multiple Choice - multiple answers";
+QuizOptions.TRUE_OR_FALSE = "True or False";
+QuizOptions.QUESTION_TYPES =
+    [  QuizOptions.MULTIPLE_CHOICE_SINGLE_ANSWER,
+        QuizOptions.MULTIPLE_CHOICE_MULTIPLE_ANSWERS,
+        QuizOptions.TRUE_OR_FALSE
+    ];
+
+
+
+QuizQuestion = function() {};
+Object.defineProperty(QuizQuestion, "_questionType", {
+    get: function questionType() {
+        return this._quiztype;
+    },
+    set: function questionType(val) {
+        this._quiztype = val;
+    }
+});
+
+//array of lesson IDs - the quiz can be used in more than one lesson
+Object.defineProperty(QuizQuestion, "_quizId", {
+    get: function quizId(){
+        return this._quizId
+    },
+    set: function quizId(val){
+        this._lessonIDs = val;
+    }
+});
+
+Object.defineProperty(QuizQuestion, "_title", {
+    get: function title(){
+        return this._title;
+    },
+    set: function title(val){
+        this._title = val;
+    }
+});
+
+Object.defineProperty(QuizQuestion, "_description", {
+    get: function description(){
+        return this._description;
+    },
+    set: function description(val){
+        this._description = val;
+    }
+});
+
+Object.defineProperty(QuizQuestion, "_options", {
+    get: function options(){
+        return this._options;
+    },
+    set: function options(val){
+        this._questions = val;
+    }
+});
+
+Object.defineProperty(QuizQuestion, "_saved",{
+    get: function saved(){
+        return this._saved;
+    },
+    set: function saved(val){
+        this._saved = val;
+    }
+});
+
+Object.defineProperty(QuizQuestion, "_answered", {
+    get: function answered(){
+        return this._answered;
+    },
+    set: function answered(val){
+        this._answered = val;
+    }
+})
+
+Object.defineProperty(QuizQuestion, "_isMultipleAnswer", {
+    get: function isMultipleAnswer(){
+        return this._questionType == QuizOptions.MULTIPLE_CHOICE_MULTIPLE_ANSWERS;
+    }
+});
+
+Object.defineProperty(QuizQuestion, "_isSingleAnswer", {
+    get: function isSingleAnswer(){
+        return this._questionType == QuizOptions.MULTIPLE_CHOICE_SINGLE_ANSWER;
+    }
+});
+
+Object.defineProperty(QuizQuestion, "_isTrueOrFalse", {
+    get: function isTrueOrfalse(){
+        return this._questionType == QuizOptions.TRUE_OR_FALSE;
+    }
+})
+
+

client/helpers/editMode.js

@@ -2,3 +2,20 @@ Template.registerHelper('editMode', function () {
     // get edit mode session variable
     return Session.get('editMode');
 });
+
+Template.registerHelper('isEditingCurrentCourse', function() {
+    // Get reference to current router
+    var router = Router.current();
+
+    // Get Course ID from router
+    var currentCourseId = router.params._id;
+
+    // Get value of editing course session variable
+    var editingCourseId = Session.get('editingCourseId')
+
+    // See if user is editing current course
+    var editingCurrentCourse = (editingCourseId === currentCourseId);
+
+    // return true if user is editing this course
+    return editingCurrentCourse;
+});

client/templates/course/course.js

@@ -13,6 +13,10 @@ Template.course.created = function () {
 
   // Set the empty active lesson ID variable
   activeLessonID = new ReactiveVar(undefined);
+
+  //Set an ampty active quiz Id var
+  activeQuizID = new ReactiveVar(undefined);
+
 };
 
 Template.course.helpers({
@@ -24,5 +28,6 @@ Template.course.helpers({
     var course = Courses.findOne(instance.courseId);
 
     return course;
-  }
+  },
+
 });