Example #1
0
        public bool CheckAnswer(string answer)
        {
            return(answer.ToLower().Contains(CorrectAnswer.ToLower()) && (!(answer.ToLower().Contains("true") && answer.ToLower().Contains("false"))));

            /*above line is to remove case sensitivity in answers and make it so answers that contain the answer (like a duck instead of duck) still work while
             * While still disallowing the use of both true and false in the same answer to buypass the true false questions*/
        }
        void ReleaseDesignerOutlets()
        {
            if (CorrectAnswer != null)
            {
                CorrectAnswer.Dispose();
                CorrectAnswer = null;
            }

            if (false1 != null)
            {
                false1.Dispose();
                false1 = null;
            }

            if (false2 != null)
            {
                false2.Dispose();
                false2 = null;
            }

            if (false3 != null)
            {
                false3.Dispose();
                false3 = null;
            }

            if (QuestionField != null)
            {
                QuestionField.Dispose();
                QuestionField = null;
            }
        }
 public void StartGame()
 {
     for (int i = 1; i <= 4; i++)
     {
         CorrectAnswer.Add(i, random.Next(1, 7));
     }
 }
Example #4
0
        public override double CalculateScore(string answerProvided, out bool isCorrectAnswer, out bool isCompleteAnswer)
        {
            isCorrectAnswer  = false;
            isCompleteAnswer = false;

            if (string.IsNullOrEmpty(answerProvided))
            {
                return(0);
            }

            var answerIds  = answerProvided.ToLowerInvariant().Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            var correctIds = CorrectAnswer.ToLowerInvariant().Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

            if (answerIds.Length > correctIds.Length)
            {
                return(0);
            }

            var distance       = answerIds.LevenshteinDistance(correctIds);
            var penaltyWeights = new [] { 1, 0.75, 0.5, 0.4, 0.3, 0.25, 0.2 };
            var startIndex     = correctIds.Length - 1;
            var score          = ScoreAwarded;

            for (var i = distance - 1; i >= 0; i--)
            {
                score -= penaltyWeights[i];
            }

            isCompleteAnswer = answerIds.Length == correctIds.Length;
            isCorrectAnswer  = distance == 0;

            return(Math.Max(0, score));
        }
Example #5
0
        public override double CalculateScore(string answerProvided, out bool isCorrectAnswer, out bool isCompleteAnswer)
        {
            isCorrectAnswer  = false;
            isCompleteAnswer = false;
            if (string.IsNullOrEmpty(answerProvided))
            {
                return(0);
            }

            var score    = ScoreAwarded;
            var provided = new HashSet <string>(answerProvided.ToLowerInvariant().Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries));
            var correct  = new HashSet <string>(CorrectAnswer.ToLowerInvariant().Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries));

            if (provided.Count > correct.Count)
            {
                return(0);
            }

            var penaltyWeights = new [] { 1, 0.75, 0.5, 0.4, 0.3, 0.25, 0.2 };
            var penaltyIndex   = Math.Min(penaltyWeights.Length, correct.Count) - 1;

            foreach (var c in correct)
            {
                if (!provided.Contains(c))
                {
                    score       -= (ScoreAwarded * penaltyWeights[penaltyIndex]);
                    penaltyIndex = Math.Max(0, penaltyIndex - 1);
                }
            }
            isCorrectAnswer  = score == ScoreAwarded;
            isCompleteAnswer = provided.Count == correct.Count;
            return(Math.Max(0, score));
        }
        public ActionResult Index(InstructorModels.AddQuestionsModel model)
        {
            var      course = db.Courses.Single(x => x.Id == model.CourseId);
            Question que    = new Question {
                QuestionText = model.QuestionText, Course = course
            };
            Answer ans1 = new Answer {
                AnswerText = model.Answer1, Question = que
            };
            Answer ans2 = new Answer {
                AnswerText = model.Answer2, Question = que
            };
            Answer ans3 = new Answer {
                AnswerText = model.Answer3, Question = que
            };
            CorrectAnswer corAns = new CorrectAnswer {
                AnswerText = model.CorrectAnswer, Question = que
            };

            que.QuestionText = model.QuestionText;
            var user = db.AspNetUsers.Single(u => u.UserName == "*****@*****.**");

            db.Questions.Add(que);
            db.Answers.Add(ans1);
            db.Answers.Add(ans2);
            db.Answers.Add(ans3);
            db.CorrectAnswers.Add(corAns);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
    public void ValidateAnswer(CorrectAnswer opt)
    {
        if (actualState != TriviaGameplayState.QUESTION)
        {
            return;
        }

        timeToCompleteCounter = 0;

        if (opt == correctAnswer)
        {
            cantQuestionsAnswered++;
            questionsAnswered.Add(randomQuestion);
            Checks[cantQuestionsAnswered - 1].sprite = OkIcon;
            SFXManager.SharedInstance.PlaySFX(SFXType.SoundType.CORRECT);

            if (Checks.Count == cantQuestionsAnswered)
            {
                actualState = TriviaGameplayState.END;
                uiManager.WinGame();
                GameManager.SharedInstance.ChangeGameManager(GameManager.GameState.GAME_OVER);
            }
            else
            {
                NewQuestion();
            }
        }
        else
        {
            FailAnswer();
        }
    }
 private void CopyAnswerArray()
 {
     for (int i = 0; i < 4; i++)
     {
         CheckForDoubles[i] = CorrectAnswer.ElementAt(i).Value;
     }
 }
Example #9
0
        public void SaveQuestionEditModelIntoDb(QuestionEditModel _model)
        {
            Question      _question;
            Answer        _answer;
            CorrectAnswer _correctAnswer;
            List <Answer> _answers;

            _question = new Question()
            {
                Text   = _model.Name,
                TestId = _model.Id,
            };
            _dataManager.Questions.SetQuestionIntoDb(_question);

            for (int i = 0; i < _model.AnswerEditModels.Count; i++)
            {
                _answer            = new Answer();
                _answer.Text       = _model.AnswerEditModels[i].Name;
                _answer.QuestionId = _question.Id;
                _dataManager.Answers.SaveAnswer(_answer);

                if (_model.AnswerEditModels[i].Correct)
                {
                    _correctAnswer = new CorrectAnswer()
                    {
                        QuestionId = _question.Id,
                        AnswerId   = _answer.Id,
                    };
                    _dataManager.CorrectAnswers.SetCorrectAnswerIntoDb(_correctAnswer);
                }
            }
        }
        public bool GetCorrectPropertyByQuestionAndAnswerIds(int questionId, int answerId)
        {
            List <CorrectAnswer> _answers      = _dataManager.CorrectAnswers.GetAllCorrectAnswersByQuestionId(questionId);
            CorrectAnswer        currentAnswer = _answers.Find(x => x.AnswerId == answerId);
            bool correct = currentAnswer != null ? true : false;

            return(correct);
        }
        public ActionResult DeleteConfirmed(int id)
        {
            CorrectAnswer correctAnswer = db.CorrectAnswers.Find(id);

            db.CorrectAnswers.Remove(correctAnswer);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Example #12
0
 protected override void InternalValidate()
 {
     base.InternalValidate();
     if (CorrectAnswer.IsNull())
     {
         AddError(CORRECT_ANSWER_PROPERTY, CORRECT_ANSWER_PROPERTY_ERROR_TEXT);
     }
 }
Example #13
0
 public override object GetQuestionData(string randomizationSeed)
 {
     return(new
     {
         Choose = CorrectAnswer.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Length,
         Options = SortList(Options, randomizationSeed)
     });
 }
Example #14
0
 internal virtual void Grade()
 {
     if (UserInput.ToLower() == CorrectAnswer.ToLower())
     {
         IsCorrect = true;
     }
     else
     {
         IsCorrect = false;
     }
 }
 public ActionResult Edit([Bind(Include = "Id,Answer,PracticePracticeId")] CorrectAnswer correctAnswer)
 {
     if (ModelState.IsValid)
     {
         db.Entry(correctAnswer).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.PracticePracticeId = new SelectList(db.Practices, "PracticeId", "PracticeName", correctAnswer.PracticePracticeId);
     return(View(correctAnswer));
 }
Example #16
0
 public void SetCorrectAnswerIntoDb(CorrectAnswer correct)
 {
     if (correct.QuestionId == 0 && correct.AnswerId == 0)
     {
         IsSetCorrectAnswerIntoDb = true;
     }
     else
     {
         IsSetCorrectAnswerIntoDb = false;
     }
 }
        public ActionResult Create([Bind(Include = "Id,Answer,PracticePracticeId")] CorrectAnswer correctAnswer)
        {
            if (ModelState.IsValid)
            {
                db.CorrectAnswers.Add(correctAnswer);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.PracticePracticeId = new SelectList(db.Practices, "PracticeId", "PracticeName", correctAnswer.PracticePracticeId);
            return(View(correctAnswer));
        }
        private void SetBlackPegs()
        {
            int counter = 0;

            for (int i = 0; i < CorrectAnswer.Count; i++)
            {
                if (SortedAnswerArray[i] == CorrectAnswer.ElementAt(i).Value)
                {
                    HintToAnswer[counter] = Brushes.Black;
                    counter++;
                }
            }
        }
        // GET: CorrectAnswers/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            CorrectAnswer correctAnswer = db.CorrectAnswers.Find(id);

            if (correctAnswer == null)
            {
                return(HttpNotFound());
            }
            return(View(correctAnswer));
        }
        // GET: CorrectAnswers/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            CorrectAnswer correctAnswer = db.CorrectAnswers.Find(id);

            if (correctAnswer == null)
            {
                return(HttpNotFound());
            }
            ViewBag.PracticePracticeId = new SelectList(db.Practices, "PracticeId", "PracticeName", correctAnswer.PracticePracticeId);
            return(View(correctAnswer));
        }
Example #21
0
 private void CheckIfCorrect()
 {
     if (UserAnswer == null)
     {
         IsCorrect = false;
     }
     else if (CorrectAnswer.Equals(UserAnswer))
     {
         IsCorrect = true;
     }
     else
     {
         IsCorrect = false;
     }
 }
Example #22
0
        public ExamBuilder WithQuestion(string text, CorrectAnswer correctAnswer)
        {
            _prototype.AddQuestion(
                order: _prototype.Questions.Count + 1,
                text: text,
                a: "a1",
                b: "b1",
                c: "c1",
                d: "d1",
                correctAnswer: correctAnswer,
                explanation: Guid.NewGuid().ToString()
                );

            return(this);
        }
Example #23
0
        public void Unbase64ify()
        {
            Category      = Category.FromBase64();
            Type          = Type.FromBase64();
            Difficulty    = Difficulty.FromBase64();
            Question      = Question.FromBase64();
            CorrectAnswer = CorrectAnswer.FromBase64();

            if (WrongAnswers != null)
            {
                var answers = new List <string>();
                foreach (var answer in WrongAnswers)
                {
                    answers.Add(answer.FromBase64());
                }
                WrongAnswers = answers;
            }
        }
        public bool AddCorrectAnswer(CorrectAnswerVM model)
        {
            if (model == null)
            {
                throw new Exception("There is no Entry!");
            }

            var answer = new CorrectAnswer
            {
                QuestionBankId       = model.questionBankId,
                QuestionOptionId     = model.questionOptionId,
                QuestionOptionTypeId = model.questionOptionTypeId,
            };

            _context.CorrectAnswer.Add(answer);

            return(_context.SaveChanges() > 0);
        }
 public void IsMatchTest()
 {
     {
         var rightAnswer = new CorrectAnswer("This is an apple.");
         rightAnswer.CorrectAnswerHelper = new CorrectAnswerHelperUsingRegex(rightAnswer);
         string s = null;
         Assert.False(rightAnswer.IsMatch(s));
         Assert.False(rightAnswer.IsMatch(""));
         Assert.False(rightAnswer.IsMatch(" "));
     }
     {
         var rightAnswer = new CorrectAnswer("This is an apple.");
         rightAnswer.CorrectAnswerHelper = new CorrectAnswerHelperUsingNormalizer(rightAnswer);
         string s = null;
         Assert.False(rightAnswer.IsMatch(s));
         Assert.False(rightAnswer.IsMatch(""));
         Assert.False(rightAnswer.IsMatch(" "));
     }
 }
Example #26
0
        public ActionResult CorrectAnswerPDF(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var categorie = db.QuestionToCategories.Where(i => i.CategorieId == id);

            if (categorie == null)
            {
                throw new HttpException(404, "Not found");
            }


            CorrectAnswerViewModel correctAnswerViewModel = new CorrectAnswerViewModel();

            correctAnswerViewModel.Categorie = db.Categories.Find(id);

            foreach (var item in categorie.ToList())
            {
                Question      question      = db.Questions.Find(item.QuestionId);
                CorrectAnswer correctAnswer = new CorrectAnswer();


                correctAnswerViewModel.CorrectAnswer.Add(new CorrectAnswer()
                {
                    Question = question.Contents,
                    Answer   = question.CorrectAnswer
                });
            }

            if (correctAnswerViewModel.CorrectAnswer.Count == 0)
            {
                throw new HttpException(404, "Not found");
            }

            return(new ViewAsPdf(correctAnswerViewModel)
            {
                FileName = "Odpowiedzi.pdf"
            });
        }
Example #27
0
        public override double CalculateScore(string answerProvided, out bool isCorrectAnswer, out bool isCompleteAnswer)
        {
            isCorrectAnswer  = false;
            isCompleteAnswer = false;
            if (string.IsNullOrEmpty(answerProvided))
            {
                return(0);
            }

            var coordinates = answerProvided.Split(',');

            if (coordinates.Length != 2)
            {
                return(0);
            }

            if (!int.TryParse(coordinates[0], out int userX))
            {
                return(0);
            }
            if (!int.TryParse(coordinates[1], out int userY))
            {
                return(0);
            }

            isCompleteAnswer = true;

            var answerCoordinates = CorrectAnswer.Split(',').Select(c => int.Parse(c)).ToArray();

            if (userX < answerCoordinates[0] || userX > answerCoordinates[0] + answerCoordinates[2])
            {
                return(0);
            }

            if (userY < answerCoordinates[1] || userY > answerCoordinates[1] + answerCoordinates[3])
            {
                return(0);
            }

            isCorrectAnswer = true;
            return(ScoreAwarded);
        }
Example #28
0
        internal void FillDialog()
        {
            /* * 0 - content, 1 .. 5 - answer, 6 - points, 7 - id*/
            Name = QuestionString[0];
            for (int i = 0; i < 5; i++)
            {
                string[] splitted = QuestionString[i + 1].Split('_');
                if (splitted.Length == 2)
                {
                    Answers.Add(splitted[0]);
                    CorrectAnswer.Add(splitted[1] == "1" ? true : false);
                }
                else
                {
                    Answers.Add("");
                    CorrectAnswer.Add(false);
                }
            }

            Length = Int32.Parse(QuestionString[6].Replace("-", ""));
        }
    private void NewQuestion()
    {
        do
        {
            randomQuestion = Random.Range(0, Questions.Count);
        }while (questionsAnswered.Contains(randomQuestion));

        txtQuestion.text = Questions[randomQuestion].QuestionString;
        int randomOrder = Random.Range(0, 2);

        correctAnswer = (CorrectAnswer)randomOrder;

        if (correctAnswer == CorrectAnswer.LEFT)
        {
            txtAnswer1.text = Questions[randomQuestion].CorrectAnswer;
            txtAnswer2.text = Questions[randomQuestion].FakeAnswer;
        }
        else
        {
            txtAnswer2.text = Questions[randomQuestion].CorrectAnswer;
            txtAnswer1.text = Questions[randomQuestion].FakeAnswer;
        }
    }
Example #30
0
 public Question(
     Guid id,
     Exam exam,
     int order,
     string text,
     string a,
     string b,
     string c,
     string d,
     CorrectAnswer correctAnswer,
     string explanation
     )
 {
     Id            = id;
     Exam          = exam;
     Order         = order;
     Text          = text;
     A             = a;
     B             = b;
     C             = c;
     D             = d;
     CorrectAnswer = correctAnswer;
     Explanation   = explanation;
 }
        public void StartsWithTest()
        {
            var mondaiWords0 = new []
            {
                new MondaiWord("This"),
                new MondaiWord("is"),
            };
            var mondaiWords1 = new []
            {
                new MondaiWord("this"),
                new MondaiWord("is"),
            };
            var mondaiWords2 = new []
            {
                new MondaiWord("aaa"),
                new MondaiWord("This"),
                new MondaiWord("is"),
            };
            var mondaiWords3 = new []
            {
                new MondaiWord("This is"),
                new MondaiWord("an apple."),
            };

            {
                var rightAnswer = new CorrectAnswer("This is an apple.");
                rightAnswer.CorrectAnswerHelper = new CorrectAnswerHelperUsingRegex(rightAnswer);

                {
                    var s = MondaiWord.SimplyJoin(mondaiWords0);
                    Assert.AreEqual("This is", s);
                    var p = "^" + MondaiWord.GetRegexPattern(s);
                    Assert.AreEqual(@"^This\s+is", p);
                    StringAssert.IsMatch(p, rightAnswer.Text);
                }

                Assert.Throws<ArgumentNullException>(() => { rightAnswer.StartsWith(null); });
                Assert.True(rightAnswer.StartsWith(new MondaiWord[0]));

                Assert.True(rightAnswer.StartsWith(mondaiWords0));
                Assert.False(rightAnswer.StartsWith(mondaiWords1));
                Assert.False(rightAnswer.StartsWith(mondaiWords2));
                Assert.True(rightAnswer.StartsWith(mondaiWords3));
            }
            {
                var rightAnswer = new CorrectAnswer("This is an apple.");
                rightAnswer.CorrectAnswerHelper = new CorrectAnswerHelperUsingNormalizer(rightAnswer);

                Assert.Throws<ArgumentNullException>(() => { rightAnswer.StartsWith(null); });
                Assert.True(rightAnswer.StartsWith(new MondaiWord[0]));

                Assert.True(rightAnswer.StartsWith(mondaiWords0));
                Assert.False(rightAnswer.StartsWith(mondaiWords1));
                Assert.False(rightAnswer.StartsWith(mondaiWords2));
                Assert.True(rightAnswer.StartsWith(mondaiWords3));
            }
        }
Example #32
0
 public Question(int id, QuestionType qt, string text, CorrectAnswer ca) : this(id, qt, text) {
     CorrectAnswers = ca;
 }
Example #33
0
 public void SetCorrectAnswer(CorrectAnswer letter) => CorrectAnswers = letter;
 public void Test0()
 {
     {
         var rightAnswer = new CorrectAnswer("This is an apple.");
         rightAnswer.CorrectAnswerHelper = new CorrectAnswerHelperUsingRegex(rightAnswer);
         Assert.AreEqual("This is an apple.", rightAnswer.Text);
         Assert.AreEqual(@"This\s+is\s+an\s+apple\s*\.", ((CorrectAnswerHelperUsingRegex)rightAnswer.CorrectAnswerHelper).RegexPattern);
         Assert.True(rightAnswer.IsMatch("This is an apple."));
         Assert.True(rightAnswer.IsMatch(new []
         {
             new MondaiWord("This"),
             new MondaiWord("is"),
             new MondaiWord("an"),
             new MondaiWord("apple"),
             new MondaiWord("."),
         }));
     }
     {
         var rightAnswer = new CorrectAnswer("This is an apple.");
         rightAnswer.CorrectAnswerHelper = new CorrectAnswerHelperUsingNormalizer(rightAnswer);
         Assert.AreEqual("This is an apple.", rightAnswer.Text);
         Assert.True(rightAnswer.IsMatch("This is an apple."));
         Assert.True(rightAnswer.IsMatch(new []
         {
             new MondaiWord("This"),
             new MondaiWord("is"),
             new MondaiWord("an"),
             new MondaiWord("apple"),
             new MondaiWord("."),
         }));
     }
     {
         var rightAnswer = new CorrectAnswer(@"""Aren't you swim?"" ""No, I can't.""");
         Assert.True(rightAnswer.IsMatch(@"""Aren't  you  swim ?"" ""No , I can't."""));
     }
 }
Example #35
0
        private void NextIssue(object o)
        {
            CurrentIssue.IsAnswered = true;
            // Save answer
            var isCorrect = false;

            switch (IssueType)
            {
            case IssueTypes.Selection:
            {
// ReSharper disable PossibleNullReferenceException
                var selectedByUserIssueIndex = Answers.IndexOf(Answers.First(a => a.SelectedByUser)) + 1;
                var correctIssueIndex        = CurrentIssue.Answers.IndexOf(CurrentIssue.Answers.First(a => a.IsCorrect)) + 1;
// ReSharper restore PossibleNullReferenceException
                AppController.UserInfo.Answers[_currentSet].Add(new UserAnswer
                    {
                        IsCorrect     = (isCorrect = selectedByUserIssueIndex == correctIssueIndex),
                        Answer        = selectedByUserIssueIndex.ToString("0"),
                        CorrectAnswer = correctIssueIndex.ToString("0"),
                        Points        = CurrentIssue.CorrectAnswerPoints
                    });
            }
            break;

            case IssueTypes.SelectionInImage:
                AppController.UserInfo.Answers[_currentSet].Add(new UserAnswer
                {
                    IsCorrect     = (isCorrect = UserAnswer == CorrectAnswer),
                    Answer        = UserAnswer.ToString("0"),
                    CorrectAnswer = CorrectAnswer.ToString("0"),
                    Points        = CurrentIssue.CorrectAnswerPoints
                });
                break;

            case IssueTypes.ImageSelection:
            {
// ReSharper disable AssignNullToNotNullAttribute
                var userSelection    = Answers.Where(a => a.SelectedByUser).Select(a => a.OriginalImageFileName).ToList();
                var correctSelection = CurrentIssue.Answers.Where(a => a.Selected).Select(a => a.ImageFileName).ToList();
// ReSharper restore AssignNullToNotNullAttribute
                AppController.UserInfo.Answers[_currentSet].Add(new UserAnswer
                    {
                        IsCorrect =
                            (isCorrect =
                                 userSelection.Count == correctSelection.Count &&
                                 userSelection.All(correctSelection.Contains)),
                        Answer        = string.Empty,
                        CorrectAnswer = string.Empty,
                        Points        = CurrentIssue.CorrectAnswerPoints
                    });
            }
            break;

            case IssueTypes.Order:
                AppController.UserInfo.Answers[_currentSet].Add(new UserAnswer
                {
// ReSharper disable AssignNullToNotNullAttribute
                    IsCorrect = (isCorrect = !Answers.Where((answer, index) => answer.OrderNo != index).Any()),
// ReSharper restore AssignNullToNotNullAttribute
                    Answer        = string.Empty,
                    CorrectAnswer = string.Empty,
                    Points        = CurrentIssue.CorrectAnswerPoints
                });
                break;

            case IssueTypes.Placement:
                isCorrect = PlacementCorrectAnswer1.Count == CurrentIssue.PlacementCorrectAnswer1.Count &&
                            !PlacementCorrectAnswer1.Where(
                    (imageFileName, index) =>
                    imageFileName !=
                    Path.Combine(_currentDirectory, CurrentIssue.PlacementCorrectAnswer1[index])).Any();
                isCorrect &= PlacementCorrectAnswer2.Count == CurrentIssue.PlacementCorrectAnswer2.Count &&
                             !PlacementCorrectAnswer2.Where(
                    (imageFileName, index) =>
                    imageFileName !=
                    Path.Combine(_currentDirectory, CurrentIssue.PlacementCorrectAnswer2[index])).Any();
                isCorrect &= NumberOfShelves < 3 ||
                             (PlacementCorrectAnswer3.Count == CurrentIssue.PlacementCorrectAnswer3.Count &&
                              !PlacementCorrectAnswer3.Where(
                                  (imageFileName, index) =>
                                  imageFileName !=
                                  Path.Combine(_currentDirectory, CurrentIssue.PlacementCorrectAnswer3[index])).Any());
                isCorrect &= NumberOfShelves < 4 ||
                             (PlacementCorrectAnswer4.Count == CurrentIssue.PlacementCorrectAnswer4.Count &&
                              !PlacementCorrectAnswer4.Where(
                                  (imageFileName, index) =>
                                  imageFileName !=
                                  Path.Combine(_currentDirectory, CurrentIssue.PlacementCorrectAnswer4[index])).Any());
                isCorrect &= NumberOfShelves < 5 ||
                             (PlacementCorrectAnswer5.Count == CurrentIssue.PlacementCorrectAnswer5.Count &&
                              !PlacementCorrectAnswer4.Where(
                                  (imageFileName, index) =>
                                  imageFileName !=
                                  Path.Combine(_currentDirectory, CurrentIssue.PlacementCorrectAnswer5[index])).Any());

                AppController.UserInfo.Answers[_currentSet].Add(new UserAnswer
                {
                    IsCorrect     = isCorrect,
                    Answer        = string.Empty,
                    CorrectAnswer = string.Empty,
                    Points        = CurrentIssue.CorrectAnswerPoints
                });
                break;
            }

            if (isCorrect)
            {
                AppController.UserInfo.CorrectAnswers[_currentSet]++;
                AppController.UserInfo.CorrectAnswerPoints[_currentSet] += CurrentIssue.CorrectAnswerPoints;
            }
            else
            {
                AppController.UserInfo.IncorrectAnswers[_currentSet]++;
            }
            // Go to the either next issue or result page
            var issue = GetNextIssue();

            if (issue == null)
            {
                var page = o as Page;

                if (page != null && page.NavigationService != null)
                {
                    page.NavigationService.Navigate(AppController.GetPage(ApplicationPages.ResultPage));
                }
            }
            else
            {
                SetNewIssue(issue);
            }
        }